From db300e8081ca2c7e3d6001f8199f6975f50b422c Mon Sep 17 00:00:00 2001 From: Markus Hintersteiner Date: Fri, 20 Nov 2026 07:55:53 +0100 Subject: [PATCH] feat(anr): Report non-fatal ANRs --- .../api/sentry-android-core.api | 26 ++ .../core/AndroidOptionsInitializer.java | 4 + .../android/core/ManifestMetadataReader.java | 16 + .../sentry/android/core/NonFatalAnrHint.java | 53 +++ .../android/core/NonFatalAnrIntegration.java | 249 +++++++++++ .../core/ScreenshotEventProcessor.java | 6 + .../android/core/SentryAndroidOptions.java | 71 +++- .../core/ViewHierarchyEventProcessor.java | 6 + .../android/core/anr/NonFatalAnrMarker.java | 103 +++++ .../core/AndroidOptionsInitializerTest.kt | 16 + .../core/ManifestMetadataReaderTest.kt | 25 ++ .../core/NonFatalAnrIntegrationTest.kt | 402 ++++++++++++++++++ .../core/ScreenshotEventProcessorTest.kt | 27 ++ .../android/core/SentryAndroidOptionsTest.kt | 23 + .../core/ViewHierarchyEventProcessorTest.kt | 27 ++ .../android/core/anr/NonFatalAnrMarkerTest.kt | 91 ++++ 16 files changed, 1144 insertions(+), 1 deletion(-) create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/NonFatalAnrHint.java create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/NonFatalAnrIntegration.java create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/anr/NonFatalAnrMarker.java create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/NonFatalAnrIntegrationTest.kt create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/anr/NonFatalAnrMarkerTest.kt diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api index 6d9b7b62e6d..434a79170d1 100644 --- a/sentry-android-core/api/sentry-android-core.api +++ b/sentry-android-core/api/sentry-android-core.api @@ -398,6 +398,20 @@ public final class io/sentry/android/core/NetworkBreadcrumbsIntegration : io/sen public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V } +public final class io/sentry/android/core/NonFatalAnrHint : io/sentry/hints/DiskFlushNotification { + public fun (ZLjava/lang/Runnable;)V + public fun isFlushable (Lio/sentry/protocol/SentryId;)Z + public fun isMainThreadBlocked ()Z + public fun markFlushed ()V + public fun setFlushable (Lio/sentry/protocol/SentryId;)V +} + +public final class io/sentry/android/core/NonFatalAnrIntegration : io/sentry/Integration, java/io/Closeable { + public fun ()V + public fun close ()V + public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V +} + public final class io/sentry/android/core/PerfettoContinuousProfiler : io/sentry/IContinuousProfiler, io/sentry/transport/RateLimiter$IRateLimitObserver { public fun (Lio/sentry/ILogger;Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;Lio/sentry/util/LazyEvaluator$Evaluator;Ljava/util/function/Supplier;)V public fun close (Z)V @@ -450,6 +464,8 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr public fun getNativeSdkName ()Ljava/lang/String; public fun getNdkAppHangTimeoutIntervalMillis ()J public fun getNdkHandlerStrategy ()I + public fun getNonFatalAnrSampleRate ()Ljava/lang/Double; + public fun getNonFatalAnrThresholdMs ()J public fun getScreenshot ()Lio/sentry/android/core/SentryScreenshotOptions; public fun getStartupCrashDurationThresholdMillis ()J public fun getTombstoneMergeTimeThresholdMillis ()J @@ -521,6 +537,8 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr public fun setNativeHandlerStrategy (Lio/sentry/android/core/NdkHandlerStrategy;)V public fun setNativeSdkName (Ljava/lang/String;)V public fun setNdkAppHangTimeoutIntervalMillis (J)V + public fun setNonFatalAnrSampleRate (Ljava/lang/Double;)V + public fun setNonFatalAnrThresholdMs (J)V public fun setReportHistoricalAnrs (Z)V public fun setReportHistoricalMemoryLimiterExits (Z)V public fun setReportHistoricalTombstones (Z)V @@ -789,6 +807,14 @@ public final class io/sentry/android/core/anr/AnrStackTrace : java/lang/Comparab public fun serialize (Ljava/io/DataOutputStream;)V } +public final class io/sentry/android/core/anr/NonFatalAnrMarker { + public static final field FILE_NAME Ljava/lang/String; + public static fun delete (Lio/sentry/SentryOptions;)V + public fun matches (IJ)Z + public static fun read (Lio/sentry/SentryOptions;)Lio/sentry/android/core/anr/NonFatalAnrMarker; + public static fun write (Lio/sentry/SentryOptions;IJJ)V +} + public final class io/sentry/android/core/anr/StackTraceConverter { public fun ()V public static fun convert (Lio/sentry/android/core/anr/AnrProfile;)Lio/sentry/protocol/profiling/SentryProfile; diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java index 3e7cfd65ff7..d32d2145b1e 100644 --- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java +++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java @@ -489,6 +489,10 @@ static void installDefaultIntegrations( options.addIntegration(AnrIntegrationFactory.create(context, buildInfoProvider)); options.addIntegration(new AnrProfilingIntegration()); + // Below API 30, AnrIntegration reports the same hangs, and nothing reads the marker. + if (buildInfoProvider.getSdkInfoVersion() >= Build.VERSION_CODES.R) { + options.addIntegration(new NonFatalAnrIntegration()); + } // registerActivityLifecycleCallbacks is only available if Context is an AppContext if (context instanceof Application) { 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 da60741a4c9..2513114183a 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 @@ -232,6 +232,8 @@ final class ManifestMetadataReader { static final String SCREENSHOT_MASK_ALL_IMAGES = "io.sentry.screenshot.mask-all-images"; static final String ANR_PROFILING_SAMPLE_RATE = "io.sentry.anr.profiling.sample-rate"; + static final String NON_FATAL_ANR_SAMPLE_RATE = "io.sentry.anr.non-fatal.sample-rate"; + static final String NON_FATAL_ANR_THRESHOLD_MS = "io.sentry.anr.non-fatal.threshold-ms"; static final String ENABLE_ANR_FINGERPRINTING = "io.sentry.anr.enable-fingerprinting"; @@ -825,6 +827,20 @@ static void applyMetadata( } } + if (options.getNonFatalAnrSampleRate() == null) { + final double nonFatalAnrSampleRate = + readDouble(metadata, logger, NON_FATAL_ANR_SAMPLE_RATE); + if (nonFatalAnrSampleRate != -1) { + options.setNonFatalAnrSampleRate(nonFatalAnrSampleRate); + } + } + + final long nonFatalAnrThresholdMs = + readLong(metadata, logger, NON_FATAL_ANR_THRESHOLD_MS, -1); + if (nonFatalAnrThresholdMs != -1) { + options.setNonFatalAnrThresholdMs(nonFatalAnrThresholdMs); + } + options.setEnableAnrFingerprinting( readBool( metadata, logger, ENABLE_ANR_FINGERPRINTING, options.isEnableAnrFingerprinting())); diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/NonFatalAnrHint.java b/sentry-android-core/src/main/java/io/sentry/android/core/NonFatalAnrHint.java new file mode 100644 index 00000000000..68d93d36d7b --- /dev/null +++ b/sentry-android-core/src/main/java/io/sentry/android/core/NonFatalAnrHint.java @@ -0,0 +1,53 @@ +package io.sentry.android.core; + +import io.sentry.hints.DiskFlushNotification; +import io.sentry.protocol.SentryId; +import java.util.concurrent.atomic.AtomicBoolean; +import org.jetbrains.annotations.ApiStatus; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * Type-check hint of non-fatal ANR events. Of the {@code io.sentry.hints} interfaces it implements + * only {@link DiskFlushNotification}, so the session is not ended as abnormal for it. + */ +@ApiStatus.Internal +public final class NonFatalAnrHint implements DiskFlushNotification { + + private final boolean mainThreadBlocked; + private final @Nullable Runnable onStoredOnDisk; + private final @NotNull AtomicBoolean flushed = new AtomicBoolean(false); + + /** + * @param onStoredOnDisk runs once, on the transport thread, after the envelope of the event was + * stored on disk. The transport also calls it when a rate limit drops the event. Null if the + * event needs no action on disk. + */ + public NonFatalAnrHint(final boolean mainThreadBlocked, final @Nullable Runnable onStoredOnDisk) { + this.mainThreadBlocked = mainThreadBlocked; + this.onStoredOnDisk = onStoredOnDisk; + } + + /** + * Whether the main thread is still blocked when the event is captured, because the hang was cut + * at the maximum recording time. Anything that waits for the main thread must then skip its work. + */ + public boolean isMainThreadBlocked() { + return mainThreadBlocked; + } + + @Override + public void markFlushed() { + if (onStoredOnDisk != null && flushed.compareAndSet(false, true)) { + onStoredOnDisk.run(); + } + } + + @Override + public boolean isFlushable(final @Nullable SentryId eventId) { + return true; + } + + @Override + public void setFlushable(final @NotNull SentryId eventId) {} +} diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/NonFatalAnrIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/NonFatalAnrIntegration.java new file mode 100644 index 00000000000..c770ebf8e85 --- /dev/null +++ b/sentry-android-core/src/main/java/io/sentry/android/core/NonFatalAnrIntegration.java @@ -0,0 +1,249 @@ +package io.sentry.android.core; + +import static io.sentry.util.IntegrationUtils.addIntegrationToSdkVersion; + +import android.os.Looper; +import android.os.Process; +import io.sentry.Breadcrumb; +import io.sentry.DateUtils; +import io.sentry.ILogger; +import io.sentry.IScopes; +import io.sentry.Integration; +import io.sentry.SentryEvent; +import io.sentry.SentryExceptionFactory; +import io.sentry.SentryLevel; +import io.sentry.SentryOptions; +import io.sentry.SentryStackTraceFactory; +import io.sentry.android.core.anr.AggregatedStackTrace; +import io.sentry.android.core.anr.AnrCulpritEventHelper; +import io.sentry.android.core.anr.AnrCulpritIdentifier; +import io.sentry.android.core.anr.AnrStackTrace; +import io.sentry.android.core.anr.NonFatalAnrMarker; +import io.sentry.android.core.hang.HangRecord; +import io.sentry.android.core.hang.HangRecorder; +import io.sentry.android.core.hang.HangRecorderListener; +import io.sentry.android.core.internal.util.AndroidThreadChecker; +import io.sentry.protocol.Mechanism; +import io.sentry.protocol.SentryException; +import io.sentry.protocol.SentryThread; +import io.sentry.util.HintUtils; +import io.sentry.util.Objects; +import io.sentry.util.SentryRandom; +import java.io.Closeable; +import java.io.IOException; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.atomic.AtomicReference; +import org.jetbrains.annotations.ApiStatus; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * Reports main-thread hangs as non-fatal ANR events: hangs that recover, before or after Android + * shows the ANR dialog, and hangs that still block the main thread after 8 s, which are cut there. + * + *

If sampled, subscribes to the {@link HangRecorder} of the options for the SDK lifetime. + * Installed from Android 11 (API 30), where {@link AnrV2Integration} skips the fatal ANRs that this + * integration already reported. + * + *

Enable via {@link SentryAndroidOptions#setNonFatalAnrSampleRate(Double)} or the {@code + * io.sentry.anr.non-fatal.sample-rate} manifest metadata. + */ +@ApiStatus.Internal +public final class NonFatalAnrIntegration implements Integration, Closeable { + + /** + * Android reports an input ANR after 5 s at the earliest, so a shorter hang cannot be a fatal ANR + * and gets no marker. + */ + static final long MIN_FATAL_ANR_DURATION_MS = 5_000; + + private final @NotNull AtomicReference subscribedRecorder = new AtomicReference<>(); + private final @NotNull AtomicReference subscription = + new AtomicReference<>(); + + @Override + public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions options) { + final @NotNull SentryAndroidOptions androidOptions = + Objects.requireNonNull( + (options instanceof SentryAndroidOptions) ? (SentryAndroidOptions) options : null, + "SentryAndroidOptions is required"); + if (!androidOptions.isAnrEnabled() || !androidOptions.isNonFatalAnrEnabled()) { + return; + } + final @NotNull ILogger logger = options.getLogger(); + final @Nullable HangRecorder recorder = androidOptions.getHangRecorder(); + if (recorder == null) { + logger.log(SentryLevel.WARNING, "Non-fatal ANR is enabled but there is no hang recorder"); + return; + } + final @Nullable Double sampleRate = androidOptions.getNonFatalAnrSampleRate(); + if (sampleRate == null || SentryRandom.current().nextDouble() >= sampleRate) { + logger.log(SentryLevel.DEBUG, "Non-fatal ANR is not sampled"); + return; + } + if (!subscribedRecorder.compareAndSet(null, recorder)) { + return; + } + final @NotNull HangRecorderListener listener = new Reporter(scopes, androidOptions); + subscription.set(listener); + recorder.subscribe(listener); + addIntegrationToSdkVersion("NonFatalAnr"); + } + + @Override + public void close() throws IOException { + final @Nullable HangRecorder recorder = subscribedRecorder.getAndSet(null); + final @Nullable HangRecorderListener listener = subscription.getAndSet(null); + if (recorder != null && listener != null) { + recorder.unsubscribe(listener); + } + } + + private static final class Reporter implements HangRecorderListener { + + private final @NotNull IScopes scopes; + private final @NotNull SentryAndroidOptions options; + private final @NotNull AnrCulpritEventHelper culpritEventHelper; + + Reporter(final @NotNull IScopes scopes, final @NotNull SentryAndroidOptions options) { + this.scopes = scopes; + this.options = options; + this.culpritEventHelper = + new AnrCulpritEventHelper( + new SentryExceptionFactory(new SentryStackTraceFactory(options))); + } + + @Override + public void onHangRecorded(final @NotNull HangRecord record) { + if (record.getDurationMs() < options.getNonFatalAnrThresholdMs()) { + return; + } + final long startTimestampMs = record.getStartTimestampMs(); + final long endTimestampMs = startTimestampMs + record.getDurationMs(); + + // Only once the event is on disk: a kill before that must not suppress the fatal ANR. + final @Nullable Runnable writeMarker; + if (record.hasEndedAtMaxRecordingTime() + || record.getDurationMs() >= MIN_FATAL_ANR_DURATION_MS) { + final int pid = Process.myPid(); + writeMarker = () -> NonFatalAnrMarker.write(options, pid, startTimestampMs, endTimestampMs); + } else { + writeMarker = null; + } + + final @NotNull SentryEvent event = buildEvent(record, endTimestampMs); + scopes.captureEvent( + event, + HintUtils.createWithTypeCheckHint( + new NonFatalAnrHint(record.hasEndedAtMaxRecordingTime(), writeMarker))); + + final @NotNull Breadcrumb breadcrumb = new Breadcrumb(); + breadcrumb.setCategory("anr"); + breadcrumb.setType("error"); + breadcrumb.setLevel(SentryLevel.WARNING); + breadcrumb.setMessage("Non-fatal ANR"); + breadcrumb.setData("duration_ms", record.getDurationMs()); + scopes.addBreadcrumb(breadcrumb); + } + + private @NotNull SentryEvent buildEvent( + final @NotNull HangRecord record, final long endTimestampMs) { + final @NotNull List samples = record.getSamples(); + final @Nullable AggregatedStackTrace culprit = + samples.isEmpty() ? null : AnrCulpritIdentifier.identify(samples); + + final @NotNull Mechanism mechanism = new Mechanism(); + mechanism.setType("NonFatalANR"); + mechanism.setHandled(true); + + @Nullable + List exceptions = + culprit == null ? null : culpritEventHelper.toSentryExceptions(culprit, mechanism); + if (exceptions == null) { + final @NotNull SentryException exception = new SentryException(); + exception.setType(ApplicationNotResponding.class.getName()); + exception.setValue("Non-fatal ANR"); + exception.setMechanism(mechanism); + exceptions = Arrays.asList(exception); + } + final long mainThreadId = + AndroidThreadChecker.getThreadId(Looper.getMainLooper().getThread()); + for (final @NotNull SentryException exception : exceptions) { + exception.setThreadId(mainThreadId); + } + + final @NotNull SentryEvent event = new SentryEvent(DateUtils.getDateTime(endTimestampMs)); + event.setLevel(SentryLevel.ERROR); + event.setExceptions(exceptions); + event.setThreads(Arrays.asList(mainThread(mainThreadId, samples, culprit, exceptions))); + + final @NotNull Map context = new HashMap<>(); + context.put("duration_ms", record.getDurationMs()); + context.put("sample_count", samples.size()); + event.getContexts().put("non_fatal_anr", context); + + if (event.getFingerprints() == null) { + if (options.isEnableAnrFingerprinting() + && AnrCulpritEventHelper.hasOnlySystemFrames(exceptions)) { + event.setFingerprints(Arrays.asList("system-frames-only-anr", "non-fatal-anr")); + } else { + event.setFingerprints(Arrays.asList("{{ default }}", "non-fatal-anr")); + } + } + return event; + } + + private static @NotNull SentryThread mainThread( + final long mainThreadId, + final @NotNull List samples, + final @Nullable AggregatedStackTrace culprit, + final @NotNull List exceptions) { + final @NotNull SentryThread thread = new SentryThread(); + thread.setId(mainThreadId); + thread.setName("main"); + thread.setCurrent(true); + thread.setMain(true); + final @Nullable Thread.State state = culpritState(samples, culprit); + if (state != null) { + thread.setState(state.name()); + } + if (culprit != null) { + thread.setStacktrace(exceptions.get(0).getStacktrace()); + } + return thread; + } + + private static @Nullable Thread.State culpritState( + final @NotNull List samples, final @Nullable AggregatedStackTrace culprit) { + if (samples.isEmpty()) { + return null; + } + if (culprit != null) { + final @NotNull StackTraceElement[] culpritStack = culprit.getStack(); + for (int i = samples.size() - 1; i >= 0; i--) { + if (containsRun(samples.get(i).stack, culpritStack)) { + return samples.get(i).state; + } + } + } + return samples.get(samples.size() - 1).state; + } + + private static boolean containsRun( + final @NotNull StackTraceElement[] stack, final @NotNull StackTraceElement[] run) { + for (int start = 0; start + run.length <= stack.length; start++) { + int offset = 0; + while (offset < run.length && stack[start + offset].equals(run[offset])) { + offset++; + } + if (offset == run.length) { + return true; + } + } + return false; + } + } +} 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 849f1099484..e1cfa8638bb 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 @@ -88,6 +88,12 @@ public ScreenshotEventProcessor( return event; } + final @Nullable Object sdkHint = HintUtils.getSentrySdkHint(hint); + if (sdkHint instanceof NonFatalAnrHint && ((NonFatalAnrHint) sdkHint).isMainThreadBlocked()) { + // The main thread is still blocked, waiting for it would delay the event. + return event; + } + // skip capturing in case of debouncing (=too many frequent capture requests) // the BeforeCaptureCallback may overrules the debouncing decision final boolean shouldDebounce = debouncer.checkForDebounce(); diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java index 9789d070af1..7b14d1f89d3 100644 --- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java +++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java @@ -332,6 +332,10 @@ public interface BeforeCaptureCallback { */ private @Nullable Double anrProfilingSampleRate; + private @Nullable Double nonFatalAnrSampleRate; + + private long nonFatalAnrThresholdMs = 700; + private boolean enableAnrFingerprinting = true; private volatile @Nullable HangRecorder hangRecorder; @@ -401,7 +405,11 @@ public boolean isAnrReportInDebug() { } /** - * Sets ANR (Application Not Responding) to enabled or disabled on Debug mode Default is disabled + * Sets whether {@link AnrIntegration} (ANR v1, below Android 11) reports ANRs while a debugger is + * connected. Default is disabled. + * + *

Only ANR v1 uses this flag. Non-fatal ANR reporting and ANR profiling always ignore hangs + * while a debugger is connected. * * @param anrReportInDebug true for enabled and false for disabled */ @@ -1009,6 +1017,67 @@ public boolean isAnrProfilingEnabled() { return anrProfilingSampleRate != null && anrProfilingSampleRate > 0; } + /** + * Returns the sample rate for reporting non-fatal ANRs: main-thread hangs that recover, and hangs + * that still block the main thread after 8 s, which are cut there. + * + * @return the non-fatal ANR sample rate, or {@code null} when reporting is disabled (default) + */ + public @Nullable Double getNonFatalAnrSampleRate() { + return nonFatalAnrSampleRate; + } + + /** + * Sets the sample rate for reporting non-fatal ANRs. The sampling decision is made once per SDK + * initialization, not once per hang. + * + *

Use {@code null} to disable (default). Values must be between {@code 0.0} and {@code 1.0}. + * + * @param nonFatalAnrSampleRate the sample rate, or {@code null} to disable + */ + public void setNonFatalAnrSampleRate(final @Nullable Double nonFatalAnrSampleRate) { + if (!SampleRateUtils.isValidSampleRate(nonFatalAnrSampleRate)) { + throw new IllegalArgumentException( + "The value " + + nonFatalAnrSampleRate + + " is not valid. Use null to disable or values >= 0.0 and <= 1.0."); + } + this.nonFatalAnrSampleRate = nonFatalAnrSampleRate; + } + + /** + * Returns the minimum duration in milliseconds a main-thread hang needs to be reported as a + * non-fatal ANR. Defaults to 700. + */ + public long getNonFatalAnrThresholdMs() { + return nonFatalAnrThresholdMs; + } + + /** + * Sets the minimum duration in milliseconds a main-thread hang needs to be reported as a + * non-fatal ANR. Defaults to 700. Only used if {@link #getNonFatalAnrSampleRate()} is set. + * + *

Detection starts after 300 ms, so a lower value behaves like 300 ms. A hang is measured up + * to 8 000 ms, so a higher value never reports. A negative value is ignored. + * + * @param nonFatalAnrThresholdMs the threshold in milliseconds + */ + public void setNonFatalAnrThresholdMs(final long nonFatalAnrThresholdMs) { + if (nonFatalAnrThresholdMs < 0) { + getLogger() + .log( + SentryLevel.WARNING, + "The non-fatal ANR threshold %d ms is negative and is ignored.", + nonFatalAnrThresholdMs); + return; + } + this.nonFatalAnrThresholdMs = nonFatalAnrThresholdMs; + } + + boolean isNonFatalAnrEnabled() { + return nonFatalAnrSampleRate != null && nonFatalAnrSampleRate > 0; + } + /** * The recorder that the ANR integrations share. Null if {@link #getCacheDirPath()} was null at * init. 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..fa1c21ec744 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 @@ -80,6 +80,12 @@ public ViewHierarchyEventProcessor(final @NotNull SentryAndroidOptions options) return event; } + final @Nullable Object sdkHint = HintUtils.getSentrySdkHint(hint); + if (sdkHint instanceof NonFatalAnrHint && ((NonFatalAnrHint) sdkHint).isMainThreadBlocked()) { + // The main thread is still blocked, waiting for it would delay the event. + return event; + } + // skip capturing in case of debouncing (=too many frequent capture requests) // the BeforeCaptureCallback may overrules the debouncing decision final boolean shouldDebounce = debouncer.checkForDebounce(); diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/anr/NonFatalAnrMarker.java b/sentry-android-core/src/main/java/io/sentry/android/core/anr/NonFatalAnrMarker.java new file mode 100644 index 00000000000..7d63d6d0844 --- /dev/null +++ b/sentry-android-core/src/main/java/io/sentry/android/core/anr/NonFatalAnrMarker.java @@ -0,0 +1,103 @@ +package io.sentry.android.core.anr; + +import io.sentry.SentryLevel; +import io.sentry.SentryOptions; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import org.jetbrains.annotations.ApiStatus; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * Remembers the last non-fatal ANR of this process that can also be a fatal ANR, so that the next + * launch can tell that a fatal ANR it finds in the exit reasons was already reported. + * + *

Format, big-endian: {@code short version (1)}, {@code int pid}, {@code long startTimestampMs}, + * {@code long endTimestampMs}, both as Unix time in milliseconds. + */ +@ApiStatus.Internal +public final class NonFatalAnrMarker { + + public static final @NotNull String FILE_NAME = "last_non_fatal_anr"; + + private static final short VERSION = 1; + + // Covers a user who waits at the ANR dialog before closing the app. + private static final long GRACE_PERIOD_MS = 30_000; + + private final int pid; + private final long startTimestampMs; + private final long endTimestampMs; + + private NonFatalAnrMarker(final int pid, final long startTimestampMs, final long endTimestampMs) { + this.pid = pid; + this.startTimestampMs = startTimestampMs; + this.endTimestampMs = endTimestampMs; + } + + /** Whether an exit of the process {@code pid} at {@code exitTimestampMs} belongs to this hang. */ + public boolean matches(final int pid, final long exitTimestampMs) { + return this.pid == pid + && exitTimestampMs >= startTimestampMs + && exitTimestampMs <= endTimestampMs + GRACE_PERIOD_MS; + } + + /** Overwrites the previous marker. */ + public static void write( + final @NotNull SentryOptions options, + final int pid, + final long startTimestampMs, + final long endTimestampMs) { + final @Nullable File file = markerFile(options); + if (file == null) { + return; + } + try (final @NotNull DataOutputStream dos = new DataOutputStream(new FileOutputStream(file))) { + dos.writeShort(VERSION); + dos.writeInt(pid); + dos.writeLong(startTimestampMs); + dos.writeLong(endTimestampMs); + } catch (IOException e) { + options.getLogger().log(SentryLevel.ERROR, "Failed to write the non-fatal ANR marker", e); + } + } + + /** Reads the marker, or returns null if it is missing, corrupt or of an unknown version. */ + public static @Nullable NonFatalAnrMarker read(final @NotNull SentryOptions options) { + final @Nullable File file = markerFile(options); + if (file == null || !file.exists()) { + return null; + } + try (final @NotNull DataInputStream dis = new DataInputStream(new FileInputStream(file))) { + if (dis.readShort() != VERSION) { + return null; + } + return new NonFatalAnrMarker(dis.readInt(), dis.readLong(), dis.readLong()); + } catch (IOException e) { + options.getLogger().log(SentryLevel.ERROR, "Failed to read the non-fatal ANR marker", e); + return null; + } + } + + public static void delete(final @NotNull SentryOptions options) { + final @Nullable File file = markerFile(options); + if (file != null && file.exists() && !file.delete()) { + options.getLogger().log(SentryLevel.WARNING, "Could not delete the non-fatal ANR marker"); + } + } + + private static @Nullable File markerFile(final @NotNull SentryOptions options) { + final @Nullable String cacheDirPath = options.getCacheDirPath(); + if (cacheDirPath == null) { + options + .getLogger() + .log(SentryLevel.DEBUG, "No cacheDirPath, the non-fatal ANR marker is not available"); + return null; + } + return new File(cacheDirPath, FILE_NAME); + } +} diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt index e87679528e2..bb7bad12618 100644 --- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt +++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt @@ -1144,6 +1144,22 @@ class AndroidOptionsInitializerTest { assertNull(anrv1Integration) } + @Config(sdk = [30]) + @Test + fun `NonFatalAnrIntegration added to integrations list for API 30 and above`() { + fixture.initSut(useRealContext = true) + + assertNotNull(fixture.sentryOptions.integrations.firstOrNull { it is NonFatalAnrIntegration }) + } + + @Config(sdk = [29]) + @Test + fun `NonFatalAnrIntegration not added to integrations list below API 30`() { + fixture.initSut(useRealContext = true) + + assertNull(fixture.sentryOptions.integrations.firstOrNull { it is NonFatalAnrIntegration }) + } + @Test fun `MemoryLimiterIntegration added to integrations list for API 37 and above`() { val options = SentryAndroidOptions() 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 a6a3f1f34fd..04301848d82 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 @@ -2562,6 +2562,31 @@ class ManifestMetadataReaderTest { assertNull(fixture.options.anrProfilingSampleRate) } + @Test + fun `applyMetadata reads non fatal anr options`() { + val bundle = + bundleOf( + ManifestMetadataReader.NON_FATAL_ANR_SAMPLE_RATE to 0.25f, + ManifestMetadataReader.NON_FATAL_ANR_THRESHOLD_MS to 1500, + ) + val context = fixture.getContext(metaData = bundle) + + ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider) + + assertEquals(0.25, fixture.options.nonFatalAnrSampleRate!!, 0.01) + assertEquals(1500L, fixture.options.nonFatalAnrThresholdMs) + } + + @Test + fun `applyMetadata keeps non fatal anr defaults when not set in manifest`() { + val context = fixture.getContext() + + ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider) + + assertNull(fixture.options.nonFatalAnrSampleRate) + assertEquals(700L, fixture.options.nonFatalAnrThresholdMs) + } + @Test fun `applyMetadata reads enableAnrFingerprinting to options`() { // Arrange diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/NonFatalAnrIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/NonFatalAnrIntegrationTest.kt new file mode 100644 index 00000000000..705f46eb946 --- /dev/null +++ b/sentry-android-core/src/test/java/io/sentry/android/core/NonFatalAnrIntegrationTest.kt @@ -0,0 +1,402 @@ +package io.sentry.android.core + +import android.os.Looper +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.google.common.truth.Truth.assertThat +import io.sentry.Breadcrumb +import io.sentry.Hint +import io.sentry.IScopes +import io.sentry.SentryEvent +import io.sentry.SentryIntegrationPackageStorage +import io.sentry.SentryLevel +import io.sentry.android.core.anr.AnrStackTrace +import io.sentry.android.core.anr.NonFatalAnrMarker +import io.sentry.android.core.hang.HangRecord +import io.sentry.android.core.hang.HangRecorder +import io.sentry.android.core.hang.HangRecorderListener +import io.sentry.android.core.internal.util.AndroidThreadChecker +import io.sentry.hints.AbnormalExit +import io.sentry.protocol.SentryId +import io.sentry.util.HintUtils +import java.io.File +import kotlin.test.BeforeTest +import kotlin.test.Test +import org.junit.Rule +import org.junit.rules.TemporaryFolder +import org.junit.runner.RunWith +import org.mockito.kotlin.any +import org.mockito.kotlin.argumentCaptor +import org.mockito.kotlin.mock +import org.mockito.kotlin.never +import org.mockito.kotlin.times +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever + +@RunWith(AndroidJUnit4::class) +class NonFatalAnrIntegrationTest { + + @get:Rule val tmpDir = TemporaryFolder() + + private val scopes = mock() + private val recorder = mock() + private lateinit var options: SentryAndroidOptions + private val marker by lazy { File(tmpDir.root, "last_non_fatal_anr") } + private var markerExistedAtCapture: Boolean? = null + + @BeforeTest + fun setup() { + SentryIntegrationPackageStorage.getInstance().clearStorage() + options = + SentryAndroidOptions().apply { + cacheDirPath = tmpDir.root.absolutePath + nonFatalAnrSampleRate = 1.0 + hangRecorder = recorder + } + whenever(scopes.captureEvent(any(), any())).thenAnswer { + markerExistedAtCapture = marker.exists() + SentryId() + } + } + + private fun frame(cls: String, method: String) = StackTraceElement(cls, method, "F.java", 1) + + private val systemStack = + arrayOf( + frame("java.lang.Object", "wait"), + frame("android.os.Handler", "dispatchMessage"), + frame("android.os.Looper", "loop"), + ) + + private fun record( + durationMs: Long = 1_000, + samples: List = + listOf( + AnrStackTrace(1_100, systemStack, Thread.State.RUNNABLE), + AnrStackTrace(1_200, systemStack, Thread.State.BLOCKED), + ), + ) = HangRecord.Builder(durationMs, 1_000).setSamples(samples).build() + + private fun subscribed(): HangRecorderListener { + val integration = NonFatalAnrIntegration() + integration.register(scopes, options) + val captor = argumentCaptor() + verify(recorder).subscribe(captor.capture()) + return captor.firstValue + } + + private fun capturedHint(): NonFatalAnrHint = + HintUtils.getSentrySdkHint(capturedEvent().second) as NonFatalAnrHint + + private fun capturedEvent(): Pair { + val event = argumentCaptor() + val hint = argumentCaptor() + verify(scopes).captureEvent(event.capture(), hint.capture()) + return event.firstValue to hint.firstValue + } + + @Test + fun `register subscribes when sampled`() { + subscribed() + + assertThat(SentryIntegrationPackageStorage.getInstance().integrations).contains("NonFatalAnr") + } + + @Test + fun `not sampled does not subscribe`() { + options.nonFatalAnrSampleRate = Double.MIN_VALUE + + NonFatalAnrIntegration().register(scopes, options) + + verify(recorder, never()).subscribe(any()) + } + + @Test + fun `disabled by default does not subscribe`() { + options.nonFatalAnrSampleRate = null + + NonFatalAnrIntegration().register(scopes, options) + + verify(recorder, never()).subscribe(any()) + } + + @Test + fun `anr disabled does not subscribe`() { + options.isAnrEnabled = false + + NonFatalAnrIntegration().register(scopes, options) + + verify(recorder, never()).subscribe(any()) + } + + @Test + fun `no recorder does not subscribe`() { + options.hangRecorder = null + + NonFatalAnrIntegration().register(scopes, options) + NonFatalAnrIntegration().close() + + assertThat(SentryIntegrationPackageStorage.getInstance().integrations) + .doesNotContain("NonFatalAnr") + } + + @Test + fun `close unsubscribes the subscribed listener once`() { + val integration = NonFatalAnrIntegration() + integration.register(scopes, options) + val captor = argumentCaptor() + verify(recorder).subscribe(captor.capture()) + + integration.close() + integration.close() + + verify(recorder, times(1)).unsubscribe(captor.firstValue) + } + + @Test + fun `record below threshold sends no event and writes no marker`() { + val listener = subscribed() + + listener.onHangRecorded(record(durationMs = 699)) + + verify(scopes, never()).captureEvent(any(), any()) + assertThat(marker.exists()).isFalse() + } + + @Test + fun `threshold is configurable`() { + options.nonFatalAnrThresholdMs = 2_000 + val listener = subscribed() + + listener.onHangRecorded(record(durationMs = 1_999)) + + verify(scopes, never()).captureEvent(any(), any()) + } + + @Test + fun `recovered hang shorter than 5 s writes no marker`() { + val listener = subscribed() + + listener.onHangRecorded(record(durationMs = 4_999)) + capturedHint().markFlushed() + + assertThat(marker.exists()).isFalse() + } + + @Test + fun `recovered hang of 5 s writes the marker only once the event is on disk`() { + val listener = subscribed() + + listener.onHangRecorded(record(durationMs = 5_000)) + + assertThat(markerExistedAtCapture).isFalse() + assertThat(marker.exists()).isFalse() + capturedHint().markFlushed() + val read = NonFatalAnrMarker.read(options)!! + assertThat(read.matches(android.os.Process.myPid(), 1_000)).isTrue() + assertThat(read.matches(android.os.Process.myPid(), 6_000 + 30_000)).isTrue() + assertThat(read.matches(android.os.Process.myPid(), 6_000 + 30_001)).isFalse() + } + + @Test + fun `record cut at maxRecordingTime writes the marker once the event is on disk`() { + val listener = subscribed() + + listener.onHangRecorded( + HangRecord.Builder(8_000, 1_000) + .setSamples(listOf(AnrStackTrace(1_100, systemStack))) + .setEndedAtMaxRecordingTime(true) + .build(), + ) + + assertThat(marker.exists()).isFalse() + capturedHint().markFlushed() + assertThat(NonFatalAnrMarker.read(options)!!.matches(android.os.Process.myPid(), 9_000)) + .isTrue() + } + + @Test + fun `marker is written once when the event is flushed twice`() { + val listener = subscribed() + listener.onHangRecorded(record(durationMs = 5_000)) + val hint = capturedHint() + hint.markFlushed() + marker.delete() + + hint.markFlushed() + + assertThat(marker.exists()).isFalse() + } + + @Test + fun `event has handled mechanism and no abnormal exit hint`() { + val listener = subscribed() + + listener.onHangRecorded(record()) + + val (event, hint) = capturedEvent() + val exception = event.exceptions!!.single() + assertThat(exception.mechanism!!.type).isEqualTo("NonFatalANR") + assertThat(exception.mechanism!!.isHandled).isTrue() + assertThat(exception.mechanism!!.data.orEmpty()).doesNotContainKey("abnormal_mechanism") + assertThat(event.level).isEqualTo(SentryLevel.ERROR) + assertThat(event.timestamp.time).isEqualTo(2_000) + val typeCheckHint = HintUtils.getSentrySdkHint(hint) + assertThat(typeCheckHint).isInstanceOf(NonFatalAnrHint::class.java) + assertThat(typeCheckHint).isNotInstanceOf(AbnormalExit::class.java) + } + + @Test + fun `no samples gives one exception without stack`() { + val listener = subscribed() + + listener.onHangRecorded(record(samples = emptyList())) + + val (event, _) = capturedEvent() + val exception = event.exceptions!!.single() + assertThat(exception.value).isEqualTo("Non-fatal ANR") + assertThat(exception.mechanism!!.type).isEqualTo("NonFatalANR") + assertThat(event.threads!!.single().state).isNull() + } + + @Test + fun `record cut at maxRecordingTime gives a hint with the main thread blocked`() { + val listener = subscribed() + + listener.onHangRecorded( + HangRecord.Builder(8_000, 1_000) + .setSamples(listOf(AnrStackTrace(1_100, systemStack))) + .setEndedAtMaxRecordingTime(true) + .build(), + ) + + val hint = HintUtils.getSentrySdkHint(capturedEvent().second) as NonFatalAnrHint + assertThat(hint.isMainThreadBlocked).isTrue() + } + + @Test + fun `record of a recovered hang gives a hint without the main thread blocked`() { + val listener = subscribed() + + listener.onHangRecorded(record()) + + val hint = HintUtils.getSentrySdkHint(capturedEvent().second) as NonFatalAnrHint + assertThat(hint.isMainThreadBlocked).isFalse() + } + + @Test + fun `main thread and culprit exceptions have the main thread id`() { + val mainThreadId = AndroidThreadChecker.getThreadId(Looper.getMainLooper().thread) + val listener = subscribed() + + listener.onHangRecorded(record()) + + val (event, _) = capturedEvent() + assertThat(event.threads!!.single().id).isEqualTo(mainThreadId) + assertThat(event.exceptions!!.map { it.threadId }).containsExactly(mainThreadId) + } + + @Test + fun `exception without samples has the main thread id`() { + val mainThreadId = AndroidThreadChecker.getThreadId(Looper.getMainLooper().thread) + val listener = subscribed() + + listener.onHangRecorded(record(samples = emptyList())) + + val (event, _) = capturedEvent() + assertThat(event.threads!!.single().id).isEqualTo(mainThreadId) + assertThat(event.exceptions!!.single().threadId).isEqualTo(mainThreadId) + } + + @Test + fun `system-frames-only culprit gets static fingerprint`() { + val listener = subscribed() + + listener.onHangRecorded(record()) + + val (event, _) = capturedEvent() + assertThat(event.fingerprints).containsExactly("system-frames-only-anr", "non-fatal-anr") + } + + @Test + fun `app frame culprit gets default fingerprint`() { + options.addInAppInclude("com.example") + val stack = arrayOf(frame("com.example.Foo", "bar"), frame("android.os.Looper", "loop")) + val listener = subscribed() + + listener.onHangRecorded(record(samples = listOf(AnrStackTrace(1_100, stack)))) + + val (event, _) = capturedEvent() + assertThat(event.fingerprints).containsExactly("{{ default }}", "non-fatal-anr").inOrder() + } + + @Test + fun `fingerprinting disabled gets default fingerprint`() { + options.isEnableAnrFingerprinting = false + val listener = subscribed() + + listener.onHangRecorded(record()) + + val (event, _) = capturedEvent() + assertThat(event.fingerprints).containsExactly("{{ default }}", "non-fatal-anr").inOrder() + } + + @Test + fun `main thread is current and has culprit thread state`() { + val listener = subscribed() + + listener.onHangRecorded(record()) + + val (event, _) = capturedEvent() + val thread = event.threads!!.single() + assertThat(thread.name).isEqualTo("main") + assertThat(thread.isCurrent).isTrue() + assertThat(thread.isMain).isTrue() + assertThat(thread.state).isEqualTo("BLOCKED") + assertThat(thread.stacktrace!!.frames).isNotEmpty() + } + + @Test + fun `thread state is taken from the last sample with the culprit stack`() { + val other = arrayOf(frame("java.lang.Thread", "sleep")) + val samples = + listOf( + AnrStackTrace(1_100, systemStack, Thread.State.RUNNABLE), + AnrStackTrace(1_200, systemStack, Thread.State.WAITING), + AnrStackTrace(1_300, other, Thread.State.TIMED_WAITING), + ) + val listener = subscribed() + + listener.onHangRecorded(record(samples = samples)) + + val (event, _) = capturedEvent() + assertThat(event.threads!!.single().state).isEqualTo("WAITING") + } + + @Test + fun `adds context with duration and sample count`() { + val listener = subscribed() + + listener.onHangRecorded(record()) + + val (event, _) = capturedEvent() + val context = event.contexts["non_fatal_anr"] as Map<*, *> + assertThat(context["duration_ms"]).isEqualTo(1_000L) + assertThat(context["sample_count"]).isEqualTo(2) + } + + @Test + fun `adds breadcrumb`() { + val listener = subscribed() + + listener.onHangRecorded(record()) + + val captor = argumentCaptor() + verify(scopes).addBreadcrumb(captor.capture()) + val breadcrumb = captor.firstValue + assertThat(breadcrumb.category).isEqualTo("anr") + assertThat(breadcrumb.type).isEqualTo("error") + assertThat(breadcrumb.level).isEqualTo(SentryLevel.WARNING) + assertThat(breadcrumb.message).isEqualTo("Non-fatal ANR") + assertThat(breadcrumb.data["duration_ms"]).isEqualTo(1_000L) + } +} 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 e33a62b08bf..0137f1ffd29 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 @@ -39,6 +39,7 @@ import io.sentry.SentryIntegrationPackageStorage import io.sentry.SentryLevel import io.sentry.TypeCheckHint.ANDROID_ACTIVITY import io.sentry.protocol.SentryException +import io.sentry.util.HintUtils import io.sentry.util.thread.IThreadChecker import java.io.File import kotlin.test.BeforeTest @@ -187,6 +188,32 @@ class ScreenshotEventProcessorTest { assertSame(fixture.activity, hint[ANDROID_ACTIVITY]) } + @Test + fun `non-fatal ANR with the main thread blocked gets no screenshot`() { + val sut = fixture.getSut(true) + val hint = HintUtils.createWithTypeCheckHint(NonFatalAnrHint(true, null)) + + CurrentActivityHolder.getInstance().setActivity(fixture.activity) + + val event = fixture.mainProcessor.process(getEvent(), hint) + sut.process(event, hint) + + assertNull(hint.screenshot) + } + + @Test + fun `non-fatal ANR without the main thread blocked gets a screenshot`() { + val sut = fixture.getSut(true) + val hint = HintUtils.createWithTypeCheckHint(NonFatalAnrHint(false, null)) + + CurrentActivityHolder.getInstance().setActivity(fixture.activity) + + val event = fixture.mainProcessor.process(getEvent(), hint) + sut.process(event, hint) + + assertNotNull(hint.screenshot) + } + @Test fun `when activity is destroyed, does nothing`() { val sut = fixture.getSut(true) diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt index 3b9b5f13a03..06af43c0c7d 100644 --- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt +++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt @@ -241,6 +241,29 @@ class SentryAndroidOptionsTest { sentryOptions.anrProfilingSampleRate = 2.0 } + @Test + fun `non fatal anr defaults`() { + val sentryOptions = SentryAndroidOptions() + + assertNull(sentryOptions.nonFatalAnrSampleRate) + assertEquals(700L, sentryOptions.nonFatalAnrThresholdMs) + } + + @Test(expected = IllegalArgumentException::class) + fun `non fatal anr rejects invalid sample rate`() { + SentryAndroidOptions().nonFatalAnrSampleRate = -0.1 + } + + @Test + fun `non fatal anr ignores a negative threshold`() { + val sentryOptions = SentryAndroidOptions() + sentryOptions.nonFatalAnrThresholdMs = 1_500 + + sentryOptions.nonFatalAnrThresholdMs = -1 + + assertEquals(1_500L, sentryOptions.nonFatalAnrThresholdMs) + } + @Test fun `app hang tracking is disabled by default with a 5s timeout`() { val sentryOptions = SentryAndroidOptions() 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 1396ae09e3c..369949be478 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 @@ -14,6 +14,7 @@ import io.sentry.SentryIntegrationPackageStorage import io.sentry.SentryLevel import io.sentry.TypeCheckHint import io.sentry.protocol.SentryException +import io.sentry.util.HintUtils import io.sentry.util.thread.IThreadChecker import java.io.Writer import kotlin.test.BeforeTest @@ -151,6 +152,32 @@ class ViewHierarchyEventProcessorTest { assertNotNull(hint.viewHierarchy) } + @Test + fun `non-fatal ANR with the main thread blocked gets no view hierarchy`() { + val (event, hint) = + fixture.process( + true, + SentryEvent().apply { exceptions = listOf(SentryException()) }, + HintUtils.createWithTypeCheckHint(NonFatalAnrHint(true, null)), + ) + + assertNotNull(event) + assertNull(hint.viewHierarchy) + } + + @Test + fun `non-fatal ANR without the main thread blocked gets a view hierarchy`() { + val (event, hint) = + fixture.process( + true, + SentryEvent().apply { exceptions = listOf(SentryException()) }, + HintUtils.createWithTypeCheckHint(NonFatalAnrHint(false, null)), + ) + + assertNotNull(event) + assertNotNull(hint.viewHierarchy) + } + @Test fun `when an event errored in the background, the view hierarchy should captured on the main thread`() { whenever(fixture.threadChecker.isMainThread).thenReturn(false) diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/anr/NonFatalAnrMarkerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/anr/NonFatalAnrMarkerTest.kt new file mode 100644 index 00000000000..67b3d15871f --- /dev/null +++ b/sentry-android-core/src/test/java/io/sentry/android/core/anr/NonFatalAnrMarkerTest.kt @@ -0,0 +1,91 @@ +package io.sentry.android.core.anr + +import com.google.common.truth.Truth.assertThat +import io.sentry.SentryOptions +import java.io.File +import kotlin.test.Test +import org.junit.Rule +import org.junit.rules.TemporaryFolder + +class NonFatalAnrMarkerTest { + + @get:Rule val tmpDir = TemporaryFolder() + + private val options by lazy { SentryOptions().apply { cacheDirPath = tmpDir.root.absolutePath } } + private val file by lazy { File(tmpDir.root, "last_non_fatal_anr") } + + @Test + fun `read returns null without a marker`() { + assertThat(NonFatalAnrMarker.read(options)).isNull() + } + + @Test + fun `read returns what was written`() { + NonFatalAnrMarker.write(options, 42, 1_000, 2_500) + + val marker = NonFatalAnrMarker.read(options)!! + + assertThat(marker.matches(42, 1_000)).isTrue() + assertThat(marker.matches(42, 2_500)).isTrue() + assertThat(marker.matches(43, 2_000)).isFalse() + } + + @Test + fun `write overwrites the previous marker`() { + NonFatalAnrMarker.write(options, 1, 1_000, 2_000) + NonFatalAnrMarker.write(options, 2, 5_000, 6_000) + + val marker = NonFatalAnrMarker.read(options)!! + + assertThat(marker.matches(2, 5_500)).isTrue() + assertThat(marker.matches(1, 1_500)).isFalse() + } + + @Test + fun `matches covers the window until 30 seconds after the end`() { + NonFatalAnrMarker.write(options, 7, 10_000, 12_000) + val marker = NonFatalAnrMarker.read(options)!! + + assertThat(marker.matches(7, 9_999)).isFalse() + assertThat(marker.matches(7, 10_000)).isTrue() + assertThat(marker.matches(7, 42_000)).isTrue() + assertThat(marker.matches(7, 42_001)).isFalse() + } + + @Test + fun `read returns null for a corrupt file`() { + file.writeBytes(byteArrayOf(0, 1, 2)) + + assertThat(NonFatalAnrMarker.read(options)).isNull() + } + + @Test + fun `read returns null for an unknown version`() { + NonFatalAnrMarker.write(options, 1, 1_000, 2_000) + val bytes = file.readBytes() + bytes[1] = 99 + file.writeBytes(bytes) + + assertThat(NonFatalAnrMarker.read(options)).isNull() + } + + @Test + fun `delete removes the marker`() { + NonFatalAnrMarker.write(options, 1, 1_000, 2_000) + + NonFatalAnrMarker.delete(options) + + assertThat(file.exists()).isFalse() + assertThat(NonFatalAnrMarker.read(options)).isNull() + } + + @Test + fun `write and read do nothing without a cache dir`() { + options.cacheDirPath = null + + NonFatalAnrMarker.write(options, 1, 1_000, 2_000) + + assertThat(NonFatalAnrMarker.read(options)).isNull() + NonFatalAnrMarker.delete(options) + } +}