diff --git a/CHANGELOG.md b/CHANGELOG.md
index fc054e0be18..2642833569d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Features
 
+- Add opt-in `strictCallbackMode` to propagate user callback failures as SDK exception or error wrappers. Events containing these failures are silently excluded from capture, including when nested in another exception, to avoid sending data without callback filtering. Configure it through SDK options, `strict-callback-mode` in external configuration, or `io.sentry.strict-callback-mode` in the Android manifest. Disabled by default ([#6173](https://github.com/getsentry/sentry-java/pull/6173))
 - Add support for Android Navigation 3 through the new `sentry-android-navigation3` library ([#6233](https://github.com/getsentry/sentry-java/pull/6233))
   - Use `SentryNavEffect` to record navigation transactions, breadcrumbs, screen names, and additional context as your nav back stack changes.
   - See the [Navigation for Android docs](https://docs.sentry.io/platforms/android/integrations/navigation/) for additional details.
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 4405cd19309..456706724e7 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
@@ -300,6 +300,7 @@ private void startShakeDetection(final @NotNull Activity activity) {
                   if (dialog != null) {
                     onDialogGone(dialog);
                   }
+                  io.sentry.util.ExceptionUtils.maybeRethrow(e);
                   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/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index 7de5a0c2716..fc7119cec04 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 DSN = "io.sentry.dsn";
   static final String DEBUG = "io.sentry.debug";
+  static final String STRICT_CALLBACK_MODE = "io.sentry.strict-callback-mode";
   static final String DEBUG_LEVEL = "io.sentry.debug.level";
   static final String SAMPLE_RATE = "io.sentry.sample-rate";
   static final String ANR_ENABLE = "io.sentry.anr.enable";
@@ -256,6 +257,8 @@ static void applyMetadata(
 
       if (metadata != null) {
         options.setDebug(readBool(metadata, logger, DEBUG, options.isDebug()));
+        options.setStrictCallbackMode(
+            readBool(metadata, logger, STRICT_CALLBACK_MODE, options.isStrictCallbackMode()));
 
         if (options.isDebug()) {
           final @Nullable String level =
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 6932b6be3f6..5eb73ec8a35 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
@@ -116,7 +116,11 @@ private boolean isMaskingEnabled() {
         if (!beforeCaptureCallback.execute(event, hint, shouldDebounce)) {
           return event;
         }
-      } catch (Exception e) {
+      } catch (Exception | Error e) {
+        io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
+        if (e instanceof Error) {
+          throw (Error) e;
+        }
         options
             .getLogger()
             .log(
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 82916a248e6..e689442e129 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
@@ -145,6 +145,7 @@ public static void init(
             try {
               configuration.configure(options);
             } catch (Throwable t) {
+              io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, t);
               // let it slip, but log it
               options
                   .getLogger()
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 611db3c1345..04832f955c2 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
@@ -30,6 +30,7 @@
 import io.sentry.protocol.Feedback;
 import io.sentry.protocol.SentryId;
 import io.sentry.protocol.User;
+import io.sentry.util.CallbackUtils;
 import io.sentry.util.ExceptionUtils;
 import io.sentry.util.FileUtils;
 import io.sentry.util.LoadClass;
@@ -65,10 +66,14 @@ public class SentryUserFeedbackForm extends AlertDialog {
     this.resolvedFeedbackOptions =
         new SentryFeedbackOptions(Sentry.getCurrentScopes().getOptions().getFeedbackOptions());
     if (configuration != null) {
-      configuration.configure(context, resolvedFeedbackOptions);
+      CallbackUtils.run(
+          Sentry.getCurrentScopes().getOptions(),
+          () -> configuration.configure(context, resolvedFeedbackOptions));
     }
     if (configurator != null) {
-      configurator.configure(resolvedFeedbackOptions);
+      CallbackUtils.run(
+          Sentry.getCurrentScopes().getOptions(),
+          () -> configurator.configure(resolvedFeedbackOptions));
     }
     SentryIntegrationPackageStorage.getInstance().addIntegration("UserFeedbackWidget");
     maybeStartShakeDetection(context);
@@ -338,37 +343,44 @@ protected void onCreate(Bundle savedInstanceState) {
           final @NotNull Hint hint = new Hint();
           maybeAddImageAttachment(hint);
           final @NotNull SentryId id = Sentry.feedback().capture(feedback, hint);
-          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) {
-              try {
-                onSubmitSuccess.call(feedback);
-              } catch (Exception e) {
-                Sentry.getCurrentScopes()
-                    .getOptions()
-                    .getLogger()
-                    .log(SentryLevel.ERROR, "onSubmitSuccess callback threw an exception.", e);
+          try {
+            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) {
+                try {
+                  CallbackUtils.run(
+                      Sentry.getCurrentScopes().getOptions(), () -> onSubmitSuccess.call(feedback));
+                } catch (Exception e) {
+                  ExceptionUtils.maybeRethrow(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) {
-              try {
-                onSubmitError.call(feedback);
-              } catch (Exception e) {
-                Sentry.getCurrentScopes()
-                    .getOptions()
-                    .getLogger()
-                    .log(SentryLevel.ERROR, "onSubmitError callback threw an exception.", e);
+            } else {
+              final @Nullable SentryFeedbackOptions.SentryFeedbackCallback onSubmitError =
+                  feedbackOptions.getOnSubmitError();
+              if (onSubmitError != null) {
+                try {
+                  CallbackUtils.run(
+                      Sentry.getCurrentScopes().getOptions(), () -> onSubmitError.call(feedback));
+                } catch (Exception e) {
+                  ExceptionUtils.maybeRethrow(e);
+                  Sentry.getCurrentScopes()
+                      .getOptions()
+                      .getLogger()
+                      .log(SentryLevel.ERROR, "onSubmitError callback threw an exception.", e);
+                }
               }
             }
+          } finally {
+            cancel();
           }
-          cancel();
         });
 
     btnCancel.setText(feedbackOptions.getCancelButtonLabel());
@@ -388,13 +400,15 @@ public void setOnDismissListener(final @Nullable OnDismissListener listener) {
             // 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();
+              CallbackUtils.run(options, onFormClose);
             } catch (Exception e) {
+              ExceptionUtils.maybeRethrow(e);
               options
                   .getLogger()
                   .log(SentryLevel.ERROR, "onFormClose callback threw an exception.", e);
+            } finally {
+              currentReplayId = null;
             }
-            currentReplayId = null;
             if (delegate != null) {
               delegate.onDismiss(dialog);
             }
@@ -426,8 +440,9 @@ protected void onStart() {
     final @Nullable Runnable onFormOpen = feedbackOptions.getOnFormOpen();
     if (onFormOpen != null) {
       try {
-        onFormOpen.run();
+        CallbackUtils.run(options, onFormOpen);
       } catch (Exception e) {
+        ExceptionUtils.maybeRethrow(e);
         options.getLogger().log(SentryLevel.ERROR, "onFormOpen callback threw an exception.", e);
       }
     }
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 00753ee4c90..a6b365f1e01 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
@@ -95,7 +95,11 @@ public ViewHierarchyEventProcessor(final @NotNull SentryAndroidOptions options)
         if (!beforeCaptureCallback.execute(event, hint, shouldDebounce)) {
           return event;
         }
-      } catch (Exception e) {
+      } catch (Exception | Error e) {
+        io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
+        if (e instanceof Error) {
+          throw (Error) e;
+        }
         options
             .getLogger()
             .log(
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 612eb97946e..d1ecd9ba36e 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
@@ -57,6 +57,7 @@ public boolean dispatchTouchEvent(final @Nullable MotionEvent motionEvent) {
       try {
         handleTouchEvent(copy);
       } catch (Throwable e) {
+        io.sentry.util.ExceptionUtils.maybeRethrow(e);
         if (options != null) {
           options.getLogger().log(SentryLevel.ERROR, "Error dispatching touch event", 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 463b5d82ddb..ece09e0db81 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
@@ -42,6 +42,39 @@ class ManifestMetadataReaderTest {
 
   private val fixture = Fixture()
 
+  @Test
+  fun `strict callback mode defaults to false when metadata is absent`() {
+    ManifestMetadataReader.applyMetadata(
+      fixture.getContext(),
+      fixture.options,
+      fixture.buildInfoProvider,
+    )
+    assertThat(fixture.options.isStrictCallbackMode).isFalse()
+  }
+
+  @Test
+  fun `strict callback mode preserves programmatic value when metadata is absent`() {
+    fixture.options.isStrictCallbackMode = true
+    ManifestMetadataReader.applyMetadata(
+      fixture.getContext(),
+      fixture.options,
+      fixture.buildInfoProvider,
+    )
+    assertThat(fixture.options.isStrictCallbackMode).isTrue()
+  }
+
+  @Test
+  fun `strict callback mode reads true and false from manifest`() {
+    for (value in listOf(true, false)) {
+      fixture.options.isStrictCallbackMode = !value
+      ContextUtils.resetInstance()
+      val context =
+        fixture.getContext(bundleOf(ManifestMetadataReader.STRICT_CALLBACK_MODE to value))
+      ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+      assertThat(fixture.options.isStrictCallbackMode).isEqualTo(value)
+    }
+  }
+
   @BeforeTest
   fun `set up`() {
     ContextUtils.resetInstance()
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 635d7a308c5..bdf99de117f 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
@@ -314,6 +314,22 @@ class ScreenshotEventProcessorTest {
     assertNull(hint.screenshot)
   }
 
+  @Test
+  fun `strict capture failures propagate without attaching screenshot`() {
+    CurrentActivityHolder.getInstance().setActivity(fixture.activity)
+    fixture.options.isStrictCallbackMode = true
+    val processor = fixture.getSut(true)
+    for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+      fixture.options.setBeforeScreenshotCaptureCallback { _, _, _ -> throw failure }
+      val event = SentryEvent().apply { exceptions = listOf(SentryException()) }
+      val hint = Hint()
+      val thrown = kotlin.test.assertFails { processor.process(event, hint) }
+      assertThat(io.sentry.util.CallbackUtils.isCallbackException(thrown)).isTrue()
+      assertThat(thrown.cause).isSameInstanceAs(failure)
+      assertThat(hint.screenshot).isNull()
+    }
+  }
+
   @Test
   fun `when capture callback throws, skips screenshot and retains event`() {
     CurrentActivityHolder.getInstance().setActivity(fixture.activity)
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 95e50a85b14..18f54a6af07 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
@@ -106,6 +106,82 @@ class SentryUserFeedbackFormTest {
     fixture.mockedSentry.close()
   }
 
+  @Test
+  fun `strict submit callbacks propagate failures and close the form`() {
+    fixture.options.isStrictCallbackMode = true
+    for (success in listOf(false, true)) {
+      for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+        fixture.options.feedbackOptions.setOnSubmitSuccess { throw failure }
+        fixture.options.feedbackOptions.setOnSubmitError { throw failure }
+        whenever(fixture.mockFeedbackApi.capture(any<Feedback>(), anyOrNull()))
+          .thenReturn(if (success) SentryId() else SentryId.EMPTY_ID)
+        val sut = fixture.getSut()
+        sut.show()
+        sut
+          .findViewById<EditText>(R.id.sentry_dialog_user_feedback_edt_description)
+          .setText("message")
+        val thrown =
+          kotlin.test.assertFails {
+            sut.findViewById<Button>(R.id.sentry_dialog_user_feedback_btn_send).performClick()
+          }
+        assertThat(io.sentry.util.CallbackUtils.isCallbackException(thrown)).isTrue()
+        assertThat(thrown.cause).isSameInstanceAs(failure)
+        assertThat(sut.isShowing).isFalse()
+        shadowOf(Looper.getMainLooper()).idle()
+      }
+    }
+  }
+
+  @Test
+  fun `strict feedback configurators propagate marked failures`() {
+    fixture.options.isStrictCallbackMode = true
+    for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+      val configured =
+        kotlin.test.assertFails { fixture.getSut(configuration = { _, _ -> throw failure }) }
+      val customized = kotlin.test.assertFails { fixture.getSut(configurator = { throw failure }) }
+      for (thrown in listOf(configured, customized)) {
+        com.google.common.truth.Truth.assertThat(
+            io.sentry.util.CallbackUtils.isCallbackException(thrown)
+          )
+          .isTrue()
+        com.google.common.truth.Truth.assertThat(thrown.cause).isSameInstanceAs(failure)
+      }
+    }
+  }
+
+  @Test
+  fun `strict form open callback propagates marked failures`() {
+    fixture.options.isStrictCallbackMode = true
+    for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+      fixture.options.feedbackOptions.onFormOpen = Runnable { throw failure }
+      val sut = fixture.getSut()
+      val thrown = kotlin.test.assertFails { sut.show() }
+      com.google.common.truth.Truth.assertThat(
+          io.sentry.util.CallbackUtils.isCallbackException(thrown)
+        )
+        .isTrue()
+      com.google.common.truth.Truth.assertThat(thrown.cause).isSameInstanceAs(failure)
+      sut.dismiss()
+    }
+  }
+
+  @Test
+  fun `strict form close callback propagates marked failures`() {
+    fixture.options.isStrictCallbackMode = true
+    for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+      fixture.options.feedbackOptions.onFormClose = Runnable { throw failure }
+      val sut = fixture.getSut()
+      sut.show()
+      sut.dismiss()
+      val thrown = kotlin.test.assertFails { shadowOf(Looper.getMainLooper()).idle() }
+      com.google.common.truth.Truth.assertThat(
+          io.sentry.util.CallbackUtils.isCallbackException(thrown)
+        )
+        .isTrue()
+      com.google.common.truth.Truth.assertThat(thrown.cause).isSameInstanceAs(failure)
+    }
+  }
+
   @Test
   fun `feedback dialog is shown when sdk is enabled`() {
     fixture.options.isEnabled = true
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ViewHierarchyEventProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ViewHierarchyEventProcessorTest.kt
index 6f19035a8d9..439057561ae 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ViewHierarchyEventProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ViewHierarchyEventProcessorTest.kt
@@ -344,6 +344,21 @@ class ViewHierarchyEventProcessorTest {
     assertNull(hint.viewHierarchy)
   }
 
+  @Test
+  fun `strict capture failures propagate without attaching view hierarchy`() {
+    fixture.options.isStrictCallbackMode = true
+    val processor = fixture.getSut(true)
+    for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+      fixture.options.setBeforeViewHierarchyCaptureCallback { _, _, _ -> throw failure }
+      val event = SentryEvent().apply { exceptions = listOf(SentryException()) }
+      val hint = Hint()
+      val thrown = kotlin.test.assertFails { processor.process(event, hint) }
+      assertThat(io.sentry.util.CallbackUtils.isCallbackException(thrown)).isTrue()
+      assertThat(thrown.cause).isSameInstanceAs(failure)
+      assertThat(hint.viewHierarchy).isNull()
+    }
+  }
+
   @Test
   fun `when capture callback throws, skips view hierarchy and retains event`() {
     fixture.options.isDebug = true
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 edb3f9c03a7..828100acabe 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
@@ -464,8 +464,9 @@ public class ReplayIntegration(
             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()
+            io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e)
+            options.logger.log(ERROR, "Error in ReplayFrameObserver", e)
           }
         }
       }
@@ -487,8 +488,9 @@ public class ReplayIntegration(
             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()
+            io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e)
+            options.logger.log(ERROR, "Error in ReplayFrameObserver", e)
           }
         }
       }
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 ce987c24ce8..06a5d20b0b5 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
@@ -92,6 +92,7 @@ internal class ScreenshotRecorder(
       contentChanged.set(false)
       screenshotStrategy.capture(root)
     } catch (e: Throwable) {
+      io.sentry.util.ExceptionUtils.maybeRethrow(e)
       options.logger.log(WARNING, "Failed to capture replay recording", e)
     }
   }
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 19c61900889..0056c636dc5 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
@@ -96,6 +96,7 @@ internal class WindowRecorder(
         }
         recorder?.capture()
       } catch (e: Throwable) {
+        io.sentry.util.ExceptionUtils.maybeRethrow(e)
         options.logger.log(ERROR, "Failed to capture a frame", e)
       }
 
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 c3deefbf71b..c0c6cdc0e6c 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
@@ -138,6 +138,7 @@ internal class CanvasStrategy(
         executor.getBackgroundHandler(),
       )
     } catch (t: Throwable) {
+      io.sentry.util.ExceptionUtils.maybeRethrow(t)
       options.logger.log(SentryLevel.ERROR, "Canvas Strategy: picture render failed", t)
       lastCaptureSuccessful.set(false)
     }
@@ -197,6 +198,7 @@ internal class CanvasStrategy(
     try {
       post(runnable)
     } catch (t: Throwable) {
+      io.sentry.util.ExceptionUtils.maybeRethrow(t)
       options.logger.log(
         SentryLevel.ERROR,
         "Canvas Strategy: failed to post runnable ${runnable.taskName}",
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 06be58e19de..edac8e5e022 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
@@ -167,6 +167,10 @@ internal class PixelCopyStrategy(
               )
             }
           } catch (e: RuntimeException) {
+            if (io.sentry.util.CallbackUtils.isCallbackException(e)) {
+              finishFrame()
+              io.sentry.util.ExceptionUtils.maybeRethrow(e)
+            }
             // 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.
@@ -177,6 +181,10 @@ internal class PixelCopyStrategy(
         mainLooperHandler.handler,
       )
     } catch (e: Throwable) {
+      if (io.sentry.util.CallbackUtils.isCallbackException(e)) {
+        finishFrame()
+        io.sentry.util.ExceptionUtils.maybeRethrow(e)
+      }
       options.logger.log(WARNING, "Failed to capture replay recording", e)
       unstableCaptures.set(0)
       lastCaptureSuccessful.set(false)
@@ -295,6 +303,7 @@ internal class PixelCopyStrategy(
         // double-recycle if the recycle paths above already ran.
         svBitmap = null
       } catch (e: Throwable) {
+        io.sentry.util.ExceptionUtils.maybeRethrow(e)
         options.logger.log(WARNING, "Failed to capture SurfaceView", e)
         svBitmap?.recycle()
         onCaptureComplete()
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Executors.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Executors.kt
index a5dddc3bd4d..124d43e9e1f 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Executors.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Executors.kt
@@ -15,10 +15,12 @@ internal fun ISentryExecutorService.submitSafely(
       try {
         task.run()
       } catch (e: Throwable) {
+        io.sentry.util.ExceptionUtils.maybeRethrow(e)
         options.logger.log(ERROR, "Failed to execute task $taskName", e)
       }
     }
   } catch (e: Throwable) {
+    io.sentry.util.ExceptionUtils.maybeRethrow(e)
     options.logger.log(ERROR, "Failed to submit task $taskName to executor", e)
     null
   }
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 5ba334f8029..b8ac2089fad 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
@@ -35,6 +35,7 @@ internal class ReplayExecutorService(
         try {
           task.run()
         } catch (e: Throwable) {
+          io.sentry.util.ExceptionUtils.maybeRethrow(e)
           options.logger.log(
             ERROR,
             "Failed to execute task ${if (task is ReplayRunnable) task.taskName else ""}",
@@ -43,6 +44,7 @@ internal class ReplayExecutorService(
         }
       }
     } catch (e: Throwable) {
+      io.sentry.util.ExceptionUtils.maybeRethrow(e)
       options.logger.log(
         ERROR,
         "Failed to submit task ${if (task is ReplayRunnable) task.taskName else ""} to executor",
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 932f26a2b6d..a85a3535ee7 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
@@ -1531,6 +1531,42 @@ class ReplayIntegrationTest {
     assertEquals(copyBitmap, receivedBitmap)
   }
 
+  @Test
+  fun `strict snapshot observer failure propagates and recycles its bitmap`() {
+    val captureStrategy =
+      mock<CaptureStrategy> {
+        doAnswer {
+            (it.arguments[1] as ReplayCache.(Long) -> Unit).invoke(
+              fixture.replayCache,
+              1720693523997,
+            )
+          }
+          .whenever(mock)
+          .onScreenshotRecorded(anyOrNull<Bitmap>(), any())
+      }
+    val replay = fixture.getSut(context, replayCaptureStrategyProvider = { captureStrategy })
+    fixture.options.isStrictCallbackMode = true
+    replay.register(fixture.scopes, fixture.options)
+    replay.start()
+    for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+      fixture.options.sessionReplay.frameObserver =
+        SentryReplayOptions.ReplayFrameObserver { _, _, _ ->
+          throw failure
+        }
+      val copyBitmap = mock<Bitmap>()
+      val sourceBitmap =
+        mock<Bitmap> {
+          on { config } doReturn ARGB_8888
+          on { copy(any(), any()) } doReturn copyBitmap
+        }
+      val thrown = kotlin.test.assertFails { replay.onScreenshotRecorded(sourceBitmap) }
+      assertThat(io.sentry.util.CallbackUtils.isCallbackException(thrown)).isTrue()
+      assertThat(thrown.cause).isSameInstanceAs(failure)
+      verify(copyBitmap).recycle()
+    }
+    verify(fixture.replayCache, never()).addFrame(any<Bitmap>(), any(), anyOrNull())
+  }
+
   @Test
   fun `snapshot observer exception does not prevent frame storage`() {
     val captureStrategy =
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/util/StrictCallbackModeExecutorTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/util/StrictCallbackModeExecutorTest.kt
new file mode 100644
index 00000000000..50f2cf4a0fd
--- /dev/null
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/util/StrictCallbackModeExecutorTest.kt
@@ -0,0 +1,53 @@
+package io.sentry.android.replay.util
+
+import com.google.common.truth.Truth.assertThat
+import io.sentry.SentryExecutorService
+import io.sentry.SentryOptions
+import io.sentry.exception.SentryCallbackError
+import io.sentry.exception.SentryCallbackException
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+import kotlin.test.Test
+import kotlin.test.assertFailsWith
+
+class StrictCallbackModeExecutorTest {
+  @Test
+  fun `replay executor preserves callback failures in task results`() {
+    val executor =
+      ReplayExecutorService(Executors.newSingleThreadScheduledExecutor(), SentryOptions())
+    try {
+      for (marker in
+        listOf(
+          SentryCallbackException(IllegalStateException()),
+          SentryCallbackError(LinkageError()),
+        )) {
+        val future = executor.submit(Runnable { throw marker })!!
+        val thrown = assertFailsWith<ExecutionException> { future.get(5, TimeUnit.SECONDS) }
+        assertThat(thrown.cause).isSameInstanceAs(marker)
+      }
+    } finally {
+      executor.shutdownNow()
+    }
+  }
+
+  @Test
+  fun `safe submission preserves callback failures in task results`() {
+    val options = SentryOptions()
+    val executor = SentryExecutorService(options)
+    try {
+      for (marker in
+        listOf(
+          SentryCallbackException(IllegalStateException()),
+          SentryCallbackError(LinkageError()),
+        )) {
+        val future =
+          executor.submitSafely(options, "strict-callback-mode-test", Runnable { throw marker })!!
+        val thrown = assertFailsWith<ExecutionException> { future.get(5, TimeUnit.SECONDS) }
+        assertThat(thrown.cause).isSameInstanceAs(marker)
+      }
+    } finally {
+      executor.close(1000)
+    }
+  }
+}
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 707fc28d965..47c69cb2832 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
@@ -167,6 +167,9 @@ public class SentryTimberTree(
     vararg args: Any?,
   ) {
     val tag = retrieveTag()
+    if (io.sentry.util.CallbackUtils.isCallbackException(throwable)) {
+      return
+    }
 
     if (message.isNullOrEmpty() && throwable == null) {
       return // Swallow message if it's null and there's no throwable
diff --git a/sentry-android-timber/src/test/java/io/sentry/android/timber/SentryTimberTreeTest.kt b/sentry-android-timber/src/test/java/io/sentry/android/timber/SentryTimberTreeTest.kt
index 8ef43a9b691..17a56458e27 100644
--- a/sentry-android-timber/src/test/java/io/sentry/android/timber/SentryTimberTreeTest.kt
+++ b/sentry-android-timber/src/test/java/io/sentry/android/timber/SentryTimberTreeTest.kt
@@ -50,6 +50,19 @@ class SentryTimberTreeTest {
     Timber.uprootAll()
   }
 
+  @Test
+  fun `callback failures are excluded before events breadcrumbs and logs`() {
+    val sut = fixture.getSut()
+    for (marker in
+      listOf(
+        io.sentry.exception.SentryCallbackException(IllegalStateException()),
+        io.sentry.exception.SentryCallbackError(LinkageError()),
+      )) {
+      sut.e(java.util.concurrent.CompletionException(marker), "private")
+    }
+    verifyNoInteractions(fixture.scopes, fixture.logs)
+  }
+
   @Test
   fun `Tree captures an event if min level is equal`() {
     val sut = fixture.getSut()
diff --git a/sentry-apollo-3/src/main/java/io/sentry/apollo3/SentryApollo3HttpInterceptor.kt b/sentry-apollo-3/src/main/java/io/sentry/apollo3/SentryApollo3HttpInterceptor.kt
index 53e48657393..0b26bc62b40 100644
--- a/sentry-apollo-3/src/main/java/io/sentry/apollo3/SentryApollo3HttpInterceptor.kt
+++ b/sentry-apollo-3/src/main/java/io/sentry/apollo3/SentryApollo3HttpInterceptor.kt
@@ -227,6 +227,11 @@ constructor(
           }
         } catch (e: Throwable) {
           span.spanContext.sampled = false
+          if (scopes.options.isStrictCallbackMode) {
+            response?.body?.close()
+            span.finish()
+          }
+          io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(scopes.options, e)
           if (wasSampled) {
             scopes.options.clientReportRecorder.recordLostEvent(
               DiscardReason.CALLBACK_ERROR,
@@ -450,6 +455,7 @@ constructor(
 
       scopes.captureEvent(event, hint)
     } catch (e: Throwable) {
+      io.sentry.util.ExceptionUtils.maybeRethrow(e)
       scopes.options.logger.log(SentryLevel.ERROR, "Error capturing the GraphQL error.", e)
     }
   }
diff --git a/sentry-apollo-3/src/test/java/io/sentry/apollo3/SentryApollo3InterceptorTest.kt b/sentry-apollo-3/src/test/java/io/sentry/apollo3/SentryApollo3InterceptorTest.kt
index 49d7d790a53..70c4630612a 100644
--- a/sentry-apollo-3/src/test/java/io/sentry/apollo3/SentryApollo3InterceptorTest.kt
+++ b/sentry-apollo-3/src/test/java/io/sentry/apollo3/SentryApollo3InterceptorTest.kt
@@ -337,6 +337,26 @@ class SentryApollo3InterceptorTest {
     }
   }
 
+  @Test
+  fun `strict beforeSpan failures escape and finish dropped spans`(): Unit = runBlocking {
+    fixture.options.isStrictCallbackMode = true
+    for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+      val tx =
+        SentryTracer(TransactionContext("op", "desc", TracesSamplingDecision(true)), fixture.scopes)
+      whenever(fixture.scopes.span).thenReturn(tx)
+      val sut = fixture.getSut(beforeSpan = { _, _, _ -> throw failure })
+      val thrown =
+        kotlin.test.assertFails {
+          kotlinx.coroutines.withTimeout(5000) { sut.query(LaunchDetailsQuery("83")).execute() }
+        }
+      assertThat(io.sentry.util.CallbackUtils.isCallbackException(thrown)).isTrue()
+      assertThat(generateSequence(thrown) { it.cause }.toList()).contains(failure)
+      assertThat(tx.children.single().isSampled).isFalse()
+      assertThat(tx.children.single().isFinished).isTrue()
+      sut.close()
+    }
+  }
+
   @Test
   fun `when beforeSpan throws, drops span and preserves response`(): Unit = runBlocking {
     val failure = IllegalStateException("callback failed")
diff --git a/sentry-apollo-4/src/main/java/io/sentry/apollo4/SentryApollo4HttpInterceptor.kt b/sentry-apollo-4/src/main/java/io/sentry/apollo4/SentryApollo4HttpInterceptor.kt
index aea5d6691c4..3241b40ec0e 100644
--- a/sentry-apollo-4/src/main/java/io/sentry/apollo4/SentryApollo4HttpInterceptor.kt
+++ b/sentry-apollo-4/src/main/java/io/sentry/apollo4/SentryApollo4HttpInterceptor.kt
@@ -226,6 +226,11 @@ constructor(
           }
         } catch (e: Throwable) {
           span.spanContext.sampled = false
+          if (scopes.options.isStrictCallbackMode) {
+            response?.body?.close()
+            span.finish()
+          }
+          io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(scopes.options, e)
           if (wasSampled) {
             scopes.options.clientReportRecorder.recordLostEvent(
               DiscardReason.CALLBACK_ERROR,
@@ -449,6 +454,7 @@ constructor(
 
       scopes.captureEvent(event, hint)
     } catch (e: Throwable) {
+      io.sentry.util.ExceptionUtils.maybeRethrow(e)
       scopes.options.logger.log(SentryLevel.ERROR, "Error capturing the GraphQL error.", e)
     }
   }
diff --git a/sentry-apollo-4/src/test/java/io/sentry/apollo4/SentryApollo4HttpInterceptorTest.kt b/sentry-apollo-4/src/test/java/io/sentry/apollo4/SentryApollo4HttpInterceptorTest.kt
index 210cab90327..d130babb8b6 100644
--- a/sentry-apollo-4/src/test/java/io/sentry/apollo4/SentryApollo4HttpInterceptorTest.kt
+++ b/sentry-apollo-4/src/test/java/io/sentry/apollo4/SentryApollo4HttpInterceptorTest.kt
@@ -351,6 +351,28 @@ abstract class SentryApollo4HttpInterceptorTest(
     }
   }
 
+  @Test
+  fun `strict beforeSpan failures escape and finish dropped spans`(): Unit = runBlocking {
+    fixture.options.isStrictCallbackMode = true
+    for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+      val tx =
+        SentryTracer(TransactionContext("op", "desc", TracesSamplingDecision(true)), fixture.scopes)
+      whenever(fixture.scopes.span).thenReturn(tx)
+      val sut = fixture.getSut(beforeSpan = { _, _, _ -> throw failure })
+      val thrown =
+        kotlin.test.assertFails {
+          kotlinx.coroutines.withTimeout(5000) {
+            executeQueryImplementation(sut.query(LaunchDetailsQuery("83")))
+          }
+        }
+      assertThat(io.sentry.util.CallbackUtils.isCallbackException(thrown)).isTrue()
+      assertThat(generateSequence(thrown) { it.cause }.toList()).contains(failure)
+      assertThat(tx.children.single().isSampled).isFalse()
+      assertThat(tx.children.single().isFinished).isTrue()
+      sut.close()
+    }
+  }
+
   @Test
   fun `when beforeSpan throws, drops span and preserves response`(): Unit = runBlocking {
     val failure = IllegalStateException("callback failed")
diff --git a/sentry-apollo/src/main/java/io/sentry/apollo/SentryApolloInterceptor.kt b/sentry-apollo/src/main/java/io/sentry/apollo/SentryApolloInterceptor.kt
index 3524d32dc1f..2088e5ed069 100644
--- a/sentry-apollo/src/main/java/io/sentry/apollo/SentryApolloInterceptor.kt
+++ b/sentry-apollo/src/main/java/io/sentry/apollo/SentryApolloInterceptor.kt
@@ -180,8 +180,17 @@ class SentryApolloInterceptor(
       val wasSampled = span.isSampled == true
       try {
         newSpan = beforeSpan.execute(span, request, response)
+      } catch (e: Error) {
+        if (scopes.options.isStrictCallbackMode) {
+          span.spanContext.sampled = false
+          span.finish()
+        }
+        io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(scopes.options, e)
+        throw e
       } catch (e: Exception) {
         span.spanContext.sampled = false
+        if (scopes.options.isStrictCallbackMode) span.finish()
+        io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(scopes.options, e)
         if (wasSampled) {
           scopes.options.clientReportRecorder.recordLostEvent(
             DiscardReason.CALLBACK_ERROR,
diff --git a/sentry-apollo/src/test/java/io/sentry/apollo/SentryApolloInterceptorTest.kt b/sentry-apollo/src/test/java/io/sentry/apollo/SentryApolloInterceptorTest.kt
index 498b4663cac..0d1a5601476 100644
--- a/sentry-apollo/src/test/java/io/sentry/apollo/SentryApolloInterceptorTest.kt
+++ b/sentry-apollo/src/test/java/io/sentry/apollo/SentryApolloInterceptorTest.kt
@@ -40,6 +40,7 @@ import okhttp3.mockwebserver.SocketPolicy
 import org.junit.Before
 import org.mockito.kotlin.any
 import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.argumentCaptor
 import org.mockito.kotlin.check
 import org.mockito.kotlin.doAnswer
 import org.mockito.kotlin.mock
@@ -272,6 +273,33 @@ class SentryApolloInterceptorTest {
     }
   }
 
+  @Test
+  fun `strict beforeSpan failures escape asynchronous completion callback`() {
+    fixture.options.isStrictCallbackMode = true
+    for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+      val tx =
+        SentryTracer(TransactionContext("op", "desc", TracesSamplingDecision(true)), fixture.scopes)
+      whenever(fixture.scopes.span).thenReturn(tx)
+      val chain = mock<com.apollographql.apollo.interceptor.ApolloInterceptorChain>()
+      val callback =
+        argumentCaptor<com.apollographql.apollo.interceptor.ApolloInterceptor.CallBack>()
+      val sut = SentryApolloInterceptor(fixture.scopes) { _, _, _ -> throw failure }
+      val request =
+        com.apollographql.apollo.interceptor.ApolloInterceptor.InterceptorRequest.builder(
+            LaunchDetailsQuery.builder().id("83").build()
+          )
+          .build()
+      sut.interceptAsync(request, chain, java.util.concurrent.Executor { it.run() }, mock())
+      verify(chain).proceedAsync(any(), any(), callback.capture())
+      val thrown =
+        kotlin.test.assertFails { callback.firstValue.onFailure(ApolloException("request")) }
+      assertThat(thrown.cause).isSameInstanceAs(failure)
+      assertThat(io.sentry.util.CallbackUtils.isCallbackException(thrown)).isTrue()
+      assertThat(tx.children.single().isSampled).isFalse()
+      assertThat(tx.children.single().isFinished).isTrue()
+    }
+  }
+
   @Test
   fun `when beforeSpan throws, drops span and preserves response`(): Unit = runBlocking {
     val failure = IllegalStateException("callback failed")
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 2331ab17aaf..99db5b27113 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
@@ -209,6 +209,37 @@ class SentryInstrumentationTest {
     }
   }
 
+  @Test
+  fun `strict beforeSpan failures reach GraphQL without invoking callback again`() {
+    for (async in listOf(false, true)) {
+      for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+        var calls = 0
+        val sut =
+          fixture.getSut(
+            async = async,
+            beforeSpan = { _, _, _ ->
+              calls++
+              throw failure
+            },
+          )
+        fixture.scopes.options.isStrictCallbackMode = true
+        withMockScopes {
+          val result = runCatching { sut.execute("{ shows { id } }") }
+          val thrown =
+            result.exceptionOrNull()
+              ?: (result.getOrThrow().errors.single() as graphql.ExceptionWhileDataFetching)
+                .exception
+          assertThat(io.sentry.util.CallbackUtils.isCallbackException(thrown)).isTrue()
+          assertThat(generateSequence(thrown) { it.cause }.toList()).contains(failure)
+          assertThat(calls).isEqualTo(1)
+          val span = fixture.activeSpan.children.last()
+          assertThat(span.isSampled).isFalse()
+          assertThat(span.isFinished).isTrue()
+        }
+      }
+    }
+  }
+
   @Test
   fun `when beforeSpan throws, drops span and preserves result`() {
     val failure = IllegalStateException("callback failed")
diff --git a/sentry-graphql-core/src/main/java/io/sentry/graphql/SentryGraphqlInstrumentation.java b/sentry-graphql-core/src/main/java/io/sentry/graphql/SentryGraphqlInstrumentation.java
index 34044aea435..d5dea413bbd 100644
--- a/sentry-graphql-core/src/main/java/io/sentry/graphql/SentryGraphqlInstrumentation.java
+++ b/sentry-graphql-core/src/main/java/io/sentry/graphql/SentryGraphqlInstrumentation.java
@@ -232,7 +232,7 @@ public void beginExecuteOperation(
           final @Nullable Object result =
               maybeCallSubscriptionHandler(parameters, environment, tmpResult);
           if (result instanceof CompletableFuture) {
-            ((CompletableFuture<?>) result)
+            return ((CompletableFuture<?>) result)
                 .whenComplete(
                     (r, ex) -> {
                       if (ex != null) {
@@ -249,6 +249,7 @@ public void beginExecuteOperation(
           }
           return result;
         } catch (Throwable e) {
+          io.sentry.util.ExceptionUtils.maybeRethrow(e);
           span.setThrowable(e);
           span.setStatus(SpanStatus.INTERNAL_ERROR);
           finish(span, environment);
@@ -290,7 +291,17 @@ private void finish(
       ISpan newSpan = span;
       try {
         newSpan = beforeSpan.execute(span, environment, result);
-      } catch (Exception e) {
+      } catch (Exception | Error e) {
+        final io.sentry.SentryOptions options =
+            scopesFromContext(environment.getGraphQlContext()).getOptions();
+        if (options.isStrictCallbackMode()) {
+          span.getSpanContext().setSampled(false);
+          span.finish();
+        }
+        io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
+        if (e instanceof Error) {
+          throw (Error) e;
+        }
         span.getSpanContext().setSampled(false);
         if (wasSampled) {
           scopesFromContext(environment.getGraphQlContext())
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 2652694b8f9..1e1905514bc 100644
--- a/sentry-graphql/src/test/kotlin/io/sentry/graphql/SentryInstrumentationTest.kt
+++ b/sentry-graphql/src/test/kotlin/io/sentry/graphql/SentryInstrumentationTest.kt
@@ -205,6 +205,37 @@ class SentryInstrumentationTest {
     }
   }
 
+  @Test
+  fun `strict beforeSpan failures reach GraphQL without invoking callback again`() {
+    for (async in listOf(false, true)) {
+      for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+        var calls = 0
+        val sut =
+          fixture.getSut(
+            async = async,
+            beforeSpan = { _, _, _ ->
+              calls++
+              throw failure
+            },
+          )
+        fixture.scopes.options.isStrictCallbackMode = true
+        withMockScopes {
+          val result = runCatching { sut.execute("{ shows { id } }") }
+          val thrown =
+            result.exceptionOrNull()
+              ?: (result.getOrThrow().errors.single() as graphql.ExceptionWhileDataFetching)
+                .exception
+          assertThat(io.sentry.util.CallbackUtils.isCallbackException(thrown)).isTrue()
+          assertThat(generateSequence(thrown) { it.cause }.toList()).contains(failure)
+          assertThat(calls).isEqualTo(1)
+          val span = fixture.activeSpan.children.last()
+          assertThat(span.isSampled).isFalse()
+          assertThat(span.isFinished).isTrue()
+        }
+      }
+    }
+  }
+
   @Test
   fun `when beforeSpan throws, drops span and preserves result`() {
     val failure = IllegalStateException("callback failed")
diff --git a/sentry-jul/build.gradle.kts b/sentry-jul/build.gradle.kts
index 2eec61eb171..a4f3297cf43 100644
--- a/sentry-jul/build.gradle.kts
+++ b/sentry-jul/build.gradle.kts
@@ -29,6 +29,7 @@ dependencies {
   testImplementation(projects.sentryTestSupport)
   testImplementation(kotlin(Config.kotlinStdLib))
   testImplementation(libs.kotlin.test.junit)
+  testImplementation(libs.google.truth)
   testImplementation(libs.logback.classic)
   testImplementation(libs.mockito.kotlin)
   testImplementation(libs.slf4j.api)
diff --git a/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java b/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java
index 4442052dd41..71d8db733a3 100644
--- a/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java
+++ b/sentry-jul/src/main/java/io/sentry/jul/SentryHandler.java
@@ -107,6 +107,9 @@ public SentryHandler(
 
   @Override
   public void publish(final @NotNull LogRecord record) {
+    if (io.sentry.util.CallbackUtils.isCallbackException(record.getThrown())) {
+      return;
+    }
     // Do not log the event if the current thread is managed by sentry
     if (!isLoggable(record)) {
       return;
@@ -129,6 +132,7 @@ public void publish(final @NotNull LogRecord record) {
         Sentry.addBreadcrumb(createBreadcrumb(record), hint);
       }
     } catch (RuntimeException e) {
+      io.sentry.util.ExceptionUtils.maybeRethrow(e);
       reportError(
           "An exception occurred while creating a new event in Sentry",
           e,
@@ -364,6 +368,7 @@ public void close() throws SecurityException {
     try {
       Sentry.close();
     } catch (RuntimeException e) {
+      io.sentry.util.ExceptionUtils.maybeRethrow(e);
       reportError(
           "An exception occurred while closing the Sentry connection",
           e,
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 ab160faac40..b02047bd210 100644
--- a/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt
+++ b/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt
@@ -100,6 +100,51 @@ class SentryHandlerTest {
       )
   }
 
+  @Test
+  fun `strict callback failures propagate through the logging handler`() {
+    fixture = Fixture(minimumEventLevel = Level.SEVERE)
+    val options = Sentry.getCurrentScopes().options
+    options.isStrictCallbackMode = true
+    for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+      options.setBeforeSend { _, _ -> throw failure }
+      val thrown = kotlin.test.assertFails { fixture.logger.severe("message") }
+      com.google.common.truth.Truth.assertThat(thrown.cause).isSameInstanceAs(failure)
+      com.google.common.truth.Truth.assertThat(
+          io.sentry.util.CallbackUtils.isCallbackException(thrown)
+        )
+        .isTrue()
+    }
+  }
+
+  @Test
+  fun `callback failures are excluded before events breadcrumbs and logs`() {
+    fixture = Fixture()
+    val options = Sentry.getCurrentScopes().options
+    options.logs.isEnabled = true
+    val beforeSend = mock<SentryOptions.BeforeSendCallback>()
+    val beforeBreadcrumb = mock<SentryOptions.BeforeBreadcrumbCallback>()
+    val beforeLog = mock<SentryOptions.Logs.BeforeSendLogCallback>()
+    val onDiscard = mock<SentryOptions.OnDiscardCallback>()
+    options.beforeSend = beforeSend
+    options.beforeBreadcrumb = beforeBreadcrumb
+    options.logs.beforeSend = beforeLog
+    options.onDiscard = onDiscard
+    for (marker in
+      listOf(
+        io.sentry.exception.SentryCallbackException(IllegalStateException()),
+        io.sentry.exception.SentryCallbackError(LinkageError()),
+      )) {
+      fixture.logger.log(Level.SEVERE, "private", java.util.concurrent.CompletionException(marker))
+    }
+    org.mockito.kotlin.verifyNoInteractions(
+      beforeSend,
+      beforeBreadcrumb,
+      beforeLog,
+      onDiscard,
+      fixture.transport,
+    )
+  }
+
   @Test
   fun `converts message`() {
     fixture = Fixture(minimumEventLevel = Level.SEVERE)
diff --git a/sentry-ktor-client/src/main/java/io/sentry/ktorClient/SentryKtorClientPlugin.kt b/sentry-ktor-client/src/main/java/io/sentry/ktorClient/SentryKtorClientPlugin.kt
index 609ed239961..b4b4b49f519 100644
--- a/sentry-ktor-client/src/main/java/io/sentry/ktorClient/SentryKtorClientPlugin.kt
+++ b/sentry-ktor-client/src/main/java/io/sentry/ktorClient/SentryKtorClientPlugin.kt
@@ -193,8 +193,21 @@ public val SentryKtorClientPlugin: ClientPlugin<SentryKtorClientPluginConfig> =
           result =
             try {
               beforeSpan.execute(span, request)
+            } catch (e: Error) {
+              val options = (if (forceScopes) scopes else Sentry.getCurrentScopes()).options
+              if (options.isStrictCallbackMode) {
+                span.spanContext.sampled = false
+                span.finish(SpanStatus.fromHttpStatusCode(response.status.value), endTimestamp)
+              }
+              io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e)
+              throw e
             } catch (e: Exception) {
               span.spanContext.sampled = false
+              val options = (if (forceScopes) scopes else Sentry.getCurrentScopes()).options
+              if (options.isStrictCallbackMode) {
+                span.finish(SpanStatus.fromHttpStatusCode(response.status.value), endTimestamp)
+              }
+              io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e)
               if (wasSampled) {
                 (if (forceScopes) scopes else Sentry.getCurrentScopes())
                   .options
diff --git a/sentry-ktor-client/src/test/java/io/sentry/ktorClient/SentryKtorClientPluginTest.kt b/sentry-ktor-client/src/test/java/io/sentry/ktorClient/SentryKtorClientPluginTest.kt
index 4aadfe823a0..9c1807f3e8b 100644
--- a/sentry-ktor-client/src/test/java/io/sentry/ktorClient/SentryKtorClientPluginTest.kt
+++ b/sentry-ktor-client/src/test/java/io/sentry/ktorClient/SentryKtorClientPluginTest.kt
@@ -467,6 +467,29 @@ class SentryKtorClientPluginTest {
     }
   }
 
+  @Test
+  fun `strict beforeSpan failures propagate and finish dropped spans`(): Unit = runBlocking {
+    for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+      val fixture = Fixture()
+      val sut = fixture.getSut(beforeSpan = { _, _ -> throw failure })
+      fixture.options.isStrictCallbackMode = true
+      val thrown =
+        kotlin.test.assertFails {
+          sut.use { sut.get(fixture.server.url("/hello").toString()) }
+        }
+      assertThat(thrown)
+        .isInstanceOf(
+          if (failure is Error) io.sentry.exception.SentryCallbackError::class.java
+          else io.sentry.exception.SentryCallbackException::class.java
+        )
+      assertThat(generateSequence(thrown) { it.cause }.toList()).contains(failure)
+      val span = fixture.sentryTracer.children.single()
+      assertThat(span.isSampled).isFalse()
+      assertThat(span.isFinished).isTrue()
+      fixture.server.shutdown()
+    }
+  }
+
   @Test
   fun `when beforeSpan throws, drops span and preserves response`(): Unit = runBlocking {
     val failure = IllegalStateException("callback failed")
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 c965784f00f..b699fa3ce71 100644
--- a/sentry-log4j2/src/main/java/io/sentry/log4j2/SentryAppender.java
+++ b/sentry-log4j2/src/main/java/io/sentry/log4j2/SentryAppender.java
@@ -218,6 +218,9 @@ void start(final @NotNull Sentry.OptionsConfiguration<SentryOptions> optionsConf
 
   @Override
   public void append(final @NotNull LogEvent eventObject) {
+    if (io.sentry.util.CallbackUtils.isCallbackException(eventObject.getThrown())) {
+      return;
+    }
     if (scopes.getOptions().getLogs().isEnabled()
         && eventObject.getLevel().isMoreSpecificThan(minimumLevel)) {
       captureLog(eventObject);
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 c32459ea022..0001a188eff 100644
--- a/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt
+++ b/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt
@@ -6,6 +6,7 @@ import io.sentry.ScopesAdapter
 import io.sentry.Sentry
 import io.sentry.SentryLevel
 import io.sentry.SentryLogLevel
+import io.sentry.SentryOptions
 import io.sentry.checkEvent
 import io.sentry.checkLogs
 import io.sentry.logger.ILoggerBatchProcessorFactory
@@ -143,6 +144,35 @@ class SentryAppenderTest {
       )
   }
 
+  @Test
+  fun `callback failures are excluded before events breadcrumbs and logs`() {
+    val logger = fixture.getSut()
+    val options = Sentry.getCurrentScopes().options
+    options.logs.isEnabled = true
+    val beforeSend = mock<SentryOptions.BeforeSendCallback>()
+    val beforeBreadcrumb = mock<SentryOptions.BeforeBreadcrumbCallback>()
+    val beforeLog = mock<SentryOptions.Logs.BeforeSendLogCallback>()
+    val onDiscard = mock<SentryOptions.OnDiscardCallback>()
+    options.beforeSend = beforeSend
+    options.beforeBreadcrumb = beforeBreadcrumb
+    options.logs.beforeSend = beforeLog
+    options.onDiscard = onDiscard
+    for (marker in
+      listOf(
+        io.sentry.exception.SentryCallbackException(IllegalStateException()),
+        io.sentry.exception.SentryCallbackError(LinkageError()),
+      )) {
+      logger.error("private", java.util.concurrent.CompletionException(marker))
+    }
+    org.mockito.kotlin.verifyNoInteractions(
+      beforeSend,
+      beforeBreadcrumb,
+      beforeLog,
+      onDiscard,
+      fixture.transport,
+    )
+  }
+
   @Test
   fun `converts message`() {
     val logger = fixture.getSut(minimumEventLevel = Level.DEBUG)
diff --git a/sentry-logback/src/main/java/io/sentry/logback/SentryAppender.java b/sentry-logback/src/main/java/io/sentry/logback/SentryAppender.java
index 722845e2d70..32a5cf2fe49 100644
--- a/sentry-logback/src/main/java/io/sentry/logback/SentryAppender.java
+++ b/sentry-logback/src/main/java/io/sentry/logback/SentryAppender.java
@@ -88,6 +88,11 @@ public void start() {
 
   @Override
   protected void append(@NotNull ILoggingEvent eventObject) {
+    if (eventObject.getThrowableProxy() instanceof ThrowableProxy
+        && io.sentry.util.CallbackUtils.isCallbackException(
+            ((ThrowableProxy) eventObject.getThrowableProxy()).getThrowable())) {
+      return;
+    }
     if (ScopesAdapter.getInstance().getOptions().getLogs().isEnabled()
         && eventObject.getLevel().isGreaterOrEqual(minimumLevel)) {
       captureLog(eventObject);
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 bb10c5ede9c..8722193643c 100644
--- a/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt
+++ b/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt
@@ -118,6 +118,34 @@ class SentryAppenderTest {
     Sentry.close()
   }
 
+  @Test
+  fun `callback failures are excluded before events breadcrumbs and logs`() {
+    fixture = Fixture(enableLogs = true)
+    val options = Sentry.getCurrentScopes().options
+    val beforeSend = mock<SentryOptions.BeforeSendCallback>()
+    val beforeBreadcrumb = mock<SentryOptions.BeforeBreadcrumbCallback>()
+    val beforeLog = mock<SentryOptions.Logs.BeforeSendLogCallback>()
+    val onDiscard = mock<SentryOptions.OnDiscardCallback>()
+    options.beforeSend = beforeSend
+    options.beforeBreadcrumb = beforeBreadcrumb
+    options.logs.beforeSend = beforeLog
+    options.onDiscard = onDiscard
+    for (marker in
+      listOf(
+        io.sentry.exception.SentryCallbackException(IllegalStateException()),
+        io.sentry.exception.SentryCallbackError(LinkageError()),
+      )) {
+      fixture.logger.error("private", java.util.concurrent.CompletionException(marker))
+    }
+    org.mockito.kotlin.verifyNoInteractions(
+      beforeSend,
+      beforeBreadcrumb,
+      beforeLog,
+      onDiscard,
+      fixture.transport,
+    )
+  }
+
   @Test
   fun `does not initialize Sentry if Sentry is already enabled with higher prio`() {
     fixture =
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 2f07a1de240..a3405716d14 100644
--- a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
+++ b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
@@ -375,8 +375,23 @@ public open class SentryOkHttpInterceptor(
       val result =
         try {
           beforeSpan.execute(span, request, response)
+        } catch (e: Error) {
+          if (scopes.options.isStrictCallbackMode) {
+            span.spanContext.sampled = false
+            response?.close()
+            if (!isFromEventListener) span.finish()
+            okHttpEvent?.finish()
+          }
+          io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(scopes.options, e)
+          throw e
         } catch (e: Exception) {
           span.spanContext.sampled = false
+          if (scopes.options.isStrictCallbackMode) {
+            response?.close()
+            if (!isFromEventListener) span.finish()
+            okHttpEvent?.finish()
+          }
+          io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(scopes.options, e)
           if (wasSampled) {
             scopes.options.clientReportRecorder.recordLostEvent(
               DiscardReason.CALLBACK_ERROR,
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 59a8f121f59..f4b4d51b698 100644
--- a/sentry-okhttp/src/test/java/io/sentry/okhttp/SentryOkHttpInterceptorTest.kt
+++ b/sentry-okhttp/src/test/java/io/sentry/okhttp/SentryOkHttpInterceptorTest.kt
@@ -479,6 +479,29 @@ class SentryOkHttpInterceptorTest {
     }
   }
 
+  @Test
+  fun `strict beforeSpan failures propagate and finish dropped spans`() {
+    for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+      val fixture = Fixture()
+      val sut = fixture.getSut(beforeSpan = { _, _, _ -> throw failure })
+      fixture.options.isStrictCallbackMode = true
+      val thrown =
+        kotlin.test.assertFails {
+          sut.newCall(Request.Builder().url(fixture.server.url("/hello")).build()).execute()
+        }
+      assertThat(thrown)
+        .isInstanceOf(
+          if (failure is Error) io.sentry.exception.SentryCallbackError::class.java
+          else io.sentry.exception.SentryCallbackException::class.java
+        )
+      assertThat(thrown.cause).isSameInstanceAs(failure)
+      val span = fixture.sentryTracer.children.single()
+      assertThat(span.isSampled).isFalse()
+      assertThat(span.isFinished).isTrue()
+      fixture.server.shutdown()
+    }
+  }
+
   @Test
   fun `when beforeSpan throws, drops span and preserves response`() {
     val failure = IllegalStateException("callback failed")
@@ -509,6 +532,24 @@ class SentryOkHttpInterceptorTest {
       )
   }
 
+  @Test
+  fun `strict beforeSpan failure closes response and event listener state`() {
+    val failure = IllegalStateException("private")
+    val sut =
+      fixture.getSut(
+        beforeSpan = { _, _, _ -> throw failure },
+        eventListener = SentryOkHttpEventListener(fixture.scopes),
+      )
+    fixture.options.isStrictCallbackMode = true
+    val call = sut.newCall(getRequest())
+    val thrown = kotlin.test.assertFails { call.execute() }
+    assertThat(thrown.cause).isSameInstanceAs(failure)
+    assertThat(SentryOkHttpEventListener.eventMap).doesNotContainKey(call)
+    val span = fixture.sentryTracer.children.first { it.operation == "http.client" }
+    assertThat(span.isFinished).isTrue()
+    assertThat(span.isSampled).isFalse()
+  }
+
   @Test
   fun `when beforeSpan throws, event listener still finishes span`() {
     val sut =
diff --git a/sentry-openfeign/src/main/java/io/sentry/openfeign/SentryFeignClient.java b/sentry-openfeign/src/main/java/io/sentry/openfeign/SentryFeignClient.java
index 7ed48d0dc10..7ed45608977 100644
--- a/sentry-openfeign/src/main/java/io/sentry/openfeign/SentryFeignClient.java
+++ b/sentry-openfeign/src/main/java/io/sentry/openfeign/SentryFeignClient.java
@@ -97,40 +97,56 @@ public Response execute(final @NotNull Request request, final @NotNull Request.O
         span.setStatus(SpanStatus.INTERNAL_ERROR);
         throw e;
       } finally {
-        if (beforeSpan != null) {
-          final boolean wasSampled = Boolean.TRUE.equals(span.isSampled());
-          ISpan result = span;
-          try {
-            result = beforeSpan.execute(span, request, response);
-          } catch (Exception e) {
-            span.getSpanContext().setSampled(false);
-            if (wasSampled) {
-              scopes
-                  .getOptions()
-                  .getClientReportRecorder()
-                  .recordLostEvent(DiscardReason.CALLBACK_ERROR, DataCategory.Span);
-            }
-            scopes
-                .getOptions()
-                .getLogger()
-                .log(
-                    SentryLevel.ERROR,
-                    "The beforeSpan callback threw an exception in SentryFeignClient. Dropping span.",
-                    e);
-          }
+        finishSpan(span, request, response);
+      }
+    } finally {
+      addBreadcrumb(request, response);
+    }
+  }
 
-          if (result == null) {
-            // span is dropped
-            span.getSpanContext().setSampled(false);
-          } else {
-            span.finish();
+  private void finishSpan(
+      final @NotNull ISpan span,
+      final @NotNull Request request,
+      final @Nullable Response response) {
+    if (beforeSpan != null) {
+      final boolean wasSampled = Boolean.TRUE.equals(span.isSampled());
+      ISpan result = span;
+      try {
+        result = beforeSpan.execute(span, request, response);
+      } catch (Exception | Error e) {
+        if (scopes.getOptions().isStrictCallbackMode()) {
+          span.getSpanContext().setSampled(false);
+          if (response != null) {
+            response.close();
           }
-        } else {
           span.finish();
         }
+        io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(scopes.getOptions(), e);
+        if (e instanceof Error) {
+          throw (Error) e;
+        }
+        span.getSpanContext().setSampled(false);
+        if (wasSampled) {
+          scopes
+              .getOptions()
+              .getClientReportRecorder()
+              .recordLostEvent(DiscardReason.CALLBACK_ERROR, DataCategory.Span);
+        }
+        scopes
+            .getOptions()
+            .getLogger()
+            .log(
+                SentryLevel.ERROR,
+                "The beforeSpan callback threw an exception in SentryFeignClient. Dropping span.",
+                e);
       }
-    } finally {
-      addBreadcrumb(request, response);
+      if (result == null) {
+        span.getSpanContext().setSampled(false);
+      } else {
+        span.finish();
+      }
+    } else {
+      span.finish();
     }
   }
 
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 9a2bd98d365..742c8c30e4b 100644
--- a/sentry-openfeign/src/test/kotlin/io/sentry/openfeign/SentryFeignClientTest.kt
+++ b/sentry-openfeign/src/test/kotlin/io/sentry/openfeign/SentryFeignClientTest.kt
@@ -318,6 +318,25 @@ class SentryFeignClientTest {
     }
   }
 
+  @Test
+  fun `strict beforeSpan failures propagate and finish dropped spans`() {
+    for (failure in listOf(IllegalStateException("private"), LinkageError("private"))) {
+      val fixture = Fixture()
+      fixture.sentryOptions.isStrictCallbackMode = true
+      val sut = fixture.getSut(beforeSpan = { _, _, _ -> throw failure })
+      val thrown = kotlin.test.assertFails { sut.getOk() }
+      assertThat(thrown)
+        .isInstanceOf(
+          if (failure is Error) io.sentry.exception.SentryCallbackError::class.java
+          else io.sentry.exception.SentryCallbackException::class.java
+        )
+      assertThat(thrown.cause).isSameInstanceAs(failure)
+      val span = fixture.sentryTracer.children.single()
+      assertThat(span.isSampled).isFalse()
+      assertThat(span.isFinished).isTrue()
+    }
+  }
+
   @Test
   fun `when beforeSpan throws, drops span and preserves response`() {
     val failure = IllegalStateException("callback failed")
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 c0eb866de02..02b34680fc6 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
@@ -204,6 +204,7 @@ class SentryAutoConfigurationTest {
         "sentry.shutdown-timeout-millis=20",
         "sentry.flush-timeout-millis=30",
         "sentry.debug=true",
+        "sentry.strict-callback-mode=true",
         "sentry.diagnostic-level=INFO",
         "sentry.sentry-client-name=my-client",
         "sentry.max-breadcrumbs=100",
@@ -254,6 +255,7 @@ class SentryAutoConfigurationTest {
         assertThat(options.shutdownTimeoutMillis).isEqualTo(20)
         assertThat(options.flushTimeoutMillis).isEqualTo(30)
         assertThat(options.isDebug).isTrue()
+        assertThat(options.isStrictCallbackMode).isTrue()
         assertThat(options.diagnosticLevel).isEqualTo(SentryLevel.INFO)
         assertThat(options.maxBreadcrumbs).isEqualTo(100)
         assertThat(options.release).isEqualTo("1.0.3")
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 31876882c4d..1cf8d188cdb 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
@@ -207,6 +207,7 @@ class SentryAutoConfigurationTest {
         "sentry.shutdown-timeout-millis=20",
         "sentry.flush-timeout-millis=30",
         "sentry.debug=true",
+        "sentry.strict-callback-mode=true",
         "sentry.diagnostic-level=INFO",
         "sentry.sentry-client-name=my-client",
         "sentry.max-breadcrumbs=100",
@@ -259,6 +260,7 @@ class SentryAutoConfigurationTest {
         assertThat(options.shutdownTimeoutMillis).isEqualTo(20)
         assertThat(options.flushTimeoutMillis).isEqualTo(30)
         assertThat(options.isDebug).isTrue()
+        assertThat(options.isStrictCallbackMode).isTrue()
         assertThat(options.diagnosticLevel).isEqualTo(SentryLevel.INFO)
         assertThat(options.maxBreadcrumbs).isEqualTo(100)
         assertThat(options.release).isEqualTo("1.0.3")
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 31be74477fd..325446c671a 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
@@ -205,6 +205,7 @@ class SentryAutoConfigurationTest {
         "sentry.shutdown-timeout-millis=20",
         "sentry.flush-timeout-millis=30",
         "sentry.debug=true",
+        "sentry.strict-callback-mode=true",
         "sentry.diagnostic-level=INFO",
         "sentry.sentry-client-name=my-client",
         "sentry.max-breadcrumbs=100",
@@ -257,6 +258,7 @@ class SentryAutoConfigurationTest {
         assertThat(options.shutdownTimeoutMillis).isEqualTo(20)
         assertThat(options.flushTimeoutMillis).isEqualTo(30)
         assertThat(options.isDebug).isTrue()
+        assertThat(options.isStrictCallbackMode).isTrue()
         assertThat(options.diagnosticLevel).isEqualTo(SentryLevel.INFO)
         assertThat(options.maxBreadcrumbs).isEqualTo(100)
         assertThat(options.release).isEqualTo("1.0.3")
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 400b602aa14..33604308b5a 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -583,6 +583,7 @@ public final class io/sentry/ExternalOptions {
 	public fun getSessionFlushTimeoutMillis ()Ljava/lang/Long;
 	public fun getShutdownTimeoutMillis ()Ljava/lang/Long;
 	public fun getSpotlightConnectionUrl ()Ljava/lang/String;
+	public fun getStrictCallbackMode ()Ljava/lang/Boolean;
 	public fun getTags ()Ljava/util/Map;
 	public fun getTracePropagationTargets ()Ljava/util/List;
 	public fun getTracesSampleRate ()Ljava/lang/Double;
@@ -643,6 +644,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 setStrictCallbackMode (Ljava/lang/Boolean;)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
@@ -3914,6 +3916,7 @@ public class io/sentry/SentryOptions : io/sentry/transport/RateLimiterConfig {
 	public fun isSendDefaultPii ()Z
 	public fun isSendModules ()Z
 	public fun isStartProfilerOnAppStart ()Z
+	public fun isStrictCallbackMode ()Z
 	public fun isStrictTraceContinuation ()Z
 	public fun isTraceOptionsRequests ()Z
 	public fun isTraceSampling ()Z
@@ -4036,6 +4039,7 @@ public class io/sentry/SentryOptions : io/sentry/transport/RateLimiterConfig {
 	public fun setSpotlightConnectionUrl (Ljava/lang/String;)V
 	public fun setSslSocketFactory (Ljavax/net/ssl/SSLSocketFactory;)V
 	public fun setStartProfilerOnAppStart (Z)V
+	public fun setStrictCallbackMode (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
@@ -5237,6 +5241,14 @@ public final class io/sentry/exception/InvalidSentryTraceHeaderException : java/
 	public fun getSentryTraceHeader ()Ljava/lang/String;
 }
 
+public final class io/sentry/exception/SentryCallbackError : java/lang/Error {
+	public fun <init> (Ljava/lang/Error;)V
+}
+
+public final class io/sentry/exception/SentryCallbackException : java/lang/RuntimeException {
+	public fun <init> (Ljava/lang/Throwable;)V
+}
+
 public final class io/sentry/exception/SentryEnvelopeException : java/lang/Exception {
 	public fun <init> (Ljava/lang/String;)V
 	public fun <init> (Ljava/lang/String;Ljava/lang/Throwable;)V
@@ -7859,6 +7871,12 @@ public final class io/sentry/util/AutoClosableReentrantLock : io/sentry/ISentryL
 	public fun close ()V
 }
 
+public final class io/sentry/util/CallbackUtils {
+	public static fun isCallbackException (Ljava/lang/Throwable;)Z
+	public static fun rethrowIfStrictCallbackMode (Lio/sentry/SentryOptions;Ljava/lang/Throwable;)V
+	public static fun run (Lio/sentry/SentryOptions;Ljava/lang/Runnable;)V
+}
+
 public final class io/sentry/util/CheckInUtils {
 	public fun <init> ()V
 	public static fun isIgnored (Ljava/util/List;Ljava/lang/String;)Z
@@ -7937,6 +7955,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 maybeRethrow (Ljava/lang/Throwable;)V
 	public static fun rethrowIfFatal (Ljava/lang/Throwable;)V
 }
 
diff --git a/sentry/src/main/java/io/sentry/ExternalOptions.java b/sentry/src/main/java/io/sentry/ExternalOptions.java
index 272cf1c13a9..d629c1b744d 100644
--- a/sentry/src/main/java/io/sentry/ExternalOptions.java
+++ b/sentry/src/main/java/io/sentry/ExternalOptions.java
@@ -22,6 +22,7 @@ public final class ExternalOptions {
   private @Nullable String serverName;
   private @Nullable Boolean enableUncaughtExceptionHandler;
   private @Nullable Boolean debug;
+  private @Nullable Boolean strictCallbackMode;
   private @Nullable Boolean enableDeduplication;
   private @Nullable Double sampleRate;
   private @Nullable Double tracesSampleRate;
@@ -90,6 +91,7 @@ public final class ExternalOptions {
     options.setTracesSampleRate(propertiesProvider.getDoubleProperty("traces-sample-rate"));
     options.setProfilesSampleRate(propertiesProvider.getDoubleProperty("profiles-sample-rate"));
     options.setDebug(propertiesProvider.getBooleanProperty("debug"));
+    options.setStrictCallbackMode(propertiesProvider.getBooleanProperty("strict-callback-mode"));
     options.setEnableDeduplication(propertiesProvider.getBooleanProperty("enable-deduplication"));
     options.setSendClientReports(propertiesProvider.getBooleanProperty("send-client-reports"));
     options.setForceInit(propertiesProvider.getBooleanProperty("force-init"));
@@ -401,6 +403,14 @@ public void setEnableUncaughtExceptionHandler(
     return tracePropagationTargets;
   }
 
+  public @Nullable Boolean getStrictCallbackMode() {
+    return strictCallbackMode;
+  }
+
+  public void setStrictCallbackMode(final @Nullable Boolean strictCallbackMode) {
+    this.strictCallbackMode = strictCallbackMode;
+  }
+
   public @Nullable Boolean getDebug() {
     return debug;
   }
diff --git a/sentry/src/main/java/io/sentry/NoOpHub.java b/sentry/src/main/java/io/sentry/NoOpHub.java
index d6ec5774e2b..f78f8bef62e 100644
--- a/sentry/src/main/java/io/sentry/NoOpHub.java
+++ b/sentry/src/main/java/io/sentry/NoOpHub.java
@@ -155,12 +155,12 @@ public void popScope() {}
 
   @Override
   public void withScope(@NotNull ScopeCallback callback) {
-    callback.run(NoOpScope.getInstance());
+    io.sentry.util.CallbackUtils.run(getOptions(), () -> callback.run(NoOpScope.getInstance()));
   }
 
   @Override
   public void withIsolationScope(@NotNull ScopeCallback callback) {
-    callback.run(NoOpScope.getInstance());
+    io.sentry.util.CallbackUtils.run(getOptions(), () -> callback.run(NoOpScope.getInstance()));
   }
 
   @Override
diff --git a/sentry/src/main/java/io/sentry/NoOpScopes.java b/sentry/src/main/java/io/sentry/NoOpScopes.java
index b9c650c42a8..9265760a303 100644
--- a/sentry/src/main/java/io/sentry/NoOpScopes.java
+++ b/sentry/src/main/java/io/sentry/NoOpScopes.java
@@ -152,12 +152,12 @@ public void popScope() {}
 
   @Override
   public void withScope(@NotNull ScopeCallback callback) {
-    callback.run(NoOpScope.getInstance());
+    io.sentry.util.CallbackUtils.run(getOptions(), () -> callback.run(NoOpScope.getInstance()));
   }
 
   @Override
   public void withIsolationScope(@NotNull ScopeCallback callback) {
-    callback.run(NoOpScope.getInstance());
+    io.sentry.util.CallbackUtils.run(getOptions(), () -> callback.run(NoOpScope.getInstance()));
   }
 
   @Override
diff --git a/sentry/src/main/java/io/sentry/Scope.java b/sentry/src/main/java/io/sentry/Scope.java
index 42aef2821ac..0760a1c35dd 100644
--- a/sentry/src/main/java/io/sentry/Scope.java
+++ b/sentry/src/main/java/io/sentry/Scope.java
@@ -468,6 +468,7 @@ public Queue<Breadcrumb> getBreadcrumbs() {
     try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
       breadcrumb = callback.execute(breadcrumb, hint);
     } catch (Throwable e) {
+      io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
       options
           .getLogger()
           .log(
@@ -1005,7 +1006,7 @@ public void addEventProcessor(final @NotNull EventProcessor eventProcessor) {
   public Session withSession(final @NotNull IWithSession sessionCallback) {
     Session cloneSession = null;
     try (final @NotNull ISentryLifecycleToken ignored = sessionLock.acquire()) {
-      sessionCallback.accept(session);
+      io.sentry.util.CallbackUtils.run(options, () -> sessionCallback.accept(session));
 
       if (session != null) {
         cloneSession = session.clone();
@@ -1134,7 +1135,7 @@ public Session endSession() {
   @Override
   public void withTransaction(final @NotNull IWithTransaction callback) {
     try (final @NotNull ISentryLifecycleToken ignored = transactionLock.acquire()) {
-      callback.accept(transaction);
+      io.sentry.util.CallbackUtils.run(options, () -> callback.accept(transaction));
     }
   }
 
@@ -1181,7 +1182,7 @@ public void setPropagationContext(final @NotNull PropagationContext propagationC
   public @NotNull PropagationContext withPropagationContext(
       final @NotNull IWithPropagationContext callback) {
     try (final @NotNull ISentryLifecycleToken ignored = propagationContextLock.acquire()) {
-      callback.accept(propagationContext);
+      io.sentry.util.CallbackUtils.run(options, () -> callback.accept(propagationContext));
       return new PropagationContext(propagationContext);
     }
   }
diff --git a/sentry/src/main/java/io/sentry/Scopes.java b/sentry/src/main/java/io/sentry/Scopes.java
index d3926d56993..7bb35ad6647 100644
--- a/sentry/src/main/java/io/sentry/Scopes.java
+++ b/sentry/src/main/java/io/sentry/Scopes.java
@@ -9,6 +9,8 @@
 import io.sentry.metrics.MetricsApi;
 import io.sentry.protocol.*;
 import io.sentry.transport.RateLimiter;
+import io.sentry.util.CallbackUtils;
+import io.sentry.util.ExceptionUtils;
 import io.sentry.util.HintUtils;
 import io.sentry.util.Objects;
 import io.sentry.util.SpanUtils;
@@ -146,6 +148,9 @@ public boolean isEnabled() {
       final @NotNull SentryEvent event,
       final @Nullable Hint hint,
       final @Nullable ScopeCallback scopeCallback) {
+    if (event != null && CallbackUtils.isCallbackException(event.getThrowable())) {
+      return SentryId.EMPTY_ID;
+    }
     SentryId sentryId = SentryId.EMPTY_ID;
     if (!isEnabled()) {
       getOptions()
@@ -164,6 +169,7 @@ public boolean isEnabled() {
         sentryId = getClient().captureEvent(event, localScope, hint);
         updateLastEventId(sentryId);
       } catch (Throwable e) {
+        ExceptionUtils.maybeRethrow(e);
         getOptions()
             .getLogger()
             .log(
@@ -192,6 +198,7 @@ private void assignTraceContext(final @NotNull SentryEvent event) {
         callback.run(localScope);
         return localScope;
       } catch (Throwable t) {
+        CallbackUtils.rethrowIfStrictCallbackMode(getOptions(), t);
         getOptions()
             .getLogger()
             .log(SentryLevel.ERROR, "Error in the 'ScopeCallback' callback.", t);
@@ -235,6 +242,7 @@ private void assignTraceContext(final @NotNull SentryEvent event) {
 
         sentryId = getClient().captureMessage(message, level, localScope);
       } catch (Throwable e) {
+        ExceptionUtils.maybeRethrow(e);
         getOptions()
             .getLogger()
             .log(SentryLevel.ERROR, "Error while capturing message: " + message, e);
@@ -266,6 +274,7 @@ private void assignTraceContext(final @NotNull SentryEvent event) {
 
         sentryId = getClient().captureFeedback(feedback, hint, localScope);
       } catch (Throwable e) {
+        ExceptionUtils.maybeRethrow(e);
         getOptions()
             .getLogger()
             .log(SentryLevel.ERROR, "Error while capturing feedback: " + feedback.getMessage(), e);
@@ -294,6 +303,7 @@ private void assignTraceContext(final @NotNull SentryEvent event) {
           sentryId = capturedEnvelopeId;
         }
       } catch (Throwable e) {
+        ExceptionUtils.maybeRethrow(e);
         getOptions().getLogger().log(SentryLevel.ERROR, "Error while capturing envelope.", e);
       }
     }
@@ -319,6 +329,9 @@ private void assignTraceContext(final @NotNull SentryEvent event) {
       final @NotNull Throwable throwable,
       final @Nullable Hint hint,
       final @Nullable ScopeCallback scopeCallback) {
+    if (CallbackUtils.isCallbackException(throwable)) {
+      return SentryId.EMPTY_ID;
+    }
     SentryId sentryId = SentryId.EMPTY_ID;
     if (!isEnabled()) {
       getOptions()
@@ -339,6 +352,7 @@ private void assignTraceContext(final @NotNull SentryEvent event) {
 
         sentryId = getClient().captureEvent(event, localScope, hint);
       } catch (Throwable e) {
+        ExceptionUtils.maybeRethrow(e);
         getOptions()
             .getLogger()
             .log(
@@ -362,6 +376,7 @@ public void captureUserFeedback(final @NotNull UserFeedback userFeedback) {
       try {
         getClient().captureUserFeedback(userFeedback);
       } catch (Throwable e) {
+        ExceptionUtils.maybeRethrow(e);
         getOptions()
             .getLogger()
             .log(
@@ -499,6 +514,7 @@ public void close(final boolean isRestarting) {
         configureScope(ScopeType.ISOLATION, scope -> scope.getClient().close(isRestarting));
         configureScope(ScopeType.GLOBAL, scope -> scope.getClient().close(isRestarting));
       } catch (Throwable e) {
+        ExceptionUtils.maybeRethrow(e);
         getOptions().getLogger().log(SentryLevel.ERROR, "Error while closing the Scopes.", e);
       }
     }
@@ -712,6 +728,7 @@ public void withScope(final @NotNull ScopeCallback callback) {
       try {
         callback.run(NoOpScope.getInstance());
       } catch (Throwable e) {
+        CallbackUtils.rethrowIfStrictCallbackMode(getOptions(), e);
         getOptions().getLogger().log(SentryLevel.ERROR, "Error in the 'withScope' callback.", e);
       }
 
@@ -720,6 +737,7 @@ public void withScope(final @NotNull ScopeCallback callback) {
       try (final @NotNull ISentryLifecycleToken ignored = forkedScopes.makeCurrent()) {
         callback.run(forkedScopes.getScope());
       } catch (Throwable e) {
+        CallbackUtils.rethrowIfStrictCallbackMode(getOptions(), e);
         getOptions().getLogger().log(SentryLevel.ERROR, "Error in the 'withScope' callback.", e);
       }
     }
@@ -731,6 +749,7 @@ public void withIsolationScope(final @NotNull ScopeCallback callback) {
       try {
         callback.run(NoOpScope.getInstance());
       } catch (Throwable e) {
+        CallbackUtils.rethrowIfStrictCallbackMode(getOptions(), e);
         getOptions()
             .getLogger()
             .log(SentryLevel.ERROR, "Error in the 'withIsolationScope' callback.", e);
@@ -741,6 +760,7 @@ public void withIsolationScope(final @NotNull ScopeCallback callback) {
       try (final @NotNull ISentryLifecycleToken ignored = forkedScopes.makeCurrent()) {
         callback.run(forkedScopes.getIsolationScope());
       } catch (Throwable e) {
+        CallbackUtils.rethrowIfStrictCallbackMode(getOptions(), e);
         getOptions()
             .getLogger()
             .log(SentryLevel.ERROR, "Error in the 'withIsolationScope' callback.", e);
@@ -761,6 +781,7 @@ public void configureScope(
       try {
         callback.run(combinedScope.getSpecificScope(scopeType));
       } catch (Throwable e) {
+        CallbackUtils.rethrowIfStrictCallbackMode(getOptions(), e);
         getOptions()
             .getLogger()
             .log(SentryLevel.ERROR, "Error in the 'configureScope' callback.", e);
@@ -794,6 +815,7 @@ public void flush(long timeoutMillis) {
       try {
         getClient().flush(timeoutMillis);
       } catch (Throwable e) {
+        ExceptionUtils.maybeRethrow(e);
         getOptions().getLogger().log(SentryLevel.ERROR, "Error in the 'client.flush'.", e);
       }
     }
@@ -877,6 +899,7 @@ public void flush(long timeoutMillis) {
                         hint,
                         profilingTraceData);
           } catch (Throwable e) {
+            ExceptionUtils.maybeRethrow(e);
             getOptions()
                 .getLogger()
                 .log(
@@ -907,6 +930,7 @@ public void flush(long timeoutMillis) {
       try {
         sentryId = getClient().captureProfileChunk(profilingContinuousData, getScope());
       } catch (Throwable e) {
+        ExceptionUtils.maybeRethrow(e);
         getOptions()
             .getLogger()
             .log(
@@ -1212,6 +1236,7 @@ public void reportFullyDisplayed() {
       try {
         sentryId = getClient().captureCheckIn(checkIn, getCombinedScopeView(), null);
       } catch (Throwable e) {
+        ExceptionUtils.maybeRethrow(e);
         getOptions()
             .getLogger()
             .log(SentryLevel.ERROR, "Error while capturing check-in for slug", e);
@@ -1235,6 +1260,7 @@ public void reportFullyDisplayed() {
       try {
         sentryId = getClient().captureReplayEvent(replay, getCombinedScopeView(), hint);
       } catch (Throwable e) {
+        ExceptionUtils.maybeRethrow(e);
         getOptions().getLogger().log(SentryLevel.ERROR, "Error while capturing replay", e);
       }
     }
diff --git a/sentry/src/main/java/io/sentry/Sentry.java b/sentry/src/main/java/io/sentry/Sentry.java
index 03288ae00ad..43de1dc49b9 100644
--- a/sentry/src/main/java/io/sentry/Sentry.java
+++ b/sentry/src/main/java/io/sentry/Sentry.java
@@ -279,6 +279,7 @@ private static <T extends SentryOptions> void applyOptionsConfiguration(
     try {
       optionsConfiguration.configure(options);
     } catch (Throwable t) {
+      io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, t);
       options
           .getLogger()
           .log(SentryLevel.ERROR, "Error in the 'OptionsConfiguration.configure' callback.", t);
@@ -517,6 +518,7 @@ private static void handleAppStartProfilingConfig(
                   }
                 }
               } catch (Throwable e) {
+                io.sentry.util.ExceptionUtils.maybeRethrow(e);
                 options
                     .getLogger()
                     .log(
@@ -525,6 +527,7 @@ private static void handleAppStartProfilingConfig(
             }
           });
     } catch (Throwable e) {
+      io.sentry.util.ExceptionUtils.maybeRethrow(e);
       options
           .getLogger()
           .log(
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index c0758a4efd4..6cedc90f9e3 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -94,6 +94,9 @@ private boolean shouldApplyScopeData(final @NotNull CheckIn event, final @NotNul
   public @NotNull SentryId captureEvent(
       @NotNull SentryEvent event, final @Nullable IScope scope, @Nullable Hint hint) {
     Objects.requireNonNull(event, "SentryEvent is required.");
+    if (io.sentry.util.CallbackUtils.isCallbackException(event.getThrowable())) {
+      return SentryId.EMPTY_ID;
+    }
 
     // Drop silently to prevent recursion; a log here can re-enter through a logging integration.
     if (SentryCallbackReentrancyGuard.isActive()) {
@@ -229,6 +232,7 @@ private boolean shouldApplyScopeData(final @NotNull CheckIn event, final @NotNul
         try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
           shouldCaptureReplay = beforeErrorSampling.execute(event, hint);
         } catch (Throwable e) {
+          io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
           options
               .getLogger()
               .log(
@@ -494,6 +498,10 @@ private SentryEvent processEvent(
           event = processor.process(event, hint);
         }
       } catch (Throwable e) {
+        io.sentry.util.ExceptionUtils.maybeRethrow(e);
+        if (!(processor instanceof SentryEventProcessor)) {
+          io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
+        }
         options
             .getLogger()
             .log(
@@ -551,6 +559,10 @@ private SentryLogEvent processLogEvent(
       try {
         event = processor.process(event);
       } catch (Throwable e) {
+        io.sentry.util.ExceptionUtils.maybeRethrow(e);
+        if (!(processor instanceof SentryEventProcessor)) {
+          io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
+        }
         options
             .getLogger()
             .log(
@@ -588,6 +600,10 @@ private SentryMetricsEvent processMetricsEvent(
       try {
         event = processor.process(event, hint);
       } catch (Throwable e) {
+        io.sentry.util.ExceptionUtils.maybeRethrow(e);
+        if (!(processor instanceof SentryEventProcessor)) {
+          io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
+        }
         options
             .getLogger()
             .log(
@@ -625,6 +641,10 @@ private SentryMetricsEvent processMetricsEvent(
       try {
         transaction = processor.process(transaction, hint);
       } catch (Throwable e) {
+        io.sentry.util.ExceptionUtils.maybeRethrow(e);
+        if (!(processor instanceof SentryEventProcessor)) {
+          io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
+        }
         options
             .getLogger()
             .log(
@@ -698,6 +718,10 @@ private SentryReplayEvent processReplayEvent(
       try {
         replayEvent = processor.process(replayEvent, hint);
       } catch (Throwable e) {
+        io.sentry.util.ExceptionUtils.maybeRethrow(e);
+        if (!(processor instanceof SentryEventProcessor)) {
+          io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
+        }
         options
             .getLogger()
             .log(
@@ -738,6 +762,10 @@ private SentryEvent processFeedbackEvent(
       try {
         feedbackEvent = processor.process(feedbackEvent, hint);
       } catch (Throwable e) {
+        io.sentry.util.ExceptionUtils.maybeRethrow(e);
+        if (!(processor instanceof SentryEventProcessor)) {
+          io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
+        }
         options
             .getLogger()
             .log(
@@ -997,6 +1025,7 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
       try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
         beforeEnvelopeCallback.execute(envelope, hint);
       } catch (Throwable e) {
+        io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
         options
             .getLogger()
             .log(SentryLevel.ERROR, "The BeforeEnvelope callback threw an exception.", e);
@@ -1660,6 +1689,7 @@ private void sortBreadcrumbsByDate(
       try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
         event = beforeSend.execute(event, hint);
       } catch (Throwable e) {
+        io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
         options
             .getLogger()
             .log(
@@ -1689,6 +1719,7 @@ private void sortBreadcrumbsByDate(
       try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
         transaction = beforeSendTransaction.execute(transaction, hint);
       } catch (Throwable e) {
+        io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
         options
             .getLogger()
             .log(
@@ -1749,6 +1780,7 @@ private void sortBreadcrumbsByDate(
       try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
         event = beforeSendFeedback.execute(event, hint);
       } catch (Throwable e) {
+        io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
         options
             .getLogger()
             .log(
@@ -1776,6 +1808,7 @@ private void sortBreadcrumbsByDate(
       try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
         event = beforeSendReplay.execute(event, hint);
       } catch (Throwable e) {
+        io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
         options
             .getLogger()
             .log(
@@ -1804,6 +1837,7 @@ private void sortBreadcrumbsByDate(
       try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
         event = beforeSendLog.execute(event);
       } catch (Throwable e) {
+        io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
         options
             .getLogger()
             .log(
@@ -1829,6 +1863,7 @@ private void sortBreadcrumbsByDate(
       try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
         event = beforeSendMetric.execute(event, hint);
       } catch (Throwable e) {
+        io.sentry.util.CallbackUtils.rethrowIfStrictCallbackMode(options, e);
         options
             .getLogger()
             .log(
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index 2b2f9d370a0..5a34a0fbbd8 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -139,6 +139,8 @@ public class SentryOptions implements RateLimiterConfig {
    */
   private boolean debug;
 
+  private boolean strictCallbackMode = false;
+
   /** Logger interface to log useful debugging information if debug is enabled */
   private @NotNull ILogger logger = NoOpLogger.getInstance();
 
@@ -848,6 +850,22 @@ public void setDebug(final boolean debug) {
     this.debug = debug;
   }
 
+  /** Returns whether user callback failures are propagated. Disabled by default. */
+  public boolean isStrictCallbackMode() {
+    return strictCallbackMode;
+  }
+
+  /**
+   * Enables propagating user callback failures wrapped in an SDK exception or error instead of
+   * isolating them. Events containing these failures are silently excluded from capture to avoid
+   * sending data without the failed callback's filtering.
+   *
+   * @param strictCallbackMode whether to propagate user callback failures
+   */
+  public void setStrictCallbackMode(final boolean strictCallbackMode) {
+    this.strictCallbackMode = strictCallbackMode;
+  }
+
   /**
    * Returns the Logger interface
    *
@@ -3703,6 +3721,9 @@ public void merge(final @NotNull ExternalOptions options) {
     if (options.getDebug() != null) {
       setDebug(options.getDebug());
     }
+    if (options.getStrictCallbackMode() != null) {
+      setStrictCallbackMode(options.getStrictCallbackMode());
+    }
     if (options.getEnableDeduplication() != null) {
       setEnableDeduplication(options.getEnableDeduplication());
     }
diff --git a/sentry/src/main/java/io/sentry/SentryTracer.java b/sentry/src/main/java/io/sentry/SentryTracer.java
index d60187cb4d5..20108f9523c 100644
--- a/sentry/src/main/java/io/sentry/SentryTracer.java
+++ b/sentry/src/main/java/io/sentry/SentryTracer.java
@@ -222,7 +222,8 @@ public void finish(
             final @Nullable TransactionFinishedCallback finishedCallback =
                 transactionOptions.getTransactionFinishedCallback();
             if (finishedCallback != null) {
-              finishedCallback.execute(this);
+              io.sentry.util.CallbackUtils.run(
+                  scopes.getOptions(), () -> finishedCallback.execute(this));
             }
 
             if (compositePerformanceCollector != null) {
diff --git a/sentry/src/main/java/io/sentry/Span.java b/sentry/src/main/java/io/sentry/Span.java
index 7ee7eed1900..afc67d04363 100644
--- a/sentry/src/main/java/io/sentry/Span.java
+++ b/sentry/src/main/java/io/sentry/Span.java
@@ -232,8 +232,9 @@ public void finish(final @Nullable SpanStatus status, final @Nullable SentryDate
     if (throwable != null) {
       scopes.setSpanContext(throwable, this, this.transaction.getName());
     }
-    if (spanFinishedCallback != null) {
-      spanFinishedCallback.execute(this);
+    final @Nullable SpanFinishedCallback callback = spanFinishedCallback;
+    if (callback != null) {
+      io.sentry.util.CallbackUtils.run(scopes.getOptions(), () -> callback.execute(this));
     }
     finished = true;
   }
diff --git a/sentry/src/main/java/io/sentry/TracesSampler.java b/sentry/src/main/java/io/sentry/TracesSampler.java
index bb6e5d9f11f..8b0ee327b26 100644
--- a/sentry/src/main/java/io/sentry/TracesSampler.java
+++ b/sentry/src/main/java/io/sentry/TracesSampler.java
@@ -1,6 +1,7 @@
 package io.sentry;
 
 import io.sentry.clientreport.DiscardReason;
+import io.sentry.util.CallbackUtils;
 import io.sentry.util.Objects;
 import io.sentry.util.SampleRateUtils;
 import org.jetbrains.annotations.ApiStatus;
@@ -31,6 +32,7 @@ public TracesSamplingDecision sample(final @NotNull SamplingContext samplingCont
       try {
         profilesSampleRate = options.getProfilesSampler().sample(samplingContext);
       } catch (Throwable t) {
+        CallbackUtils.rethrowIfStrictCallbackMode(options, t);
         profilesSamplerFailed = true;
         options
             .getLogger()
@@ -47,6 +49,7 @@ public TracesSamplingDecision sample(final @NotNull SamplingContext samplingCont
       try {
         samplerResult = options.getTracesSampler().sample(samplingContext);
       } catch (Throwable t) {
+        CallbackUtils.rethrowIfStrictCallbackMode(options, t);
         options
             .getLogger()
             .log(SentryLevel.ERROR, "Error in the 'TracesSamplerCallback' callback.", t);
diff --git a/sentry/src/main/java/io/sentry/UncaughtExceptionHandlerIntegration.java b/sentry/src/main/java/io/sentry/UncaughtExceptionHandlerIntegration.java
index 6ea61895799..89a8e03b9f5 100644
--- a/sentry/src/main/java/io/sentry/UncaughtExceptionHandlerIntegration.java
+++ b/sentry/src/main/java/io/sentry/UncaughtExceptionHandlerIntegration.java
@@ -108,47 +108,54 @@ public final void register(final @NotNull IScopes scopes, final @NotNull SentryO
   @Override
   public void uncaughtException(Thread thread, Throwable thrown) {
     if (options != null && scopes != null) {
-      options.getLogger().log(SentryLevel.INFO, "Uncaught exception received.");
-
-      try {
-        final UncaughtExceptionHint exceptionHint =
-            new UncaughtExceptionHint(options.getFlushTimeoutMillis(), options.getLogger());
-        final Throwable throwable = getUnhandledThrowable(thread, thrown);
-        final SentryEvent event = new SentryEvent(throwable);
-        event.setLevel(SentryLevel.FATAL);
-
-        final ITransaction transaction = scopes.getTransaction();
-        if (transaction == null && event.getEventId() != null) {
-          // if there's no active transaction on scope, this event can trigger flush notification
-          exceptionHint.setFlushable(event.getEventId());
-        }
-        final Hint hint = HintUtils.createWithTypeCheckHint(exceptionHint);
-
-        final @NotNull SentryId sentryId = scopes.captureEvent(event, hint);
-        final boolean isEventDropped = sentryId.equals(SentryId.EMPTY_ID);
-        final EventDropReason eventDropReason = HintUtils.getEventDropReason(hint);
-        // in case the event has been dropped by multithreaded deduplicator, the other threads will
-        // crash the app without a chance to persist the main event so we have to special-case this
-        if (!isEventDropped
-            || EventDropReason.MULTITHREADED_DEDUPLICATION.equals(eventDropReason)) {
-          // Block until the event is flushed to disk
-          if (!exceptionHint.waitFlush()) {
-            options
-                .getLogger()
-                .log(
-                    SentryLevel.WARNING,
-                    "Timed out waiting to flush event to disk before crashing. Event: %s",
-                    event.getEventId());
+      final boolean callbackFailure = io.sentry.util.CallbackUtils.isCallbackException(thrown);
+      if (!callbackFailure) {
+        options.getLogger().log(SentryLevel.INFO, "Uncaught exception received.");
+
+        try {
+          final UncaughtExceptionHint exceptionHint =
+              new UncaughtExceptionHint(options.getFlushTimeoutMillis(), options.getLogger());
+          final Throwable throwable = getUnhandledThrowable(thread, thrown);
+          final SentryEvent event = new SentryEvent(throwable);
+          event.setLevel(SentryLevel.FATAL);
+
+          final ITransaction transaction = scopes.getTransaction();
+          if (transaction == null && event.getEventId() != null) {
+            // if there's no active transaction on scope, this event can trigger flush notification
+            exceptionHint.setFlushable(event.getEventId());
+          }
+          final Hint hint = HintUtils.createWithTypeCheckHint(exceptionHint);
+
+          final @NotNull SentryId sentryId = scopes.captureEvent(event, hint);
+          final boolean isEventDropped = sentryId.equals(SentryId.EMPTY_ID);
+          final EventDropReason eventDropReason = HintUtils.getEventDropReason(hint);
+          // in case the event has been dropped by multithreaded deduplicator, the other threads
+          // will
+          // crash the app without a chance to persist the main event so we have to special-case
+          // this
+          if (!isEventDropped
+              || EventDropReason.MULTITHREADED_DEDUPLICATION.equals(eventDropReason)) {
+            // Block until the event is flushed to disk
+            if (!exceptionHint.waitFlush()) {
+              options
+                  .getLogger()
+                  .log(
+                      SentryLevel.WARNING,
+                      "Timed out waiting to flush event to disk before crashing. Event: %s",
+                      event.getEventId());
+            }
           }
+        } catch (Throwable e) {
+          options
+              .getLogger()
+              .log(SentryLevel.ERROR, "Error sending uncaught exception to Sentry.", e);
         }
-      } catch (Throwable e) {
-        options
-            .getLogger()
-            .log(SentryLevel.ERROR, "Error sending uncaught exception to Sentry.", e);
       }
 
       if (defaultExceptionHandler != null) {
-        options.getLogger().log(SentryLevel.INFO, "Invoking inner uncaught exception handler.");
+        if (!callbackFailure) {
+          options.getLogger().log(SentryLevel.INFO, "Invoking inner uncaught exception handler.");
+        }
         defaultExceptionHandler.uncaughtException(thread, thrown);
       } else {
         if (options.isPrintUncaughtStackTrace()) {
diff --git a/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java b/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java
index ccd7c5dc402..e52ded990eb 100644
--- a/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java
+++ b/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java
@@ -9,6 +9,8 @@
 import io.sentry.SentryOptions;
 import io.sentry.protocol.SentrySpan;
 import io.sentry.protocol.SentryTransaction;
+import io.sentry.util.CallbackUtils;
+import io.sentry.util.ExceptionUtils;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
@@ -63,6 +65,7 @@ public void recordLostEnvelope(@NotNull DiscardReason reason, @Nullable SentryEn
         recordLostEnvelopeItem(reason, item);
       }
     } catch (Throwable e) {
+      ExceptionUtils.maybeRethrow(e);
       options.getLogger().log(SentryLevel.ERROR, e, "Unable to record lost envelope.");
     }
   }
@@ -119,6 +122,7 @@ public void recordLostEnvelopeItem(
         }
       }
     } catch (Throwable e) {
+      ExceptionUtils.maybeRethrow(e);
       options.getLogger().log(SentryLevel.ERROR, e, "Unable to record lost envelope item.");
     }
   }
@@ -135,6 +139,7 @@ public void recordLostEvent(
       recordLostEventInternal(reason.getReason(), category.getCategory(), count);
       executeOnDiscard(reason, category, count);
     } catch (Throwable e) {
+      ExceptionUtils.maybeRethrow(e);
       options.getLogger().log(SentryLevel.ERROR, e, "Unable to record lost event.");
     }
   }
@@ -145,6 +150,7 @@ private void executeOnDiscard(
       try {
         options.getOnDiscard().execute(reason, category, countToAdd);
       } catch (Throwable e) {
+        CallbackUtils.rethrowIfStrictCallbackMode(options, e);
         options.getLogger().log(SentryLevel.ERROR, "The onDiscard callback threw an exception.", e);
       }
     }
diff --git a/sentry/src/main/java/io/sentry/exception/SentryCallbackError.java b/sentry/src/main/java/io/sentry/exception/SentryCallbackError.java
new file mode 100644
index 00000000000..3ecf70372e0
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/exception/SentryCallbackError.java
@@ -0,0 +1,17 @@
+package io.sentry.exception;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * An error from a user callback propagated by strict callback mode without converting it to an
+ * exception.
+ */
+@ApiStatus.Internal
+public final class SentryCallbackError extends Error {
+  private static final long serialVersionUID = 1L;
+
+  public SentryCallbackError(final @NotNull Error cause) {
+    super("Sentry user callback failed in strict callback mode", cause);
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/exception/SentryCallbackException.java b/sentry/src/main/java/io/sentry/exception/SentryCallbackException.java
new file mode 100644
index 00000000000..663af4c51c0
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/exception/SentryCallbackException.java
@@ -0,0 +1,14 @@
+package io.sentry.exception;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+/** A user callback failure propagated by strict callback mode and excluded from event capture. */
+@ApiStatus.Internal
+public final class SentryCallbackException extends RuntimeException {
+  private static final long serialVersionUID = 1L;
+
+  public SentryCallbackException(final @NotNull Throwable cause) {
+    super("Sentry user callback failed in strict callback mode", cause);
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/logger/LoggerApi.java b/sentry/src/main/java/io/sentry/logger/LoggerApi.java
index 3741ddc6209..2f5a3e1fd7c 100644
--- a/sentry/src/main/java/io/sentry/logger/LoggerApi.java
+++ b/sentry/src/main/java/io/sentry/logger/LoggerApi.java
@@ -131,6 +131,7 @@ private void captureLog(
 
       scopes.getClient().captureLog(logEvent, combinedScope);
     } catch (Throwable e) {
+      io.sentry.util.ExceptionUtils.maybeRethrow(e);
       options.getLogger().log(SentryLevel.ERROR, "Error while capturing log event", e);
     }
   }
diff --git a/sentry/src/main/java/io/sentry/metrics/MetricsApi.java b/sentry/src/main/java/io/sentry/metrics/MetricsApi.java
index d70b4ab5c97..f0597636100 100644
--- a/sentry/src/main/java/io/sentry/metrics/MetricsApi.java
+++ b/sentry/src/main/java/io/sentry/metrics/MetricsApi.java
@@ -152,6 +152,7 @@ private void captureMetrics(
 
       scopes.getClient().captureMetric(metricsEvent, combinedScope, params.getHint());
     } catch (Throwable e) {
+      io.sentry.util.ExceptionUtils.maybeRethrow(e);
       options.getLogger().log(SentryLevel.ERROR, "Error while capturing metrics event", e);
     }
   }
diff --git a/sentry/src/main/java/io/sentry/util/CallbackUtils.java b/sentry/src/main/java/io/sentry/util/CallbackUtils.java
new file mode 100644
index 00000000000..a71c6eb245d
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/CallbackUtils.java
@@ -0,0 +1,40 @@
+package io.sentry.util;
+
+import io.sentry.SentryOptions;
+import io.sentry.exception.SentryCallbackError;
+import io.sentry.exception.SentryCallbackException;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@ApiStatus.Internal
+public final class CallbackUtils {
+  private CallbackUtils() {}
+
+  /** Marks failures from callbacks that already propagate their exceptions by default. */
+  public static void run(final @NotNull SentryOptions options, final @NotNull Runnable callback) {
+    try {
+      callback.run();
+    } catch (Exception | Error e) {
+      rethrowIfStrictCallbackMode(options, e);
+      throw e;
+    }
+  }
+
+  /** Call before logging or loss accounting at a user callback boundary. */
+  public static void rethrowIfStrictCallbackMode(
+      final @NotNull SentryOptions options, final @NotNull Throwable throwable) {
+    ExceptionUtils.maybeRethrow(throwable);
+    if (options.isStrictCallbackMode()) {
+      if (throwable instanceof Error) {
+        throw new SentryCallbackError((Error) throwable);
+      }
+      throw new SentryCallbackException(throwable);
+    }
+  }
+
+  /** Callback failures must be excluded before invoking any processors or other callbacks. */
+  public static boolean isCallbackException(final @Nullable Throwable throwable) {
+    return ExceptionUtils.findCallbackException(throwable) != null;
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/util/EventSizeLimitingUtils.java b/sentry/src/main/java/io/sentry/util/EventSizeLimitingUtils.java
index c6c3d1a48b2..5458a4e1ec9 100644
--- a/sentry/src/main/java/io/sentry/util/EventSizeLimitingUtils.java
+++ b/sentry/src/main/java/io/sentry/util/EventSizeLimitingUtils.java
@@ -69,6 +69,7 @@ private EventSizeLimitingUtils() {}
             return reducedEvent;
           }
         } catch (Throwable e) {
+          CallbackUtils.rethrowIfStrictCallbackMode(options, e);
           options
               .getLogger()
               .log(
@@ -96,6 +97,7 @@ private EventSizeLimitingUtils() {}
 
       return reducedEvent;
     } catch (Throwable e) {
+      ExceptionUtils.maybeRethrow(e);
       options
           .getLogger()
           .log(
diff --git a/sentry/src/main/java/io/sentry/util/ExceptionUtils.java b/sentry/src/main/java/io/sentry/util/ExceptionUtils.java
index c17470bfac3..52e2e8929e7 100644
--- a/sentry/src/main/java/io/sentry/util/ExceptionUtils.java
+++ b/sentry/src/main/java/io/sentry/util/ExceptionUtils.java
@@ -1,10 +1,14 @@
 package io.sentry.util;
 
+import io.sentry.exception.ExceptionMechanismException;
+import io.sentry.exception.SentryCallbackError;
+import io.sentry.exception.SentryCallbackException;
 import java.util.Collections;
 import java.util.IdentityHashMap;
 import java.util.Set;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 @ApiStatus.Internal
 public final class ExceptionUtils {
@@ -36,6 +40,43 @@ public static boolean isIgnored(
     return ignoredExceptionsForType.contains(throwable.getClass());
   }
 
+  /**
+   * Rethrows callback exception and error markers, including those nested in a cause chain,
+   * regardless of the current strict-callback-mode setting. Call before logging or discard
+   * accounting at SDK error-isolation boundaries. Other throwables are left for the caller to
+   * handle.
+   *
+   * @param throwable the failure to check
+   */
+  public static void maybeRethrow(final @NotNull Throwable throwable) {
+    final Throwable failure = findCallbackException(throwable);
+    if (failure instanceof SentryCallbackError) {
+      throw (SentryCallbackError) failure;
+    }
+    if (failure instanceof SentryCallbackException) {
+      throw (SentryCallbackException) failure;
+    }
+  }
+
+  static @Nullable Throwable findCallbackException(@Nullable Throwable throwable) {
+    if (throwable == null) {
+      return null;
+    }
+    final Set<Throwable> visited =
+        Collections.newSetFromMap(new IdentityHashMap<Throwable, Boolean>());
+    while (throwable != null && visited.add(throwable)) {
+      if (throwable instanceof SentryCallbackException
+          || throwable instanceof SentryCallbackError) {
+        return throwable;
+      }
+      throwable =
+          throwable instanceof ExceptionMechanismException
+              ? ((ExceptionMechanismException) throwable).getThrowable()
+              : throwable.getCause();
+    }
+    return null;
+  }
+
   /**
    * Rethrows non-recoverable {@link Throwable}s that should never be swallowed: {@link
    * VirtualMachineError} (e.g. OutOfMemoryError/StackOverflowError), {@link ThreadDeath} and {@link
diff --git a/sentry/src/test/java/io/sentry/StrictCallbackModeTest.kt b/sentry/src/test/java/io/sentry/StrictCallbackModeTest.kt
new file mode 100644
index 00000000000..dea20c16de9
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/StrictCallbackModeTest.kt
@@ -0,0 +1,282 @@
+package io.sentry
+
+import com.google.common.truth.Truth.assertThat
+import io.sentry.clientreport.DiscardReason
+import io.sentry.exception.ExceptionMechanismException
+import io.sentry.exception.SentryCallbackError
+import io.sentry.exception.SentryCallbackException
+import io.sentry.internal.eventprocessor.SentryEventProcessor
+import io.sentry.protocol.Feedback
+import io.sentry.protocol.Mechanism
+import io.sentry.protocol.SentryId
+import io.sentry.protocol.SentryTransaction
+import io.sentry.util.CallbackUtils
+import io.sentry.util.SentryCallbackReentrancyGuard
+import java.util.concurrent.CompletionException
+import kotlin.test.Test
+import kotlin.test.assertFails
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+import org.mockito.kotlin.any
+import org.mockito.kotlin.clearInvocations
+import org.mockito.kotlin.doAnswer
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verifyNoInteractions
+import org.mockito.kotlin.whenever
+
+@RunWith(Parameterized::class)
+class StrictCallbackModeTest(private val fatal: Boolean) {
+  companion object {
+    @JvmStatic @Parameterized.Parameters(name = "fatal={0}") fun data() = listOf(false, true)
+  }
+
+  private val failure: Throwable =
+    if (fatal) LinkageError("private callback data")
+    else IllegalStateException("private callback data")
+  private val fixture = SentryClientTest.Fixture()
+  private val options =
+    fixture.sentryOptions.apply {
+      isStrictCallbackMode = true
+      eventProcessors.clear()
+      logs.isEnabled = true
+      metrics.isEnabled = true
+    }
+  private val client = fixture.getSut()
+  private val scope = Scope(options).apply { bindClient(this@StrictCallbackModeTest.client) }
+  private val scopes = Scopes(scope, Scope(options), Scope(options), "strict-callback-mode-test")
+
+  private fun assertFailure(block: () -> Unit): Throwable {
+    val thrown = assertFails(block = block)
+    assertThat(thrown)
+      .isInstanceOf(
+        if (fatal) SentryCallbackError::class.java else SentryCallbackException::class.java
+      )
+    assertThat(thrown.cause).isSameInstanceAs(failure)
+    assertThat(SentryCallbackReentrancyGuard.isActive()).isFalse()
+    return thrown
+  }
+
+  @Test
+  fun `options configuration propagates marked failures`() {
+    assertFailure {
+      Sentry.init { configured ->
+        configured.isStrictCallbackMode = true
+        throw failure
+      }
+    }
+  }
+
+  @Test
+  fun `transaction finished callback propagates marked failures`() {
+    options.tracesSampleRate = 1.0
+    val transactionOptions =
+      TransactionOptions().apply {
+        setTransactionFinishedCallback { throw failure }
+      }
+    val transaction = scopes.startTransaction(TransactionContext("test", "op"), transactionOptions)
+    assertFailure { transaction.finish() }
+  }
+
+  @Test
+  fun `beforeSend escapes scopes and does not report a loss`() {
+    val onDiscard = mock<SentryOptions.OnDiscardCallback>()
+    options.onDiscard = onDiscard
+    options.setBeforeSend { _, _ -> throw failure }
+    assertFailure { scopes.captureEvent(SentryEvent()) }
+    verifyNoInteractions(onDiscard, fixture.transport)
+  }
+
+  @Test
+  fun `callback markers escape before logging even after strict callback mode is disabled`() {
+    val logger = mock<ILogger>()
+    val onDiscard = mock<SentryOptions.OnDiscardCallback>()
+    options.isDebug = true
+    options.setLogger(logger)
+    options.onDiscard = onDiscard
+    val marker =
+      if (fatal) SentryCallbackError(failure as Error) else SentryCallbackException(failure)
+    options.setBeforeSend { _, _ ->
+      clearInvocations(logger)
+      options.isStrictCallbackMode = false
+      throw marker
+    }
+    assertThat(assertFails { scopes.captureEvent(SentryEvent()) }).isSameInstanceAs(marker)
+    verifyNoInteractions(logger, onDiscard, fixture.transport)
+  }
+
+  @Test
+  fun `beforeSend escapes captureException and captureMessage`() {
+    options.setBeforeSend { _, _ -> throw failure }
+    assertFailure { scopes.captureException(IllegalArgumentException()) }
+    assertFailure { scopes.captureMessage("message") }
+  }
+
+  @Test
+  fun `beforeSendTransaction escapes scopes`() {
+    options.setBeforeSendTransaction { _, _ -> throw failure }
+    val transaction =
+      SentryTracer(TransactionContext("test", "op", TracesSamplingDecision(true)), scopes)
+    assertFailure { transaction.finish() }
+  }
+
+  @Test
+  fun `beforeSendFeedback escapes scopes`() {
+    options.setBeforeSendFeedback { _, _ -> throw failure }
+    assertFailure { scopes.captureFeedback(Feedback("feedback")) }
+  }
+
+  @Test
+  fun `beforeSendReplay escapes scopes`() {
+    options.setBeforeSendReplay { _, _ -> throw failure }
+    assertFailure { scopes.captureReplay(SentryReplayEvent(), Hint()) }
+  }
+
+  @Test
+  fun `beforeSendLog escapes logger API`() {
+    options.logs.setBeforeSend { throw failure }
+    assertFailure { scopes.logger().log(SentryLogLevel.INFO, "message") }
+  }
+
+  @Test
+  fun `beforeSendMetric escapes metrics API`() {
+    options.metrics.setBeforeSend { _, _ -> throw failure }
+    assertFailure { scopes.metrics().count("metric") }
+  }
+
+  @Test
+  fun `beforeEnvelope escapes scopes`() {
+    options.setBeforeEnvelopeCallback { _, _ -> throw failure }
+    assertFailure { scopes.captureEvent(SentryEvent()) }
+    verifyNoInteractions(fixture.transport)
+  }
+
+  @Test
+  fun `beforeBreadcrumb escapes and is not added`() {
+    options.setBeforeBreadcrumb { _, _ -> throw failure }
+    assertFailure { scopes.addBreadcrumb(Breadcrumb("private")) }
+    assertThat(scope.breadcrumbs).isEmpty()
+  }
+
+  @Test
+  fun `tracesSampler and profilesSampler escape without fallback`() {
+    options.tracesSampleRate = 1.0
+    options.setTracesSampler { throw failure }
+    assertFailure { scopes.startTransaction("test", "op") }
+    options.tracesSampler = null
+    options.setProfilesSampler { throw failure }
+    assertFailure { scopes.startTransaction("test", "op") }
+  }
+
+  @Test
+  fun `beforeErrorSampling escapes without capturing replay`() {
+    options.sessionReplay.setBeforeErrorSampling { _, _ -> throw failure }
+    val event =
+      SentryEvent().apply {
+        exceptions =
+          listOf(io.sentry.protocol.SentryException().apply { type = "IllegalArgumentException" })
+      }
+    assertFailure { scopes.captureEvent(event) }
+  }
+
+  @Test
+  fun `onDiscard escapes its enclosing recorder catches`() {
+    options.setOnDiscard { _, _, _ -> throw failure }
+    assertFailure {
+      options.clientReportRecorder.recordLostEvent(DiscardReason.SAMPLE_RATE, DataCategory.Error)
+    }
+    options.setBeforeSend { _, _ -> null }
+    assertFailure { scopes.captureEvent(SentryEvent()) }
+  }
+
+  @Test
+  fun `scope callbacks escape and restore current scopes`() {
+    val previous = Sentry.getCurrentScopes()
+    assertFailure { scopes.withScope { throw failure } }
+    assertThat(Sentry.getCurrentScopes()).isSameInstanceAs(previous)
+    assertFailure { scopes.withIsolationScope { throw failure } }
+    assertThat(Sentry.getCurrentScopes()).isSameInstanceAs(previous)
+    assertFailure { scopes.configureScope { throw failure } }
+    assertFailure { scopes.captureEvent(SentryEvent(), ScopeCallback { throw failure }) }
+  }
+
+  @Test
+  fun `onOversizedEvent escapes the size limiter and scopes catches`() {
+    options.setOnOversizedEvent { _, _ -> throw failure }
+    options.isEnableEventSizeLimiting = true
+    val event =
+      SentryEvent().apply {
+        setExtra("large", "x".repeat(SentryOptions.MAX_EVENT_SIZE_BYTES.toInt() + 1))
+      }
+    assertFailure { scopes.captureEvent(event) }
+  }
+
+  @Test
+  fun `all customer processor types propagate failures`() {
+    val processor = mock<EventProcessor>()
+    doAnswer { throw failure }.whenever(processor).process(any<SentryEvent>(), any())
+    doAnswer { throw failure }.whenever(processor).process(any<SentryTransaction>(), any())
+    doAnswer { throw failure }.whenever(processor).process(any<SentryReplayEvent>(), any())
+    doAnswer { throw failure }.whenever(processor).process(any<SentryLogEvent>())
+    doAnswer { throw failure }.whenever(processor).process(any<SentryMetricsEvent>(), any())
+    for (onScope in listOf(false, true)) {
+      if (onScope) scope.addEventProcessor(processor) else options.addEventProcessor(processor)
+      assertFailure { scopes.captureEvent(SentryEvent()) }
+      assertFailure { scopes.captureFeedback(Feedback("feedback")) }
+      // Replays only run options-level processors.
+      if (!onScope) assertFailure { scopes.captureReplay(SentryReplayEvent(), Hint()) }
+      assertFailure {
+        client.captureTransaction(SentryTransaction(fixture.sentryTracer), scope, null)
+      }
+      assertFailure { scopes.logger().log(SentryLogLevel.INFO, "message") }
+      assertFailure { scopes.metrics().count("metric") }
+      options.eventProcessors.clear()
+    }
+  }
+
+  @Test
+  fun `SDK processor failures are not converted but nested callback markers escape`() {
+    val processor = mock<SentryEventProcessor>()
+    doAnswer { throw failure }.whenever(processor).process(any<SentryEvent>(), any())
+    options.addEventProcessor(processor)
+    val event = SentryEvent()
+    assertThat(scopes.captureEvent(event)).isEqualTo(event.eventId)
+    val marker = assertFailure { CallbackUtils.rethrowIfStrictCallbackMode(options, failure) }
+    doAnswer { throw marker }.whenever(processor).process(any<SentryEvent>(), any())
+    assertThat(assertFails { scopes.captureEvent(SentryEvent()) }).isSameInstanceAs(marker)
+  }
+
+  @Test
+  fun `capture silently excludes nested callback failures even with strict callback mode disabled`() {
+    val marker = assertFailure { CallbackUtils.rethrowIfStrictCallbackMode(options, failure) }
+    val throwable = CompletionException(IllegalArgumentException("outer", marker))
+    val mechanismWrapper =
+      ExceptionMechanismException(Mechanism(), throwable, Thread.currentThread())
+    val callback = mock<ScopeCallback>()
+    val processor = mock<EventProcessor>()
+    val beforeSend = mock<SentryOptions.BeforeSendCallback>()
+    val onDiscard = mock<SentryOptions.OnDiscardCallback>()
+    val logger = mock<ILogger>()
+    options.addEventProcessor(processor)
+    options.beforeSend = beforeSend
+    options.onDiscard = onDiscard
+    options.setLogger(logger)
+    options.isStrictCallbackMode = false
+    clearInvocations(logger, fixture.transport)
+    for (wrapped in listOf(marker, throwable, mechanismWrapper)) {
+      assertThat(scopes.captureException(wrapped, callback)).isEqualTo(SentryId.EMPTY_ID)
+      assertThat(scopes.captureEvent(SentryEvent(wrapped), callback)).isEqualTo(SentryId.EMPTY_ID)
+      assertThat(client.captureEvent(SentryEvent(wrapped), scope)).isEqualTo(SentryId.EMPTY_ID)
+    }
+    verifyNoInteractions(callback, processor, beforeSend, onDiscard, logger, fixture.transport)
+  }
+
+  @Test
+  fun `default behavior still isolates failures and intentional drops remain drops`() {
+    options.isStrictCallbackMode = false
+    options.setBeforeSend { _, _ -> throw failure }
+    assertThat(scopes.captureEvent(SentryEvent())).isEqualTo(SentryId.EMPTY_ID)
+    options.isStrictCallbackMode = true
+    options.setBeforeSend { _, _ -> null }
+    assertThat(scopes.captureEvent(SentryEvent())).isEqualTo(SentryId.EMPTY_ID)
+  }
+}
diff --git a/sentry/src/test/java/io/sentry/UncaughtExceptionHandlerIntegrationTest.kt b/sentry/src/test/java/io/sentry/UncaughtExceptionHandlerIntegrationTest.kt
index 02da3b9a335..3877fc1a8d8 100644
--- a/sentry/src/test/java/io/sentry/UncaughtExceptionHandlerIntegrationTest.kt
+++ b/sentry/src/test/java/io/sentry/UncaughtExceptionHandlerIntegrationTest.kt
@@ -59,6 +59,23 @@ class UncaughtExceptionHandlerIntegrationTest {
 
   private val fixture = Fixture()
 
+  @Test
+  fun `callback failures skip all SDK handling but reach the application handler`() {
+    val sut = fixture.getSut(hasDefaultHandler = true)
+    sut.register(fixture.scopes, fixture.options)
+    org.mockito.kotlin.clearInvocations(fixture.scopes, fixture.logger)
+    for (marker in
+      listOf(
+        io.sentry.exception.SentryCallbackException(IllegalStateException("private")),
+        io.sentry.exception.SentryCallbackError(LinkageError("private")),
+      )) {
+      val failure = java.util.concurrent.CompletionException(marker)
+      sut.uncaughtException(fixture.thread, failure)
+      verify(fixture.defaultHandler).uncaughtException(fixture.thread, failure)
+    }
+    org.mockito.kotlin.verifyNoInteractions(fixture.scopes, fixture.logger)
+  }
+
   @Test
   fun `when UncaughtExceptionHandlerIntegration is initialized, uncaught handler is unchanged`() {
     fixture.getSut(isPrintUncaughtStackTrace = false)
diff --git a/sentry/src/test/java/io/sentry/config/StrictCallbackModeOptionsTest.kt b/sentry/src/test/java/io/sentry/config/StrictCallbackModeOptionsTest.kt
new file mode 100644
index 00000000000..a4d26d620a6
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/config/StrictCallbackModeOptionsTest.kt
@@ -0,0 +1,36 @@
+package io.sentry.config
+
+import com.google.common.truth.Truth.assertThat
+import io.sentry.ExternalOptions
+import io.sentry.NoOpLogger
+import io.sentry.SentryOptions
+import java.util.Properties
+import kotlin.test.Test
+
+class StrictCallbackModeOptionsTest {
+  @Test
+  fun `strict callback mode is opt in`() {
+    val options = SentryOptions()
+    assertThat(options.isStrictCallbackMode).isFalse()
+    options.isStrictCallbackMode = true
+    assertThat(options.isStrictCallbackMode).isTrue()
+    options.isStrictCallbackMode = false
+    assertThat(options.isStrictCallbackMode).isFalse()
+  }
+
+  @Test
+  fun `external strict callback mode parses true false and absent`() {
+    for (value in listOf("true", "false", null)) {
+      val properties =
+        Properties().apply { if (value != null) setProperty("strict-callback-mode", value) }
+      val external =
+        ExternalOptions.from(SimplePropertiesProvider(properties), NoOpLogger.getInstance())
+      assertThat(external.strictCallbackMode).isEqualTo(value?.toBoolean())
+      for (initial in listOf(false, true)) {
+        val options = SentryOptions().apply { isStrictCallbackMode = initial }
+        options.merge(external)
+        assertThat(options.isStrictCallbackMode).isEqualTo(value?.toBoolean() ?: initial)
+      }
+    }
+  }
+}
diff --git a/sentry/src/test/java/io/sentry/util/CallbackUtilsTest.kt b/sentry/src/test/java/io/sentry/util/CallbackUtilsTest.kt
new file mode 100644
index 00000000000..10359c4157c
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/util/CallbackUtilsTest.kt
@@ -0,0 +1,87 @@
+package io.sentry.util
+
+import com.google.common.truth.Truth.assertThat
+import io.sentry.SentryOptions
+import io.sentry.exception.ExceptionMechanismException
+import io.sentry.exception.SentryCallbackError
+import io.sentry.exception.SentryCallbackException
+import io.sentry.protocol.Mechanism
+import kotlin.test.Test
+import kotlin.test.assertFailsWith
+
+class CallbackUtilsTest {
+  @Test
+  fun `cause traversal terminates on cycles without a marker`() {
+    val first = IllegalStateException()
+    val second = IllegalArgumentException(first)
+    first.initCause(second)
+    assertThat(CallbackUtils.isCallbackException(first)).isFalse()
+    assertThat(CallbackUtils.isCallbackException(null)).isFalse()
+  }
+
+  @Test
+  fun `traversal finds markers through mechanism wrappers and cycles`() {
+    val cause = IllegalStateException()
+    val marker = SentryCallbackException(cause)
+    cause.initCause(marker)
+    val mechanism = ExceptionMechanismException(Mechanism(), cause, Thread.currentThread())
+    assertThat(CallbackUtils.isCallbackException(mechanism)).isTrue()
+  }
+
+  @Test
+  fun `nested markers are not wrapped again`() {
+    val options = SentryOptions().apply { isStrictCallbackMode = true }
+    val marker = SentryCallbackException(IllegalStateException())
+    assertThat(
+        assertFailsWith<SentryCallbackException> {
+          CallbackUtils.rethrowIfStrictCallbackMode(options, RuntimeException(marker))
+        }
+      )
+      .isSameInstanceAs(marker)
+    val error = SentryCallbackError(LinkageError())
+    assertThat(
+        assertFailsWith<SentryCallbackError> {
+          CallbackUtils.rethrowIfStrictCallbackMode(options, RuntimeException(error))
+        }
+      )
+      .isSameInstanceAs(error)
+  }
+
+  @Test
+  fun `disabled mode still propagates existing markers`() {
+    val options = SentryOptions()
+    for (marker in
+      listOf(
+        SentryCallbackException(IllegalStateException()),
+        SentryCallbackError(LinkageError()),
+      )) {
+      val thrown =
+        kotlin.test.assertFails {
+          CallbackUtils.rethrowIfStrictCallbackMode(options, RuntimeException(marker))
+        }
+      assertThat(thrown).isSameInstanceAs(marker)
+    }
+  }
+
+  @Test
+  fun `disabled mode does not wrap errors or exceptions`() {
+    val options = SentryOptions()
+    CallbackUtils.rethrowIfStrictCallbackMode(options, IllegalStateException())
+    CallbackUtils.rethrowIfStrictCallbackMode(options, LinkageError())
+    val original = IllegalStateException()
+    assertThat(
+        assertFailsWith<IllegalStateException> { CallbackUtils.run(options) { throw original } }
+      )
+      .isSameInstanceAs(original)
+  }
+
+  @Test
+  fun `strict callback mode wraps checked callback exceptions too`() {
+    val original = java.io.IOException()
+    val thrown =
+      assertFailsWith<SentryCallbackException> {
+        CallbackUtils.run(SentryOptions().apply { isStrictCallbackMode = true }) { throw original }
+      }
+    assertThat(thrown.cause).isSameInstanceAs(original)
+  }
+}
diff --git a/sentry/src/test/java/io/sentry/util/ExceptionUtilsTest.kt b/sentry/src/test/java/io/sentry/util/ExceptionUtilsTest.kt
index 385fe92dbae..6d04c41c3b2 100644
--- a/sentry/src/test/java/io/sentry/util/ExceptionUtilsTest.kt
+++ b/sentry/src/test/java/io/sentry/util/ExceptionUtilsTest.kt
@@ -1,7 +1,12 @@
 package io.sentry.util
 
 import com.google.common.truth.Truth.assertThat
+import io.sentry.exception.ExceptionMechanismException
+import io.sentry.exception.SentryCallbackError
+import io.sentry.exception.SentryCallbackException
+import io.sentry.protocol.Mechanism
 import java.lang.RuntimeException
+import java.util.concurrent.CompletionException
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFails
@@ -24,6 +29,61 @@ class ExceptionUtilsTest {
     assertEquals(rootCause, ExceptionUtils.findRootCause(ex))
   }
 
+  @Test
+  fun `maybeRethrow propagates direct and nested markers unchanged`() {
+    for (marker in
+      listOf(
+        SentryCallbackException(IllegalStateException()),
+        SentryCallbackError(LinkageError()),
+      )) {
+      for (failure in
+        listOf(
+          marker,
+          CompletionException(RuntimeException(marker)),
+          ExceptionMechanismException(Mechanism(), marker, Thread.currentThread()),
+        )) {
+        assertThat(assertFails { ExceptionUtils.maybeRethrow(failure) }).isSameInstanceAs(marker)
+      }
+    }
+  }
+
+  @Test
+  fun `maybeRethrow terminates on cycles and still finds markers`() {
+    val first = IllegalStateException()
+    val second = IllegalArgumentException(first)
+    first.initCause(second)
+    ExceptionUtils.maybeRethrow(first)
+
+    val cause = IllegalStateException()
+    val marker = SentryCallbackException(cause)
+    cause.initCause(marker)
+    val mechanism = ExceptionMechanismException(Mechanism(), cause, Thread.currentThread())
+    assertThat(assertFails { ExceptionUtils.maybeRethrow(mechanism) }).isSameInstanceAs(marker)
+  }
+
+  @Test
+  fun `maybeRethrow leaves unmarked failures including fatal errors untouched`() {
+    for (failure in
+      listOf(
+        RuntimeException(),
+        java.io.IOException(),
+        AssertionError(),
+        OutOfMemoryError(),
+        StackOverflowError(),
+        ThreadDeath(),
+        LinkageError(),
+      )) {
+      ExceptionUtils.maybeRethrow(failure)
+      ExceptionUtils.maybeRethrow(CompletionException(failure))
+    }
+    try {
+      ExceptionUtils.maybeRethrow(InterruptedException())
+      assertThat(Thread.currentThread().isInterrupted).isFalse()
+    } finally {
+      Thread.interrupted()
+    }
+  }
+
   @Test
   fun `rethrowIfFatal rethrows OutOfMemoryError`() {
     assertFails { ExceptionUtils.rethrowIfFatal(OutOfMemoryError()) }