diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AppState.java b/sentry-android-core/src/main/java/io/sentry/android/core/AppState.java index 24562e3aa49..cc06670d5d9 100644 --- a/sentry-android-core/src/main/java/io/sentry/android/core/AppState.java +++ b/sentry-android-core/src/main/java/io/sentry/android/core/AppState.java @@ -11,6 +11,7 @@ import io.sentry.SentryOptions; import io.sentry.android.core.internal.util.AndroidThreadChecker; import io.sentry.util.AutoClosableReentrantLock; +import io.sentry.util.ExceptionUtils; import java.io.Closeable; import java.io.IOException; import java.util.List; @@ -112,7 +113,8 @@ private void ensureLifecycleObserver(final @NotNull ILogger logger) { SentryLevel.WARNING, "androidx.lifecycle is not available, some features might not be properly working," + "e.g. Session Tracking, Network and System Events breadcrumbs, etc."); - } catch (Throwable e) { + } catch (LinkageError e) { + // androidx.lifecycle has an incompatible version logger.log(SentryLevel.ERROR, "AppState could not register lifecycle observer", e); } } @@ -124,7 +126,7 @@ private void addObserverInternal(final @NotNull ILogger logger) { if (observerRef != null) { ProcessLifecycleOwner.get().getLifecycle().addObserver(observerRef); } - } catch (Throwable e) { + } catch (LinkageError e) { // This is to handle a potential 'AbstractMethodError' gracefully. The error is triggered in // connection with conflicting dependencies of the androidx.lifecycle. // //See the issue here: https://github.com/getsentry/sentry-java/pull/2228 @@ -133,6 +135,13 @@ private void addObserverInternal(final @NotNull ILogger logger) { SentryLevel.ERROR, "AppState failed to get Lifecycle and could not install lifecycle observer.", e); + } catch (Throwable t) { + // addObserver dispatches ON_START synchronously to the app state listeners that are already + // registered, such as session tracking and the scope observers of hybrid SDKs, so we can't + // know what it throws. Posted from a background init, nothing else would catch it on the + // main looper. The listeners miss this ON_START. + ExceptionUtils.rethrowIfFatal(t); + logger.log(SentryLevel.ERROR, "AppState failed to notify the app state listeners.", t); } } diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/NdkIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/NdkIntegration.java index f8c96b71459..acabb77d493 100644 --- a/sentry-android-core/src/main/java/io/sentry/android/core/NdkIntegration.java +++ b/sentry-android-core/src/main/java/io/sentry/android/core/NdkIntegration.java @@ -88,7 +88,9 @@ public final void register(final @NotNull IScopes scopes, final @NotNull SentryO this.options .getLogger() .log(SentryLevel.ERROR, "Failed to invoke the SentryNdk.init method.", e); - } catch (Throwable e) { + } catch (ReflectiveOperationException e) { + // InvocationTargetException wraps whatever SentryNdk.init threw, such as an + // UnsatisfiedLinkError when the native library failed to load disableNdkIntegration(this.options); this.options.getLogger().log(SentryLevel.ERROR, "Failed to initialize SentryNdk.", e); } @@ -120,7 +122,7 @@ public void close() throws IOException { options .getLogger() .log(SentryLevel.ERROR, "Failed to invoke the SentryNdk.close method.", e); - } catch (Throwable e) { + } catch (ReflectiveOperationException e) { options.getLogger().log(SentryLevel.ERROR, "Failed to close SentryNdk.", e); } finally { disableNdkIntegration(this.options); 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 bffbf75b980..c629d53494b 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 @@ -20,6 +20,7 @@ import io.sentry.android.fragment.FragmentLifecycleIntegration; import io.sentry.android.timber.SentryTimberIntegration; import io.sentry.util.AutoClosableReentrantLock; +import io.sentry.util.ExceptionUtils; import io.sentry.util.LoadClass; import java.lang.reflect.InvocationTargetException; import java.util.ArrayList; @@ -79,6 +80,11 @@ public static void init(@NotNull final Context context, @NotNull ILogger logger) /** * Sentry initialization with a configuration handler that may override the default options * + *
If the configuration handler throws, init continues with the options it set before it + * failed. Fatal errors such as {@link OutOfMemoryError} are rethrown instead. The failure is only + * logged at ERROR level through the SDK logger, which prints only when debug is enabled, e.g. + * through the {@code io.sentry.debug} manifest entry. + * * @param context Application. context * @param configuration Sentry.OptionsConfiguration configuration handler */ @@ -91,6 +97,11 @@ public static void init( /** * Sentry initialization with a configuration handler and custom logger * + *
If the configuration handler throws, init continues with the options it set before it
+ * failed. Fatal errors such as {@link OutOfMemoryError} are rethrown instead. The failure is only
+ * logged at ERROR level through the SDK logger, which prints only when debug is enabled, e.g.
+ * through the {@code io.sentry.debug} manifest entry.
+ *
* @param context Application. context
* @param logger your custom logger that implements ILogger
* @param configuration Sentry.OptionsConfiguration configuration handler
@@ -150,8 +161,20 @@ public static void init(
try {
configuration.configure(options);
+ } catch (LinkageError e) {
+ // The callback can touch options of optional modules that are missing or have an
+ // incompatible version, e.g. session replay's masking options. Init continues with
+ // the options set before it failed.
+ options
+ .getLogger()
+ .log(
+ SentryLevel.ERROR,
+ "Error in the 'OptionsConfiguration.configure' callback.",
+ e);
} catch (Throwable t) {
- // let it slip, but log it
+ // The callback is the app's or a hybrid SDK's own code, so we can't know what it
+ // throws. Init continues with the options set before it failed.
+ ExceptionUtils.rethrowIfFatal(t);
options
.getLogger()
.log(
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 4004310a3ff..99fe0d98cd4 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
@@ -189,7 +189,14 @@ public static ViewHierarchy snapshotViewHierarchy(
try {
viewHierarchy.set(snapshotViewHierarchy(decorView, exporters));
latch.countDown();
+ } catch (LinkageError e) {
+ // The Compose exporter calls Compose internals, which may not match the app's
+ // Compose version
+ logger.log(SentryLevel.ERROR, "Failed to process view hierarchy.", e);
} catch (Throwable t) {
+ // The snapshot calls into the app's own views, so we can't know what it throws.
+ // The event is sent without a view hierarchy.
+ ExceptionUtils.rethrowIfFatal(t);
logger.log(SentryLevel.ERROR, "Failed to process view hierarchy.", t);
}
});
@@ -197,7 +204,14 @@ public static ViewHierarchy snapshotViewHierarchy(
return viewHierarchy.get();
}
}
+ } catch (LinkageError e) {
+ // The Compose exporter calls Compose internals, which may not match the app's Compose
+ // version
+ logger.log(SentryLevel.ERROR, "Failed to process view hierarchy.", e);
} catch (Throwable t) {
+ // The snapshot calls into the app's own views, so we can't know what it throws. The event
+ // is sent without a view hierarchy.
+ ExceptionUtils.rethrowIfFatal(t);
logger.log(SentryLevel.ERROR, "Failed to process view hierarchy.", t);
}
return null;
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java
index 612eb97946e..7a3e6b42302 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
@@ -6,6 +6,7 @@
import io.sentry.SentryLevel;
import io.sentry.SentryOptions;
import io.sentry.SpanStatus;
+import io.sentry.util.ExceptionUtils;
import org.jetbrains.annotations.ApiStatus;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -56,7 +57,16 @@ public boolean dispatchTouchEvent(final @Nullable MotionEvent motionEvent) {
final MotionEvent copy = motionEventObtainer.obtain(motionEvent);
try {
handleTouchEvent(copy);
+ } catch (LinkageError e) {
+ // The Compose gesture locator calls Compose internals, which may not match the app's
+ // Compose version
+ if (options != null) {
+ options.getLogger().log(SentryLevel.ERROR, "Error dispatching touch event", e);
+ }
} catch (Throwable e) {
+ // Locating the touched view calls into the app's own views, so we can't know what it
+ // throws. The gesture is not recorded, and the touch still reaches the app.
+ ExceptionUtils.rethrowIfFatal(e);
if (options != null) {
options.getLogger().log(SentryLevel.ERROR, "Error dispatching touch event", e);
}
diff --git a/sentry-android-ndk/src/main/java/io/sentry/android/ndk/DebugImagesLoader.java b/sentry-android-ndk/src/main/java/io/sentry/android/ndk/DebugImagesLoader.java
index 602981c1d01..af817abe722 100644
--- a/sentry-android-ndk/src/main/java/io/sentry/android/ndk/DebugImagesLoader.java
+++ b/sentry-android-ndk/src/main/java/io/sentry/android/ndk/DebugImagesLoader.java
@@ -8,6 +8,7 @@
import io.sentry.ndk.NativeModuleListLoader;
import io.sentry.protocol.DebugImage;
import io.sentry.util.AutoClosableReentrantLock;
+import io.sentry.util.ExceptionUtils;
import io.sentry.util.Objects;
import java.util.ArrayList;
import java.util.HashSet;
@@ -71,7 +72,13 @@ public DebugImagesLoader(
.getLogger()
.log(SentryLevel.DEBUG, "Debug images loaded: %d", debugImages.size());
}
+ } catch (LinkageError e) {
+ // e.g. UnsatisfiedLinkError when the native library failed to load
+ options.getLogger().log(SentryLevel.ERROR, e, "Failed to load debug images.");
} catch (Throwable e) {
+ // A JNI call into sentry-native, so we can't know what it throws. The event is sent
+ // without debug images.
+ ExceptionUtils.rethrowIfFatal(e);
options.getLogger().log(SentryLevel.ERROR, e, "Failed to load debug images.");
}
}
@@ -172,7 +179,13 @@ public void clearDebugImages() {
moduleListLoader.clearModuleList();
options.getLogger().log(SentryLevel.INFO, "Debug images cleared.");
+ } catch (LinkageError e) {
+ // e.g. UnsatisfiedLinkError when the native library failed to load
+ options.getLogger().log(SentryLevel.ERROR, e, "Failed to clear debug images.");
} catch (Throwable e) {
+ // A JNI call into sentry-native, so we can't know what it throws. The cached list is
+ // cleared either way.
+ ExceptionUtils.rethrowIfFatal(e);
options.getLogger().log(SentryLevel.ERROR, e, "Failed to clear debug images.");
}
debugImages = null;
diff --git a/sentry-android-ndk/src/main/java/io/sentry/android/ndk/SentryNdk.java b/sentry-android-ndk/src/main/java/io/sentry/android/ndk/SentryNdk.java
index e2339ca911d..e88f1435ab1 100644
--- a/sentry-android-ndk/src/main/java/io/sentry/android/ndk/SentryNdk.java
+++ b/sentry-android-ndk/src/main/java/io/sentry/android/ndk/SentryNdk.java
@@ -25,9 +25,9 @@ private SentryNdk() {}
try {
//noinspection UnstableApiUsage
io.sentry.ndk.SentryNdk.loadNativeLibraries();
- } catch (Throwable t) {
- // ignored
- // if loadLibrary() fails, the later init() will throw an exception anyway
+ } catch (LinkageError ignored) {
+ // e.g. UnsatisfiedLinkError. The later init() throws too, which disables the NDK
+ // integration.
} finally {
loadLibraryLatch.countDown();
}
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 6bdca6f748f..772775b32d2 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
@@ -51,6 +51,7 @@ import io.sentry.protocol.SentryId
import io.sentry.transport.ICurrentDateProvider
import io.sentry.transport.RateLimiter
import io.sentry.transport.RateLimiter.IRateLimitObserver
+import io.sentry.util.ExceptionUtils
import io.sentry.util.FileUtils
import io.sentry.util.HintUtils
import io.sentry.util.IntegrationUtils.addIntegrationToSdkVersion
@@ -486,7 +487,14 @@ public class ReplayIntegration(
val hint = Hint()
hint.set(TypeCheckHint.REPLAY_FRAME_BITMAP, copy)
observer.onMaskedFrameCaptured(hint, frameTimeStamp, screen)
+ } catch (e: LinkageError) {
+ // the observer needs a class that is missing or has an incompatible version
+ options.logger.log(ERROR, "Error in ReplayFrameObserver", e)
+ copy.recycle()
} catch (e: Throwable) {
+ // The observer is the app's own code, so we can't know what it throws. The copy is
+ // recycled and the frame is still recorded.
+ ExceptionUtils.rethrowIfFatal(e)
options.logger.log(ERROR, "Error in ReplayFrameObserver", e)
copy.recycle()
}
@@ -509,7 +517,14 @@ public class ReplayIntegration(
val hint = Hint()
hint.set(TypeCheckHint.REPLAY_FRAME_BITMAP, bitmap)
observer.onMaskedFrameCaptured(hint, frameTimestamp, screen)
+ } catch (e: LinkageError) {
+ // the observer needs a class that is missing or has an incompatible version
+ options.logger.log(ERROR, "Error in ReplayFrameObserver", e)
+ bitmap.recycle()
} catch (e: Throwable) {
+ // The observer is the app's own code, so we can't know what it throws. The bitmap is
+ // recycled and the frame is still recorded.
+ ExceptionUtils.rethrowIfFatal(e)
options.logger.log(ERROR, "Error in ReplayFrameObserver", e)
bitmap.recycle()
}
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/Windows.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/Windows.kt
index 4f8f6cabf58..d38653324f4 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/Windows.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/Windows.kt
@@ -23,6 +23,7 @@ import android.util.Log
import android.view.View
import android.view.Window
import io.sentry.util.AutoClosableReentrantLock
+import io.sentry.util.ExceptionUtils
import java.io.Closeable
import java.util.concurrent.CopyOnWriteArrayList
import java.util.concurrent.atomic.AtomicBoolean
@@ -53,7 +54,7 @@ internal object WindowSpy {
lazy(NONE) {
try {
Class.forName("com.android.internal.policy.DecorView")
- } catch (ignored: Throwable) {
+ } catch (ignored: ClassNotFoundException) {
Log.d("WindowSpy", "Unexpected exception loading DecorView on API $SDK_INT", ignored)
null
}
@@ -171,7 +172,7 @@ internal object WindowManagerSpy {
val className = "android.view.WindowManagerGlobal"
try {
Class.forName(className)
- } catch (ignored: Throwable) {
+ } catch (ignored: ClassNotFoundException) {
Log.w("WindowManagerSpy", ignored)
null
}
@@ -195,11 +196,30 @@ internal object WindowManagerSpy {
mViewsField?.let { mViewsField ->
@Suppress("UNCHECKED_CAST")
val mViews = mViewsField[windowManagerInstance] as ArrayList If the encoder throws, the logging event's formatted message is sent instead. Fatal errors
+ * such as {@link OutOfMemoryError} are rethrown. The failure is reported as a warning to
+ * logback's status manager, which you can see with {@code Placeholders and SpEL expressions in the slug are resolved. If resolving fails, the
+ * unresolved slug is used, so check-ins go to a monitor that likely does not exist. The failure
+ * is only logged as a warning through {@link io.sentry.SentryOptions#getLogger()}, which by
+ * default prints only when debug is enabled.
+ *
* @return monitor slug
*/
@AliasFor("monitorSlug")
diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/checkin/SentryCheckInAdvice.java b/sentry-spring-7/src/main/java/io/sentry/spring7/checkin/SentryCheckInAdvice.java
index 2f83a079d0d..a715a3d9922 100644
--- a/sentry-spring-7/src/main/java/io/sentry/spring7/checkin/SentryCheckInAdvice.java
+++ b/sentry-spring-7/src/main/java/io/sentry/spring7/checkin/SentryCheckInAdvice.java
@@ -11,6 +11,7 @@
import io.sentry.SentryLevel;
import io.sentry.protocol.SentryId;
import io.sentry.time.Stopwatch;
+import io.sentry.util.ExceptionUtils;
import io.sentry.util.MonitorConfigUtils;
import io.sentry.util.Objects;
import io.sentry.util.TracingUtils;
@@ -128,6 +129,12 @@ public SentryCheckInAdvice(final @NotNull IScopes scopes, final boolean monitorS
try {
monitorSlug = resolver.resolveStringValue(checkInAnnotation.value());
} catch (Throwable e) {
+ // The resolver evaluates the app's placeholders and SpEL expressions, so we can't know what
+ // it throws. A LinkageError, e.g. from a Spring version that doesn't match, is handled the
+ // same way.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
// When resolving fails, we fall back to the original string which may contain unresolved
// expressions. Testing shows this can also happen if properties cannot be resolved (without
// an exception being thrown). Sentry should alert the user about missed checkins in this
diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/SentryRequestResolver.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/SentryRequestResolver.java
index 9fcb30665cb..23eb58efed1 100644
--- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/SentryRequestResolver.java
+++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/SentryRequestResolver.java
@@ -7,6 +7,7 @@
import io.sentry.protocol.Request;
import io.sentry.util.AutoClosableReentrantLock;
import io.sentry.util.CookieUtils;
+import io.sentry.util.ExceptionUtils;
import io.sentry.util.HttpUtils;
import io.sentry.util.Objects;
import io.sentry.util.UrlUtils;
@@ -116,6 +117,12 @@ private List Placeholders and SpEL expressions in the slug are resolved. If resolving fails, the
+ * unresolved slug is used, so check-ins go to a monitor that likely does not exist. The failure
+ * is only logged as a warning through {@link io.sentry.SentryOptions#getLogger()}, which by
+ * default prints only when debug is enabled.
+ *
* @return monitor slug
*/
@AliasFor("monitorSlug")
diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/checkin/SentryCheckInAdvice.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/checkin/SentryCheckInAdvice.java
index a544c401966..905b311c691 100644
--- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/checkin/SentryCheckInAdvice.java
+++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/checkin/SentryCheckInAdvice.java
@@ -11,6 +11,7 @@
import io.sentry.SentryLevel;
import io.sentry.protocol.SentryId;
import io.sentry.time.Stopwatch;
+import io.sentry.util.ExceptionUtils;
import io.sentry.util.MonitorConfigUtils;
import io.sentry.util.Objects;
import io.sentry.util.TracingUtils;
@@ -125,6 +126,12 @@ public Object invoke(final @NotNull MethodInvocation invocation) throws Throwabl
try {
monitorSlug = resolver.resolveStringValue(checkInAnnotation.value());
} catch (Throwable e) {
+ // The resolver evaluates the app's placeholders and SpEL expressions, so we can't know what
+ // it throws. A LinkageError, e.g. from a Spring version that doesn't match, is handled the
+ // same way.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
// When resolving fails, we fall back to the original string which may contain unresolved
// expressions. Testing shows this can also happen if properties cannot be resolved (without
// an exception being thrown). Sentry should alert the user about missed checkins in this
diff --git a/sentry-spring/src/main/java/io/sentry/spring/SentryRequestResolver.java b/sentry-spring/src/main/java/io/sentry/spring/SentryRequestResolver.java
index 1c8ec52ac88..144931e3bb4 100644
--- a/sentry-spring/src/main/java/io/sentry/spring/SentryRequestResolver.java
+++ b/sentry-spring/src/main/java/io/sentry/spring/SentryRequestResolver.java
@@ -7,6 +7,7 @@
import io.sentry.protocol.Request;
import io.sentry.util.AutoClosableReentrantLock;
import io.sentry.util.CookieUtils;
+import io.sentry.util.ExceptionUtils;
import io.sentry.util.HttpUtils;
import io.sentry.util.Objects;
import io.sentry.util.UrlUtils;
@@ -116,6 +117,12 @@ private List Placeholders and SpEL expressions in the slug are resolved. If resolving fails, the
+ * unresolved slug is used, so check-ins go to a monitor that likely does not exist. The failure
+ * is only logged as a warning through {@link io.sentry.SentryOptions#getLogger()}, which by
+ * default prints only when debug is enabled.
+ *
* @return monitor slug
*/
@AliasFor("monitorSlug")
diff --git a/sentry-spring/src/main/java/io/sentry/spring/checkin/SentryCheckInAdvice.java b/sentry-spring/src/main/java/io/sentry/spring/checkin/SentryCheckInAdvice.java
index f6923c77e6e..e971dd0b7d2 100644
--- a/sentry-spring/src/main/java/io/sentry/spring/checkin/SentryCheckInAdvice.java
+++ b/sentry-spring/src/main/java/io/sentry/spring/checkin/SentryCheckInAdvice.java
@@ -11,6 +11,7 @@
import io.sentry.SentryLevel;
import io.sentry.protocol.SentryId;
import io.sentry.time.Stopwatch;
+import io.sentry.util.ExceptionUtils;
import io.sentry.util.MonitorConfigUtils;
import io.sentry.util.Objects;
import io.sentry.util.TracingUtils;
@@ -125,6 +126,12 @@ public Object invoke(final @NotNull MethodInvocation invocation) throws Throwabl
try {
monitorSlug = resolver.resolveStringValue(checkInAnnotation.value());
} catch (Throwable e) {
+ // The resolver evaluates the app's placeholders and SpEL expressions, so we can't know what
+ // it throws. A LinkageError, e.g. from a Spring version that doesn't match, is handled the
+ // same way.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
// When resolving fails, we fall back to the original string which may contain unresolved
// expressions.
// Testing shows this can also happen if properties cannot be resolved (without an exception
diff --git a/sentry/src/main/java/io/sentry/EventProcessor.java b/sentry/src/main/java/io/sentry/EventProcessor.java
index 928fd022095..05f600d4bd9 100644
--- a/sentry/src/main/java/io/sentry/EventProcessor.java
+++ b/sentry/src/main/java/io/sentry/EventProcessor.java
@@ -6,6 +6,11 @@
/**
* An Event Processor that may mutate or drop an event. Runs for SentryEvent or SentryTransaction
+ *
+ * If a processor throws, the event is dropped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only when
+ * {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link OutOfMemoryError}, are
+ * rethrown.
*/
public interface EventProcessor {
diff --git a/sentry/src/main/java/io/sentry/IScopes.java b/sentry/src/main/java/io/sentry/IScopes.java
index 6b5a2b8a5b7..c1ffa4f7d69 100644
--- a/sentry/src/main/java/io/sentry/IScopes.java
+++ b/sentry/src/main/java/io/sentry/IScopes.java
@@ -351,6 +351,12 @@ default void addBreadcrumb(@NotNull String message, @NotNull String category) {
* changes may be dropped when executed in parallel. Use {@link
* IScopes#configureScope(ScopeCallback)} instead.
*
+ * If the callback throws, the rest of it is skipped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only when
+ * {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link OutOfMemoryError}, are
+ * rethrown. Before {@link Sentry#init}, the callback runs on a no-op scope and nothing it throws
+ * is caught.
+ *
* @param callback the callback
*/
void withScope(@NotNull ScopeCallback callback);
@@ -364,6 +370,12 @@ default void addBreadcrumb(@NotNull String message, @NotNull String category) {
* changes may be dropped when executed in parallel. Use {@link IScopes#configureScope(ScopeType,
* ScopeCallback)} instead.
*
+ * If the callback throws, the rest of it is skipped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only when
+ * {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link OutOfMemoryError}, are
+ * rethrown. Before {@link Sentry#init}, the callback runs on a no-op scope and nothing it throws
+ * is caught.
+ *
* @param callback the callback
*/
void withIsolationScope(@NotNull ScopeCallback callback);
@@ -371,6 +383,11 @@ default void addBreadcrumb(@NotNull String message, @NotNull String category) {
/**
* Configures the scope through the callback.
*
+ * If the callback throws, the rest of it is skipped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only when
+ * {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link OutOfMemoryError}, are
+ * rethrown. Before {@link Sentry#init}, the callback isn't run.
+ *
* @param callback The configure scope callback.
*/
default void configureScope(@NotNull ScopeCallback callback) {
@@ -380,6 +397,11 @@ default void configureScope(@NotNull ScopeCallback callback) {
/**
* Configures the scope through the callback.
*
+ * If the callback throws, the rest of it is skipped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only when
+ * {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link OutOfMemoryError}, are
+ * rethrown. Before {@link Sentry#init}, the callback isn't run.
+ *
* @param callback The configure scope callback.
*/
void configureScope(@Nullable ScopeType scopeType, @NotNull ScopeCallback callback);
diff --git a/sentry/src/main/java/io/sentry/Integration.java b/sentry/src/main/java/io/sentry/Integration.java
index 1b1a520473e..6ee16b2d356 100644
--- a/sentry/src/main/java/io/sentry/Integration.java
+++ b/sentry/src/main/java/io/sentry/Integration.java
@@ -10,6 +10,13 @@ public interface Integration {
/**
* Registers an integration
*
+ * If this method throws, {@link Sentry#init} skips the integration and continues with the next
+ * one, so the SDK starts without what this integration would have set up. Fatal errors such as
+ * {@link OutOfMemoryError} are rethrown instead. The skipped integration is only reported as a
+ * warning through {@link SentryOptions#getLogger()}, which by default prints only when {@link
+ * SentryOptions#isDebug()} is enabled. To find out whether your integration registered, enable
+ * debug and look for "Failed to register the integration" in the log.
+ *
* @param scopes the Scopes
* @param options the options
*/
diff --git a/sentry/src/main/java/io/sentry/Scope.java b/sentry/src/main/java/io/sentry/Scope.java
index b05e4d9d05c..c58c6cd773e 100644
--- a/sentry/src/main/java/io/sentry/Scope.java
+++ b/sentry/src/main/java/io/sentry/Scope.java
@@ -496,6 +496,11 @@ public Queue If this callback throws, the rest of it is skipped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only when
+ * {@link SentryOptions#isDebug()} is enabled. When the callback was passed to a capture method,
+ * the event is captured with the scope as it was before the callback ran. Fatal errors, such as
+ * {@link OutOfMemoryError}, are rethrown.
+ *
+ * @param scope the scope
+ */
void run(@NotNull IScope scope);
}
diff --git a/sentry/src/main/java/io/sentry/Scopes.java b/sentry/src/main/java/io/sentry/Scopes.java
index 75c263c4127..ea0f8fdeae6 100644
--- a/sentry/src/main/java/io/sentry/Scopes.java
+++ b/sentry/src/main/java/io/sentry/Scopes.java
@@ -9,6 +9,7 @@
import io.sentry.metrics.MetricsApi;
import io.sentry.protocol.*;
import io.sentry.transport.RateLimiter;
+import io.sentry.util.ExceptionUtils;
import io.sentry.util.HintUtils;
import io.sentry.util.Objects;
import io.sentry.util.SpanUtils;
@@ -192,6 +193,11 @@ private void assignTraceContext(final @NotNull SentryEvent event) {
callback.run(localScope);
return localScope;
} catch (Throwable t) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated
+ // like any other exception. The event is captured with the unchanged scope.
+ if (!(t instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(t);
+ }
getOptions()
.getLogger()
.log(SentryLevel.ERROR, "Error in the 'ScopeCallback' callback.", t);
@@ -405,7 +411,6 @@ public void close() {
}
@Override
- @SuppressWarnings("FutureReturnValueIgnored")
public void close(final boolean isRestarting) {
if (!isEnabled()) {
getOptions()
@@ -417,7 +422,16 @@ public void close(final boolean isRestarting) {
if (integration instanceof Closeable) {
try {
((Closeable) integration).close();
+ } catch (LinkageError e) {
+ // The integration needs an optional dependency that is missing or has an
+ // incompatible version. The remaining integrations are still closed.
+ getOptions()
+ .getLogger()
+ .log(SentryLevel.WARNING, "Failed to close the integration {}.", integration, e);
} catch (Throwable e) {
+ // Integrations can be user-provided, so we can't know what they throw. The
+ // remaining integrations are still closed.
+ ExceptionUtils.rethrowIfFatal(e);
getOptions()
.getLogger()
.log(SentryLevel.WARNING, "Failed to close the integration {}.", integration, e);
@@ -428,7 +442,20 @@ public void close(final boolean isRestarting) {
if (eventProcessor instanceof Closeable) {
try {
((Closeable) eventProcessor).close();
+ } catch (LinkageError e) {
+ // The event processor needs an optional dependency that is missing or has an
+ // incompatible version. The remaining event processors are still closed.
+ getOptions()
+ .getLogger()
+ .log(
+ SentryLevel.WARNING,
+ "Failed to close the event processor {}.",
+ eventProcessor,
+ e);
} catch (Throwable e) {
+ // Event processors can be user-provided, so we can't know what they throw. The
+ // remaining event processors are still closed.
+ ExceptionUtils.rethrowIfFatal(e);
getOptions()
.getLogger()
.log(
@@ -442,45 +469,80 @@ public void close(final boolean isRestarting) {
configureScope(scope -> scope.clear());
configureScope(ScopeType.ISOLATION, scope -> scope.clear());
- getOptions().getBackpressureMonitor().close();
- getOptions().getTransactionProfiler().close();
- getOptions().getContinuousProfiler().close(true);
- getOptions().getCompositePerformanceCollector().close();
- getOptions().getConnectionStatusProvider().close();
+ closeComponent("backpressure monitor", () -> getOptions().getBackpressureMonitor().close());
+ closeComponent("transaction profiler", () -> getOptions().getTransactionProfiler().close());
+ closeComponent(
+ "continuous profiler", () -> getOptions().getContinuousProfiler().close(true));
+ closeComponent(
+ "performance collector", () -> getOptions().getCompositePerformanceCollector().close());
+ closeComponent(
+ "connection status provider", () -> getOptions().getConnectionStatusProvider().close());
// On restart we intentionally leave the timer executor running so that pending idle/
// deadline timeouts of transactions started before the restart still fire and finish
// those transactions. It self-terminates once idle (allowCoreThreadTimeOut).
if (!isRestarting) {
- getOptions().getTimerExecutorService().close(getOptions().getShutdownTimeoutMillis());
- }
- final @NotNull ISentryExecutorService executorService = getOptions().getExecutorService();
- if (isRestarting) {
- try {
- executorService.submit(
- () -> executorService.close(getOptions().getShutdownTimeoutMillis()));
- } catch (RejectedExecutionException e) {
- getOptions()
- .getLogger()
- .log(
- SentryLevel.WARNING,
- "Failed to submit executor service shutdown task during restart. Shutting down synchronously.",
- e);
- executorService.close(getOptions().getShutdownTimeoutMillis());
- }
- } else {
- executorService.close(getOptions().getShutdownTimeoutMillis());
+ closeComponent(
+ "timer executor service",
+ () ->
+ getOptions()
+ .getTimerExecutorService()
+ .close(getOptions().getShutdownTimeoutMillis()));
}
+ closeComponent("executor service", () -> closeExecutorService(isRestarting));
// TODO: should we end session before closing client?
configureScope(ScopeType.CURRENT, scope -> scope.getClient().close(isRestarting));
configureScope(ScopeType.ISOLATION, scope -> scope.getClient().close(isRestarting));
configureScope(ScopeType.GLOBAL, scope -> scope.getClient().close(isRestarting));
} catch (Throwable e) {
+ // A public API entry point: closing shuts down components that integrations and the app
+ // can replace, so we can't know what it throws. The remaining shutdown steps are skipped.
+ ExceptionUtils.rethrowIfFatal(e);
getOptions().getLogger().log(SentryLevel.ERROR, "Error while closing the Scopes.", e);
}
}
}
+ private interface ShutdownStep {
+ void run() throws Exception;
+ }
+
+ /**
+ * Integrations and the app can replace these components, so one may need an optional dependency
+ * that is missing or has an incompatible version. Its LinkageError is logged and the remaining
+ * shutdown steps still run, which matters on re-init, where {@link Sentry#init} calls {@link
+ * #close(boolean)}.
+ */
+ private void closeComponent(final @NotNull String component, final @NotNull ShutdownStep step)
+ throws Exception {
+ try {
+ step.run();
+ } catch (LinkageError e) {
+ getOptions().getLogger().log(SentryLevel.ERROR, e, "Failed to close the %s.", component);
+ }
+ }
+
+ @SuppressWarnings("FutureReturnValueIgnored")
+ private void closeExecutorService(final boolean isRestarting) {
+ final @NotNull ISentryExecutorService executorService = getOptions().getExecutorService();
+ if (isRestarting) {
+ try {
+ executorService.submit(
+ () -> executorService.close(getOptions().getShutdownTimeoutMillis()));
+ } catch (RejectedExecutionException e) {
+ getOptions()
+ .getLogger()
+ .log(
+ SentryLevel.WARNING,
+ "Failed to submit executor service shutdown task during restart. Shutting down synchronously.",
+ e);
+ executorService.close(getOptions().getShutdownTimeoutMillis());
+ }
+ } else {
+ executorService.close(getOptions().getShutdownTimeoutMillis());
+ }
+ }
+
@Override
public void addBreadcrumb(final @NotNull Breadcrumb breadcrumb, final @Nullable Hint hint) {
if (!isEnabled()) {
@@ -670,6 +732,11 @@ public void withScope(final @NotNull ScopeCallback callback) {
try {
callback.run(NoOpScope.getInstance());
} catch (Throwable e) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated
+ // like any other exception. The rest of the callback is skipped.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
getOptions().getLogger().log(SentryLevel.ERROR, "Error in the 'withScope' callback.", e);
}
@@ -678,6 +745,11 @@ public void withScope(final @NotNull ScopeCallback callback) {
try (final @NotNull ISentryLifecycleToken ignored = forkedScopes.makeCurrent()) {
callback.run(forkedScopes.getScope());
} catch (Throwable e) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated
+ // like any other exception. The rest of the callback is skipped.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
getOptions().getLogger().log(SentryLevel.ERROR, "Error in the 'withScope' callback.", e);
}
}
@@ -689,6 +761,11 @@ public void withIsolationScope(final @NotNull ScopeCallback callback) {
try {
callback.run(NoOpScope.getInstance());
} catch (Throwable e) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated
+ // like any other exception. The rest of the callback is skipped.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
getOptions()
.getLogger()
.log(SentryLevel.ERROR, "Error in the 'withIsolationScope' callback.", e);
@@ -699,6 +776,11 @@ public void withIsolationScope(final @NotNull ScopeCallback callback) {
try (final @NotNull ISentryLifecycleToken ignored = forkedScopes.makeCurrent()) {
callback.run(forkedScopes.getIsolationScope());
} catch (Throwable e) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated
+ // like any other exception. The rest of the callback is skipped.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
getOptions()
.getLogger()
.log(SentryLevel.ERROR, "Error in the 'withIsolationScope' callback.", e);
@@ -719,6 +801,11 @@ public void configureScope(
try {
callback.run(combinedScope.getSpecificScope(scopeType));
} catch (Throwable e) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated
+ // like any other exception. The rest of the callback is skipped.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
getOptions()
.getLogger()
.log(SentryLevel.ERROR, "Error in the 'configureScope' callback.", e);
diff --git a/sentry/src/main/java/io/sentry/Sentry.java b/sentry/src/main/java/io/sentry/Sentry.java
index ce286600477..213a57e0de8 100644
--- a/sentry/src/main/java/io/sentry/Sentry.java
+++ b/sentry/src/main/java/io/sentry/Sentry.java
@@ -21,6 +21,7 @@
import io.sentry.transport.NoOpEnvelopeCache;
import io.sentry.util.AutoClosableReentrantLock;
import io.sentry.util.DebugMetaPropertiesApplier;
+import io.sentry.util.ExceptionUtils;
import io.sentry.util.FileUtils;
import io.sentry.util.InitUtil;
import io.sentry.util.LoadClass;
@@ -252,7 +253,18 @@ private static Unlike {@link Sentry#pushScope()} this also forks in global hub mode, since the previous
* scopes are always restored once the callback returns.
*
+ * If the callback throws, the rest of it is skipped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only when
+ * {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link OutOfMemoryError}, are
+ * rethrown. Before {@link #init} and after {@link #close}, the callback runs on a no-op scope and
+ * nothing it throws is caught.
+ *
* @param callback the callback
*/
public static void withScope(final @NotNull ScopeCallback callback) {
@@ -1045,6 +1077,12 @@ public static void withScope(final @NotNull ScopeCallback callback) {
* Unlike {@link Sentry#pushIsolationScope()} this also forks in global hub mode, since the
* previous scopes are always restored once the callback returns.
*
+ * If the callback throws, the rest of it is skipped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only when
+ * {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link OutOfMemoryError}, are
+ * rethrown. Before {@link #init} and after {@link #close}, the callback runs on a no-op scope and
+ * nothing it throws is caught.
+ *
* @param callback the callback
*/
public static void withIsolationScope(final @NotNull ScopeCallback callback) {
@@ -1054,6 +1092,11 @@ public static void withIsolationScope(final @NotNull ScopeCallback callback) {
/**
* Configures the scope through the callback.
*
+ * If the callback throws, the rest of it is skipped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only when
+ * {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link OutOfMemoryError}, are
+ * rethrown. Before {@link #init} and after {@link #close}, the callback isn't run.
+ *
* @param callback The configure scope callback.
*/
public static void configureScope(final @NotNull ScopeCallback callback) {
@@ -1063,6 +1106,11 @@ public static void configureScope(final @NotNull ScopeCallback callback) {
/**
* Configures the scope through the callback.
*
+ * If the callback throws, the rest of it is skipped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only when
+ * {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link OutOfMemoryError}, are
+ * rethrown. Before {@link #init} and after {@link #close}, the callback isn't run.
+ *
* @param callback The configure scope callback.
*/
public static void configureScope(
@@ -1266,6 +1314,12 @@ public interface OptionsConfiguration If this callback throws, the SDK is initialized with the options it set before the
+ * exception, and the exception is logged at {@link SentryLevel#ERROR} through {@link
+ * SentryOptions#getLogger()}. By default that prints only when {@link SentryOptions#isDebug()}
+ * was enabled before the exception. Fatal errors, such as {@link OutOfMemoryError}, are
+ * rethrown.
+ *
* @param options the options
*/
void configure(@NotNull T options);
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index b5027432625..29ac3de4d63 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -20,6 +20,7 @@
import io.sentry.transport.ITransport;
import io.sentry.transport.RateLimiter;
import io.sentry.util.*;
+import io.sentry.util.ExceptionUtils;
import java.io.Closeable;
import java.io.IOException;
import java.util.ArrayList;
@@ -229,6 +230,11 @@ private boolean shouldApplyScopeData(final @NotNull CheckIn event, final @NotNul
try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
shouldCaptureReplay = beforeErrorSampling.execute(event, hint);
} catch (Throwable e) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated
+ // like any other exception. As the spec asks, the replay is not captured for this error.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options
.getLogger()
.log(
@@ -494,6 +500,13 @@ private SentryEvent processEvent(
event = processor.process(event, hint);
}
} catch (Throwable e) {
+ // Event processors come from integrations and the app, so we can't know what they throw.
+ // An SDK processor is skipped; any other processor's failure drops the event.
+ // A LinkageError means the processor needs an optional dependency that is missing or has an
+ // incompatible version, which is handled like any other failure.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options
.getLogger()
.log(
@@ -551,6 +564,13 @@ private SentryLogEvent processLogEvent(
try {
event = processor.process(event);
} catch (Throwable e) {
+ // Event processors come from integrations and the app, so we can't know what they throw.
+ // An SDK processor is skipped; any other processor's failure drops the log.
+ // A LinkageError means the processor needs an optional dependency that is missing or has an
+ // incompatible version, which is handled like any other failure.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options
.getLogger()
.log(
@@ -588,6 +608,13 @@ private SentryMetricsEvent processMetricsEvent(
try {
event = processor.process(event, hint);
} catch (Throwable e) {
+ // Event processors come from integrations and the app, so we can't know what they throw.
+ // An SDK processor is skipped; any other processor's failure drops the metric.
+ // A LinkageError means the processor needs an optional dependency that is missing or has an
+ // incompatible version, which is handled like any other failure.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options
.getLogger()
.log(
@@ -625,6 +652,13 @@ private SentryMetricsEvent processMetricsEvent(
try {
transaction = processor.process(transaction, hint);
} catch (Throwable e) {
+ // Event processors come from integrations and the app, so we can't know what they throw.
+ // An SDK processor is skipped; any other processor's failure drops the transaction.
+ // A LinkageError means the processor needs an optional dependency that is missing or has an
+ // incompatible version, which is handled like any other failure.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options
.getLogger()
.log(
@@ -698,6 +732,13 @@ private SentryReplayEvent processReplayEvent(
try {
replayEvent = processor.process(replayEvent, hint);
} catch (Throwable e) {
+ // Event processors come from integrations and the app, so we can't know what they throw.
+ // An SDK processor is skipped; any other processor's failure drops the replay segment.
+ // A LinkageError means the processor needs an optional dependency that is missing or has an
+ // incompatible version, which is handled like any other failure.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options
.getLogger()
.log(
@@ -738,6 +779,13 @@ private SentryEvent processFeedbackEvent(
try {
feedbackEvent = processor.process(feedbackEvent, hint);
} catch (Throwable e) {
+ // Event processors come from integrations and the app, so we can't know what they throw.
+ // An SDK processor is skipped; any other processor's failure drops the feedback.
+ // A LinkageError means the processor needs an optional dependency that is missing or has an
+ // incompatible version, which is handled like any other failure.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options
.getLogger()
.log(
@@ -953,6 +1001,11 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
beforeEnvelopeCallback.execute(envelope, hint);
} catch (Throwable e) {
+ // A callback set by an integration or a hybrid SDK, so we can't know what it throws. A
+ // LinkageError from it is treated like any other exception. The envelope is still sent.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options
.getLogger()
.log(SentryLevel.ERROR, "The BeforeEnvelope callback threw an exception.", e);
@@ -1641,6 +1694,11 @@ private void sortBreadcrumbsByDate(
try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
event = beforeSend.execute(event, hint);
} catch (Throwable e) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated like
+ // any other exception. As the spec asks, the event is dropped.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options
.getLogger()
.log(
@@ -1670,6 +1728,11 @@ private void sortBreadcrumbsByDate(
try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
transaction = beforeSendTransaction.execute(transaction, hint);
} catch (Throwable e) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated like
+ // any other exception. As the spec asks, the transaction is dropped.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options
.getLogger()
.log(
@@ -1730,6 +1793,11 @@ private void sortBreadcrumbsByDate(
try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
event = beforeSendFeedback.execute(event, hint);
} catch (Throwable e) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated like
+ // any other exception. As the spec asks, the feedback is dropped.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options
.getLogger()
.log(
@@ -1757,6 +1825,11 @@ private void sortBreadcrumbsByDate(
try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
event = beforeSendReplay.execute(event, hint);
} catch (Throwable e) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated like
+ // any other exception. As the spec asks, the replay segment is dropped.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options
.getLogger()
.log(
@@ -1785,6 +1858,11 @@ private void sortBreadcrumbsByDate(
try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
event = beforeSendLog.execute(event);
} catch (Throwable e) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated like
+ // any other exception. As the spec asks, the log is dropped.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options
.getLogger()
.log(
@@ -1810,6 +1888,11 @@ private void sortBreadcrumbsByDate(
try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
event = beforeSendMetric.execute(event, hint);
} catch (Throwable e) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated like
+ // any other exception. As the spec asks, the metric is dropped.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(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 5ba97164a5e..df9af9103d5 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -744,8 +744,8 @@ public void activate() {
try {
final Class> clazz = Class.forName("io.sentry.spotlight.SpotlightIntegration");
integrations.add((Integration) clazz.getConstructor().newInstance());
- } catch (Throwable ignored) {
- // SpotlightIntegration not available
+ } catch (ReflectiveOperationException | LinkageError ignored) {
+ // sentry-spotlight is missing or has an incompatible version
}
}
}
@@ -3548,6 +3548,11 @@ public interface BeforeSendCallback {
* integration that routes logs back into Sentry. Such nested captures are silently dropped to
* prevent infinite recursion.
*
+ * If this callback throws, the event is dropped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only
+ * when {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link
+ * OutOfMemoryError}, are rethrown.
+ *
* @param event the event
* @param hint the hints
* @return the original event or the mutated event or null if event was dropped
@@ -3566,6 +3571,11 @@ public interface BeforeSendTransactionCallback {
* integration that routes logs back into Sentry. Such nested captures are silently dropped to
* prevent infinite recursion.
*
+ * If this callback throws, the transaction is dropped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only
+ * when {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link
+ * OutOfMemoryError}, are rethrown.
+ *
* @param transaction the transaction
* @param hint the hints
* @return the original transaction or the mutated transaction or null if transaction was
@@ -3587,6 +3597,11 @@ public interface BeforeSendReplayCallback {
* integration that routes logs back into Sentry. Such nested captures are silently dropped to
* prevent infinite recursion.
*
+ * If this callback throws, the replay event is dropped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only
+ * when {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link
+ * OutOfMemoryError}, are rethrown.
+ *
* @param event the event
* @param hint the hint, contains {@link ReplayRecording}, can be accessed via {@link
* Hint#getReplayRecording()}
@@ -3606,6 +3621,11 @@ public interface BeforeBreadcrumbCallback {
* integration that routes logs back into Sentry. Such nested captures are silently dropped to
* prevent infinite recursion.
*
+ * If this callback throws, the breadcrumb is dropped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only
+ * when {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link
+ * OutOfMemoryError}, are rethrown.
+ *
* @param breadcrumb the breadcrumb
* @param hint the hints, usually the source of the breadcrumb
* @return the original breadcrumb or the mutated breadcrumb of null if breadcrumb was dropped
@@ -3621,6 +3641,11 @@ public interface OnOversizedEventCallback {
* Called when an oversized event is detected. This callback allows custom handling of oversized
* events before automatic reduction steps are applied.
*
+ * If this callback throws, its result is ignored, the automatic reduction continues with the
+ * original event, and the exception is logged at {@link SentryLevel#ERROR} through {@link
+ * SentryOptions#getLogger()}, which by default prints only when {@link SentryOptions#isDebug()}
+ * is enabled. Fatal errors, such as {@link OutOfMemoryError}, are rethrown.
+ *
* @param event the oversized event
* @param hint the hints
* @return the modified event (should ideally be reduced in size)
@@ -3635,6 +3660,11 @@ public interface OnDiscardCallback {
/**
* Best-effort record of data discarded before reaching Sentry
*
+ * If this callback throws, the exception is logged at {@link SentryLevel#ERROR} through
+ * {@link SentryOptions#getLogger()}, which by default prints only when {@link
+ * SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link OutOfMemoryError}, are
+ * rethrown.
+ *
* @param reason the reason data was dropped
* @param category the type of data discarded
* @param number the number of discarded data items
@@ -3650,6 +3680,11 @@ public interface TracesSamplerCallback {
* Calculates the sampling value used to determine if transaction is going to be sent to Sentry
* backend.
*
+ * If this callback throws, the transaction is not sampled and the exception is logged at
+ * {@link SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints
+ * only when {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link
+ * OutOfMemoryError}, are rethrown.
+ *
* @param samplingContext the sampling context
* @return sampling value or {@code null} if decision has not been taken
*/
@@ -3664,6 +3699,11 @@ public interface ProfilesSamplerCallback {
* Calculates the sampling value used to determine if a profile is going to be sent to Sentry
* backend.
*
+ * If this callback throws, no profile is recorded and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only
+ * when {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link
+ * OutOfMemoryError}, are rethrown.
+ *
* @param samplingContext the sampling context
* @return sampling value or {@code null} if decision has not been taken
*/
@@ -4229,6 +4269,11 @@ public interface BeforeSendLogCallback {
* integration that routes logs back into Sentry. Such nested captures are silently dropped to
* prevent infinite recursion.
*
+ * If this callback throws, the log is dropped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only
+ * when {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link
+ * OutOfMemoryError}, are rethrown.
+ *
* @param event the event
* @return the original log event or the mutated event or null if event was dropped
*/
@@ -4286,6 +4331,11 @@ public interface BeforeSendMetricCallback {
* integration that routes logs back into Sentry. Such nested captures are silently dropped to
* prevent infinite recursion.
*
+ * If this callback throws, the metric is dropped and the exception is logged at {@link
+ * SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by default prints only
+ * when {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as {@link
+ * OutOfMemoryError}, are rethrown.
+ *
* @param metric the metric
* @return the original metric, mutated metric or null if metric was dropped
*/
diff --git a/sentry/src/main/java/io/sentry/SentryReplayOptions.java b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
index a068e12f2a8..137569b3a59 100644
--- a/sentry/src/main/java/io/sentry/SentryReplayOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
@@ -32,6 +32,11 @@ public interface BeforeErrorSamplingCallback {
* integration that routes logs back into Sentry. Such nested captures are silently dropped to
* prevent infinite recursion.
*
+ * If this callback throws, the replay is not captured for this error and the exception is
+ * logged at {@link SentryLevel#ERROR} through {@link SentryOptions#getLogger()}, which by
+ * default prints only when {@link SentryOptions#isDebug()} is enabled. Fatal errors, such as
+ * {@link OutOfMemoryError}, are rethrown.
+ *
* @param event the error event that triggered the replay capture
* @param hint the hint associated with the event
* @return {@code true} if the error sample rate should be checked, {@code false} to skip replay
@@ -56,6 +61,11 @@ public interface ReplayFrameObserver {
/**
* Called when a masked replay frame is captured.
*
+ * If this method throws, the SDK recycles the bitmap and still records the frame. The
+ * exception is only reported as an error through {@link SentryOptions#getLogger()}, which by
+ * default prints only when {@link SentryOptions#isDebug()} is enabled, so enable debug to find
+ * out whether your observer fails. Errors such as {@link OutOfMemoryError} are not caught.
+ *
* @param hint contains the frame bitmap under {@link TypeCheckHint#REPLAY_FRAME_BITMAP}
* @param frameTimestamp the timestamp (in milliseconds since epoch) when the frame was captured
* @param screenName the current screen name, or {@code null} if unknown
diff --git a/sentry/src/main/java/io/sentry/TracesSampler.java b/sentry/src/main/java/io/sentry/TracesSampler.java
index bb6e5d9f11f..9f699f88bd3 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.ExceptionUtils;
import io.sentry.util.Objects;
import io.sentry.util.SampleRateUtils;
import org.jetbrains.annotations.ApiStatus;
@@ -31,6 +32,11 @@ public TracesSamplingDecision sample(final @NotNull SamplingContext samplingCont
try {
profilesSampleRate = options.getProfilesSampler().sample(samplingContext);
} catch (Throwable t) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated like
+ // any other exception. The transaction is not profiled.
+ if (!(t instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(t);
+ }
profilesSamplerFailed = true;
options
.getLogger()
@@ -47,6 +53,11 @@ public TracesSamplingDecision sample(final @NotNull SamplingContext samplingCont
try {
samplerResult = options.getTracesSampler().sample(samplingContext);
} catch (Throwable t) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated like
+ // any other exception. As the spec asks, the transaction is dropped.
+ if (!(t instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(t);
+ }
options
.getLogger()
.log(SentryLevel.ERROR, "Error in the 'TracesSamplerCallback' callback.", t);
diff --git a/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java b/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java
index ba6d60e2563..08c00379b4e 100644
--- a/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java
+++ b/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java
@@ -9,6 +9,7 @@
import io.sentry.SentryOptions;
import io.sentry.protocol.SentrySpan;
import io.sentry.protocol.SentryTransaction;
+import io.sentry.util.ExceptionUtils;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
@@ -151,6 +152,12 @@ private void executeOnDiscard(
try {
options.getOnDiscard().execute(reason, category, countToAdd);
} catch (Throwable e) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated like
+ // any other exception. Only this notification is lost; the discard is still counted in the
+ // client report.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options.getLogger().log(SentryLevel.ERROR, "The onDiscard callback threw an exception.", e);
}
}
diff --git a/sentry/src/main/java/io/sentry/profiling/ProfilingServiceLoader.java b/sentry/src/main/java/io/sentry/profiling/ProfilingServiceLoader.java
index cf86a13fc53..683eea8a866 100644
--- a/sentry/src/main/java/io/sentry/profiling/ProfilingServiceLoader.java
+++ b/sentry/src/main/java/io/sentry/profiling/ProfilingServiceLoader.java
@@ -9,6 +9,7 @@
import io.sentry.ScopesAdapter;
import io.sentry.SentryLevel;
import java.util.Iterator;
+import java.util.ServiceConfigurationError;
import java.util.ServiceLoader;
import org.jetbrains.annotations.ApiStatus;
import org.jetbrains.annotations.NotNull;
@@ -38,7 +39,8 @@ public final class ProfilingServiceLoader {
logger.log(
SentryLevel.DEBUG, "No continuous profiler provider found, using NoOpContinuousProfiler");
return NoOpContinuousProfiler.getInstance();
- } catch (Throwable t) {
+ } catch (ServiceConfigurationError | LinkageError t) {
+ // The provider is broken, or async-profiler's native library failed to load
logger.log(
SentryLevel.ERROR,
"Failed to load continuous profiler provider, using NoOpContinuousProfiler",
@@ -68,7 +70,8 @@ public final class ProfilingServiceLoader {
SentryLevel.DEBUG, "No profile converter provider found, using NoOpProfileConverter");
return NoOpProfileConverter.getInstance();
}
- } catch (Throwable t) {
+ } catch (ServiceConfigurationError | LinkageError t) {
+ // The provider is broken, or a class it needs is missing
logger.log(
SentryLevel.ERROR,
"Failed to load profile converter provider, using NoOpProfileConverter",
diff --git a/sentry/src/main/java/io/sentry/util/EventSizeLimitingUtils.java b/sentry/src/main/java/io/sentry/util/EventSizeLimitingUtils.java
index c6c3d1a48b2..9a167294386 100644
--- a/sentry/src/main/java/io/sentry/util/EventSizeLimitingUtils.java
+++ b/sentry/src/main/java/io/sentry/util/EventSizeLimitingUtils.java
@@ -69,6 +69,12 @@ private EventSizeLimitingUtils() {}
return reducedEvent;
}
} catch (Throwable e) {
+ // A user callback, so we can't know what it throws. A LinkageError from it is treated
+ // like any other exception. Its result is ignored, and the automatic reduction continues
+ // with the original event.
+ if (!(e instanceof LinkageError)) {
+ ExceptionUtils.rethrowIfFatal(e);
+ }
options
.getLogger()
.log(
diff --git a/sentry/src/main/java/io/sentry/util/LoadClass.java b/sentry/src/main/java/io/sentry/util/LoadClass.java
index bf179fad459..aedd27a14be 100644
--- a/sentry/src/main/java/io/sentry/util/LoadClass.java
+++ b/sentry/src/main/java/io/sentry/util/LoadClass.java
@@ -41,7 +41,8 @@ public class LoadClass {
if (logger != null) {
logger.log(SentryLevel.ERROR, "Failed to load (UnsatisfiedLinkError) " + clazz, e);
}
- } catch (Throwable e) {
+ } catch (LinkageError e) {
+ // e.g. ExceptionInInitializerError, or NoClassDefFoundError for a dependency of the class
if (logger != null) {
logger.log(SentryLevel.ERROR, "Failed to initialize " + clazz, e);
}