fix(core): Prevent recursion when a callback triggers another capture

A user beforeSend/beforeBreadcrumb/beforeSendLog callback that itself
captures — directly, or transitively through a logging integration that
routes back into Sentry (e.g. Timber, or the Gradle plugin's logcat
instrumentation) — recursed until a StackOverflowError, because the callbacks
run synchronously on the caller thread with no re-entrancy protection.

Add a shared, thread-local SentryCallbackReentrancyGuard that is set only
while a callback's execute() runs. Capture entry points (captureEvent,
captureTransaction, captureLog, Scope.addBreadcrumb) drop nested captures
while the guard is active, breaking the loop for every capture type at once.
Dropping (rather than sending) the nested capture is intentional: bypassing
beforeSend would send unscrubbed data.

The nested capture is dropped, not sent. This also makes the per-integration
guard in SentryLogcatAdapter redundant.

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

Author: runningcode

sentry-android-timber/src/test/java/io/sentry/android/timber/SentryTimberIntegrationTest.kt

@@ -1,17 +1,22 @@
 package io.sentry.android.timber
 
 import io.sentry.IScopes
+import io.sentry.ITransportFactory
+import io.sentry.ScopesAdapter
+import io.sentry.Sentry
 import io.sentry.SentryLevel
 import io.sentry.SentryLogLevel
 import io.sentry.SentryOptions
 import io.sentry.protocol.SdkVersion
+import io.sentry.transport.ITransport
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 import org.mockito.kotlin.any
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
 import timber.log.Timber
 
 class SentryTimberIntegrationTest {
@@ -112,4 +117,44 @@ class SentryTimberIntegrationTest {
 
     assertTrue(fixture.options.sdkVersion!!.integrationSet.contains("Timber"))
   }
+
+  @Test
+  fun `a beforeSend callback that logs via Timber does not recurse`() {
+    // End-to-end guard against SDK-CRASHES-JAVA-3T3H style recursion: with a real Sentry instance,
+    // a beforeSend callback that logs through the planted SentryTimberTree must not loop back into
+    // capture forever.
+    val transport = mock<ITransport>()
+    val transportFactory = mock<ITransportFactory>()
+    whenever(transportFactory.create(any(), any())).thenReturn(transport)
+
+    var beforeSendInvocations = 0
+    Sentry.init { options ->
+      options.dsn = "https://key@sentry.io/123"
+      options.setTransportFactory(transportFactory)
+      options.beforeSend =
+        SentryOptions.BeforeSendCallback { event, _ ->
+          beforeSendInvocations++
+          Timber.e("logging from beforeSend")
+          event
+        }
+    }
+    Timber.plant(
+      SentryTimberTree(
+        ScopesAdapter.getInstance(),
+        SentryLevel.ERROR,
+        SentryLevel.INFO,
+        SentryLogLevel.INFO,
+      )
+    )
+
+    try {
+      Timber.e("outer error")
+
+      // Without the core re-entrancy guard this recurses until a StackOverflowError. The nested
+      // Timber.e is dropped before its own beforeSend, so the callback runs exactly once.
+      assertEquals(1, beforeSendInvocations)
+    } finally {
+      Sentry.close()
+    }
+  }
 }

sentry/api/sentry.api

@@ -7893,6 +7893,12 @@ public final class io/sentry/util/ScopesUtil {
 	public static fun printScopesChain (Lio/sentry/IScopes;)V
 }
 
+public final class io/sentry/util/SentryCallbackReentrancyGuard {
+	public static fun enter ()V
+	public static fun exit ()V
+	public static fun isActive ()Z
+}
+
 public final class io/sentry/util/SentryRandom {
 	public fun <init> ()V
 	public static fun current ()Lio/sentry/util/Random;

sentry/src/main/java/io/sentry/Scope.java

@@ -16,6 +16,7 @@
 import io.sentry.util.ExceptionUtils;
 import io.sentry.util.Objects;
 import io.sentry.util.Pair;
+import io.sentry.util.SentryCallbackReentrancyGuard;
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -465,6 +466,7 @@ public Queue<Breadcrumb> getBreadcrumbs() {
       @NotNull Breadcrumb breadcrumb,
       final @NotNull Hint hint) {
     try {
+      SentryCallbackReentrancyGuard.enter();
       breadcrumb = callback.execute(breadcrumb, hint);
     } catch (Throwable e) {
       options
@@ -477,6 +479,8 @@ public Queue<Breadcrumb> getBreadcrumbs() {
       if (e.getMessage() != null) {
         breadcrumb.setData("sentry:message", e.getMessage());
       }
+    } finally {
+      SentryCallbackReentrancyGuard.exit();
     }
     return breadcrumb;
   }
@@ -493,6 +497,10 @@ public void addBreadcrumb(@NotNull Breadcrumb breadcrumb, @Nullable Hint hint) {
     if (breadcrumb == null || breadcrumbs instanceof DisabledQueue) {
       return;
     }
+    // Drop breadcrumbs added from within a user callback to prevent recursion.
+    if (SentryCallbackReentrancyGuard.isActive()) {
+      return;
+    }
     SentryOptions.BeforeBreadcrumbCallback callback = options.getBeforeBreadcrumb();
     if (callback != null) {
       if (hint == null) {

sentry/src/main/java/io/sentry/SentryClient.java

@@ -107,6 +107,15 @@ private boolean shouldApplyScopeData(final @NotNull CheckIn event, final @NotNul
       @NotNull SentryEvent event, final @Nullable IScope scope, @Nullable Hint hint) {
     Objects.requireNonNull(event, "SentryEvent is required.");
 
+    if (SentryCallbackReentrancyGuard.isActive()) {
+      options
+          .getLogger()
+          .log(
+              SentryLevel.DEBUG,
+              "Event captured from within a callback (beforeSend/beforeBreadcrumb/beforeSendLog) was dropped to prevent recursion.");
+      return SentryId.EMPTY_ID;
+    }
+
     if (hint == null) {
       hint = new Hint();
     }
@@ -957,6 +966,15 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
       final @Nullable ProfilingTraceData profilingTraceData) {
     Objects.requireNonNull(transaction, "Transaction is required.");
 
+    if (SentryCallbackReentrancyGuard.isActive()) {
+      options
+          .getLogger()
+          .log(
+              SentryLevel.DEBUG,
+              "Transaction captured from within a callback was dropped to prevent recursion.");
+      return SentryId.EMPTY_ID;
+    }
+
     if (hint == null) {
       hint = new Hint();
     }
@@ -1281,6 +1299,15 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
   @ApiStatus.Experimental
   @Override
   public void captureLog(@Nullable SentryLogEvent logEvent, @Nullable IScope scope) {
+    if (SentryCallbackReentrancyGuard.isActive()) {
+      options
+          .getLogger()
+          .log(
+              SentryLevel.DEBUG,
+              "Log captured from within a callback was dropped to prevent recursion.");
+      return;
+    }
+
     if (logEvent != null && scope != null) {
       logEvent = processLogEvent(logEvent, scope.getEventProcessors());
       if (logEvent == null) {
@@ -1595,6 +1622,7 @@ private void sortBreadcrumbsByDate(
     final SentryOptions.BeforeSendCallback beforeSend = options.getBeforeSend();
     if (beforeSend != null) {
       try {
+        SentryCallbackReentrancyGuard.enter();
         event = beforeSend.execute(event, hint);
       } catch (Throwable e) {
         options
@@ -1606,6 +1634,8 @@ private void sortBreadcrumbsByDate(
 
         // drop event in case of an error in beforeSend due to PII concerns
         event = null;
+      } finally {
+        SentryCallbackReentrancyGuard.exit();
       }
     }
     return event;
@@ -1617,6 +1647,7 @@ private void sortBreadcrumbsByDate(
         options.getBeforeSendTransaction();
     if (beforeSendTransaction != null) {
       try {
+        SentryCallbackReentrancyGuard.enter();
         transaction = beforeSendTransaction.execute(transaction, hint);
       } catch (Throwable e) {
         options
@@ -1628,6 +1659,8 @@ private void sortBreadcrumbsByDate(
 
         // drop transaction in case of an error in beforeSend due to PII concerns
         transaction = null;
+      } finally {
+        SentryCallbackReentrancyGuard.exit();
       }
     }
     return transaction;
@@ -1638,6 +1671,7 @@ private void sortBreadcrumbsByDate(
     final SentryOptions.BeforeSendCallback beforeSendFeedback = options.getBeforeSendFeedback();
     if (beforeSendFeedback != null) {
       try {
+        SentryCallbackReentrancyGuard.enter();
         event = beforeSendFeedback.execute(event, hint);
       } catch (Throwable e) {
         options
@@ -1646,6 +1680,8 @@ private void sortBreadcrumbsByDate(
 
         // drop feedback in case of an error in beforeSend due to PII concerns
         event = null;
+      } finally {
+        SentryCallbackReentrancyGuard.exit();
       }
     }
     return event;
@@ -1656,6 +1692,7 @@ private void sortBreadcrumbsByDate(
     final SentryOptions.BeforeSendReplayCallback beforeSendReplay = options.getBeforeSendReplay();
     if (beforeSendReplay != null) {
       try {
+        SentryCallbackReentrancyGuard.enter();
         event = beforeSendReplay.execute(event, hint);
       } catch (Throwable e) {
         options
@@ -1667,6 +1704,8 @@ private void sortBreadcrumbsByDate(
 
         // drop event in case of an error in beforeSend due to PII concerns
         event = null;
+      } finally {
+        SentryCallbackReentrancyGuard.exit();
       }
     }
     return event;
@@ -1677,6 +1716,7 @@ private void sortBreadcrumbsByDate(
         options.getLogs().getBeforeSend();
     if (beforeSendLog != null) {
       try {
+        SentryCallbackReentrancyGuard.enter();
         event = beforeSendLog.execute(event);
       } catch (Throwable e) {
         options
@@ -1688,6 +1728,8 @@ private void sortBreadcrumbsByDate(
 
         // drop event in case of an error in beforeSendLog due to PII concerns
         event = null;
+      } finally {
+        SentryCallbackReentrancyGuard.exit();
       }
     }
     return event;
@@ -1699,6 +1741,7 @@ private void sortBreadcrumbsByDate(
         options.getMetrics().getBeforeSend();
     if (beforeSendMetric != null) {
       try {
+        SentryCallbackReentrancyGuard.enter();
         event = beforeSendMetric.execute(event, hint);
       } catch (Throwable e) {
         options
@@ -1710,6 +1753,8 @@ private void sortBreadcrumbsByDate(
 
         // drop event in case of an error in beforeSendMetric due to PII concerns
         event = null;
+      } finally {
+        SentryCallbackReentrancyGuard.exit();
       }
     }
     return event;

sentry/src/main/java/io/sentry/util/SentryCallbackReentrancyGuard.java

@@ -0,0 +1,41 @@
+package io.sentry.util;
+
+import org.jetbrains.annotations.ApiStatus;
+
+/**
+ * Thread-local re-entrancy guard that marks whether a user-supplied {@code before*} callback
+ * ({@code beforeSend}, {@code beforeBreadcrumb}, {@code beforeSendLog}, ...) is currently executing
+ * on the current thread.
+ *
+ * <p>A callback that itself triggers another SDK capture on the same thread — directly, or
+ * transitively through a logging integration that routes back into Sentry (e.g. Timber or the
+ * Gradle plugin's logcat instrumentation) — would otherwise recurse indefinitely and throw {@link
+ * StackOverflowError}. Capture entry points consult {@link #isActive()} and drop the nested capture
+ * while a callback is running.
+ *
+ * <p>The flag is set ONLY around each callback's {@code execute(...)} invocation, never around the
+ * whole capture pipeline, so captures made by event processors (which run outside the callback) are
+ * not affected.
+ */
+@ApiStatus.Internal
+public final class SentryCallbackReentrancyGuard {
+
+  private static final ThreadLocal<Boolean> isRunning = new ThreadLocal<>();
+
+  private SentryCallbackReentrancyGuard() {}
+
+  /** Whether a user callback is currently executing on this thread. */
+  public static boolean isActive() {
+    return Boolean.TRUE.equals(isRunning.get());
+  }
+
+  /** Marks that a user callback is starting to execute on this thread. */
+  public static void enter() {
+    isRunning.set(Boolean.TRUE);
+  }
+
+  /** Marks that the user callback finished executing on this thread. */
+  public static void exit() {
+    isRunning.set(Boolean.FALSE);
+  }
+}

sentry/src/test/java/io/sentry/ScopeTest.kt

@@ -372,6 +372,28 @@ class ScopeTest {
     assertFalse(called)
   }
 
+  @Test
+  fun `when beforeBreadcrumb adds another breadcrumb, the nested breadcrumb is dropped and does not recurse`() {
+    var invocations = 0
+    lateinit var scope: Scope
+    val options =
+      SentryOptions().apply {
+        beforeBreadcrumb =
+          SentryOptions.BeforeBreadcrumbCallback { breadcrumb, _ ->
+            invocations++
+            scope.addBreadcrumb(Breadcrumb())
+            breadcrumb
+          }
+      }
+
+    scope = Scope(options)
+    scope.addBreadcrumb(Breadcrumb())
+
+    // Callback runs only for the outer breadcrumb; the nested one is dropped before its callback.
+    assertEquals(1, invocations)
+    assertEquals(1, scope.breadcrumbs.count())
+  }
+
   @Test
   fun `when adding breadcrumb and maxBreadcrumb is not 0, beforeBreadcrumb is executed`() {
     var called = false