Merge cd1f4c2 into 0d66c0b

Author: markushi

CHANGELOG.md

@@ -23,6 +23,11 @@
     <meta-data android:name="io.sentry.screenshot.mask-all-text" android:value="true" />
     <meta-data android:name="io.sentry.screenshot.mask-all-images" android:value="true" />
     ```
+- Add new experimental option to capture profiles for ANRs ([#4899](https://github.com/getsentry/sentry-java/pull/4899))
+  - This feature will capture a stack profile of the main thread when it gets unresponsive
+  - The profile gets attached to the ANR event on the next app start, providing a flamegraph of the ANR issue on the sentry issue details page
+  - Breaking change: if the ANR stacktrace contains only system frames (e.g. `java.lang` or `android.os`), a static fingerprint is set on the ANR event, causing all ANR events to be grouped into a single issue, reducing the overall ANR issue noise
+  - Enable via `options.setEnableAnrProfiling(true)` or Android manifest: `<meta-data android:name="io.sentry.anr.profiling.enable" android:value="true" />`
 
 ### Fixes
 
@@ -144,7 +149,7 @@
 - Discard envelopes on `4xx` and `5xx` response ([#4950](https://github.com/getsentry/sentry-java/pull/4950))
   - This aims to not overwhelm Sentry after an outage or load shedding (including HTTP 429) where too many events are sent at once
 
-### Feature
+### Features
 
 - Add a Tombstone integration that detects native crashes without relying on the NDK integration, but instead using `ApplicationExitInfo.REASON_CRASH_NATIVE` on Android 12+. ([#4933](https://github.com/getsentry/sentry-java/pull/4933))
   - Currently exposed via options as an _internal_ API only.

sentry-android-core/api/sentry-android-core.api

@@ -365,6 +365,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun isCollectExternalStorageContext ()Z
 	public fun isEnableActivityLifecycleBreadcrumbs ()Z
 	public fun isEnableActivityLifecycleTracingAutoFinish ()Z
+	public fun isEnableAnrProfiling ()Z
 	public fun isEnableAppComponentBreadcrumbs ()Z
 	public fun isEnableAppLifecycleBreadcrumbs ()Z
 	public fun isEnableAutoActivityLifecycleTracing ()Z
@@ -393,6 +394,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun setDebugImagesLoader (Lio/sentry/android/core/IDebugImagesLoader;)V
 	public fun setEnableActivityLifecycleBreadcrumbs (Z)V
 	public fun setEnableActivityLifecycleTracingAutoFinish (Z)V
+	public fun setEnableAnrProfiling (Z)V
 	public fun setEnableAppComponentBreadcrumbs (Z)V
 	public fun setEnableAppLifecycleBreadcrumbs (Z)V
 	public fun setEnableAutoActivityLifecycleTracing (Z)V
@@ -553,6 +555,79 @@ public final class io/sentry/android/core/ViewHierarchyEventProcessor : io/sentr
 	public static fun snapshotViewHierarchyAsData (Landroid/app/Activity;Lio/sentry/util/thread/IThreadChecker;Lio/sentry/ISerializer;Lio/sentry/ILogger;)[B
 }
 
+public class io/sentry/android/core/anr/AggregatedStackTrace {
+	public fun <init> ([Ljava/lang/StackTraceElement;IIJF)V
+	public fun addOccurrence (J)V
+	public fun getStack ()[Ljava/lang/StackTraceElement;
+}
+
+public class io/sentry/android/core/anr/AnrCulpritIdentifier {
+	public fun <init> ()V
+	public static fun identify (Ljava/util/List;)Lio/sentry/android/core/anr/AggregatedStackTrace;
+	public static fun isSystemFrame (Ljava/lang/String;)Z
+}
+
+public class io/sentry/android/core/anr/AnrProfile {
+	public final field endTimeMs J
+	public final field stacks Ljava/util/List;
+	public final field startTimeMs J
+	public fun <init> (Ljava/util/List;)V
+}
+
+public class io/sentry/android/core/anr/AnrProfileManager : java/lang/AutoCloseable {
+	public fun <init> (Lio/sentry/SentryOptions;)V
+	public fun <init> (Lio/sentry/SentryOptions;Ljava/io/File;)V
+	public fun add (Lio/sentry/android/core/anr/AnrStackTrace;)V
+	public fun clear ()V
+	public fun close ()V
+	public fun load ()Lio/sentry/android/core/anr/AnrProfile;
+}
+
+public class io/sentry/android/core/anr/AnrProfileRotationHelper {
+	public fun <init> ()V
+	public static fun deleteLastFile (Ljava/io/File;)Z
+	public static fun getFileForRecording (Ljava/io/File;)Ljava/io/File;
+	public static fun getLastFile (Ljava/io/File;)Ljava/io/File;
+	public static fun rotate ()V
+}
+
+public class io/sentry/android/core/anr/AnrProfilingIntegration : io/sentry/Integration, io/sentry/android/core/AppState$AppStateListener, java/io/Closeable, java/lang/Runnable {
+	public static final field POLLING_INTERVAL_MS J
+	public static final field THRESHOLD_ANR_MS J
+	public fun <init> ()V
+	protected fun checkMainThread (Ljava/lang/Thread;)V
+	public fun close ()V
+	protected fun getProfileManager ()Lio/sentry/android/core/anr/AnrProfileManager;
+	protected fun getState ()Lio/sentry/android/core/anr/AnrProfilingIntegration$MainThreadState;
+	public fun onBackground ()V
+	public fun onForeground ()V
+	public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
+	public fun run ()V
+}
+
+protected final class io/sentry/android/core/anr/AnrProfilingIntegration$MainThreadState : java/lang/Enum {
+	public static final field ANR_DETECTED Lio/sentry/android/core/anr/AnrProfilingIntegration$MainThreadState;
+	public static final field IDLE Lio/sentry/android/core/anr/AnrProfilingIntegration$MainThreadState;
+	public static final field SUSPICIOUS Lio/sentry/android/core/anr/AnrProfilingIntegration$MainThreadState;
+	public static fun valueOf (Ljava/lang/String;)Lio/sentry/android/core/anr/AnrProfilingIntegration$MainThreadState;
+	public static fun values ()[Lio/sentry/android/core/anr/AnrProfilingIntegration$MainThreadState;
+}
+
+public final class io/sentry/android/core/anr/AnrStackTrace : java/lang/Comparable {
+	public final field stack [Ljava/lang/StackTraceElement;
+	public final field timestampMs J
+	public fun <init> (J[Ljava/lang/StackTraceElement;)V
+	public fun compareTo (Lio/sentry/android/core/anr/AnrStackTrace;)I
+	public synthetic fun compareTo (Ljava/lang/Object;)I
+	public static fun deserialize (Ljava/io/DataInputStream;)Lio/sentry/android/core/anr/AnrStackTrace;
+	public fun serialize (Ljava/io/DataOutputStream;)V
+}
+
+public final class io/sentry/android/core/anr/StackTraceConverter {
+	public fun <init> ()V
+	public static fun convert (Lio/sentry/android/core/anr/AnrProfile;)Lio/sentry/protocol/profiling/SentryProfile;
+}
+
 public final class io/sentry/android/core/cache/AndroidEnvelopeCache : io/sentry/cache/EnvelopeCache {
 	public static final field LAST_ANR_MARKER_LABEL Ljava/lang/String;
 	public static final field LAST_ANR_REPORT Ljava/lang/String;

sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java

@@ -26,6 +26,8 @@
 import io.sentry.SendFireAndForgetOutboxSender;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOpenTelemetryMode;
+import io.sentry.android.core.anr.AnrProfileRotationHelper;
+import io.sentry.android.core.anr.AnrProfilingIntegration;
 import io.sentry.android.core.cache.AndroidEnvelopeCache;
 import io.sentry.android.core.internal.debugmeta.AssetsDebugMetaLoader;
 import io.sentry.android.core.internal.gestures.AndroidViewGestureTargetLocator;
@@ -140,6 +142,8 @@ static void loadDefaultAndMetadataOptions(
             .getRuntimeManager()
             .runWithRelaxedPolicy(() -> getCacheDir(finalContext).getAbsolutePath()));
 
+    AnrProfileRotationHelper.rotate();
+
     readDefaultOptionValues(options, finalContext, buildInfoProvider);
     AppState.getInstance().registerLifecycleObserver(options);
   }
@@ -401,6 +405,8 @@ static void installDefaultIntegrations(
     // it to set the replayId in case of an ANR
     options.addIntegration(AnrIntegrationFactory.create(context, buildInfoProvider));
 
+    options.addIntegration(new AnrProfilingIntegration());
+
     // registerActivityLifecycleCallbacks is only available if Context is an AppContext
     if (context instanceof Application) {
       options.addIntegration(

sentry-android-core/src/main/java/io/sentry/android/core/AnrIntegration.java

@@ -139,11 +139,18 @@ void reportANR(
       message = "Background " + message;
     }
 
-    final ApplicationNotResponding error = new ApplicationNotResponding(message, anr.getThread());
+    final @Nullable Thread thread = anr.getThread();
+    final @NotNull ApplicationNotResponding error;
+    if (thread == null) {
+      error = new ApplicationNotResponding(message);
+    } else {
+      error = new ApplicationNotResponding(message, anr.getThread());
+    }
+
     final Mechanism mechanism = new Mechanism();
     mechanism.setType("ANR");
 
-    return new ExceptionMechanismException(mechanism, error, error.getThread(), true);
+    return new ExceptionMechanismException(mechanism, error, thread, true);
   }
 
   @TestOnly

sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java

@@ -29,16 +29,26 @@
 import io.sentry.Breadcrumb;
 import io.sentry.Hint;
 import io.sentry.IpAddressUtils;
+import io.sentry.ProfileChunk;
+import io.sentry.ProfileContext;
+import io.sentry.Sentry;
 import io.sentry.SentryBaseEvent;
 import io.sentry.SentryEvent;
 import io.sentry.SentryExceptionFactory;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
 import io.sentry.SentryStackTraceFactory;
 import io.sentry.SpanContext;
+import io.sentry.android.core.anr.AggregatedStackTrace;
+import io.sentry.android.core.anr.AnrCulpritIdentifier;
+import io.sentry.android.core.anr.AnrProfile;
+import io.sentry.android.core.anr.AnrProfileManager;
+import io.sentry.android.core.anr.AnrProfileRotationHelper;
+import io.sentry.android.core.anr.StackTraceConverter;
 import io.sentry.android.core.internal.util.CpuInfoUtils;
 import io.sentry.cache.PersistingOptionsObserver;
 import io.sentry.cache.PersistingScopeObserver;
+import io.sentry.exception.ExceptionMechanismException;
 import io.sentry.hints.AbnormalExit;
 import io.sentry.hints.Backfillable;
 import io.sentry.protocol.App;
@@ -50,10 +60,14 @@
 import io.sentry.protocol.OperatingSystem;
 import io.sentry.protocol.Request;
 import io.sentry.protocol.SdkVersion;
+import io.sentry.protocol.SentryException;
+import io.sentry.protocol.SentryId;
+import io.sentry.protocol.SentryStackFrame;
 import io.sentry.protocol.SentryStackTrace;
 import io.sentry.protocol.SentryThread;
 import io.sentry.protocol.SentryTransaction;
 import io.sentry.protocol.User;
+import io.sentry.protocol.profiling.SentryProfile;
 import io.sentry.util.HintUtils;
 import io.sentry.util.SentryRandom;
 import java.io.File;
@@ -700,16 +714,33 @@ public void applyPreEnrichment(
     public void applyPostEnrichment(
         @NotNull SentryEvent event, @NotNull Backfillable hint, @NotNull Object rawHint) {
       final boolean isBackgroundAnr = isBackgroundAnr(rawHint);
-      setAppForeground(event, !isBackgroundAnr);
+
+      if (options.isEnableAnrProfiling()) {
+        applyAnrProfile(event, hint, isBackgroundAnr);
+      }
+
       setDefaultAnrFingerprint(event, isBackgroundAnr);
+
+      // Set app foreground state
+      setAppForeground(event, !isBackgroundAnr);
     }
 
     private void setDefaultAnrFingerprint(
         final @NotNull SentryEvent event, final boolean isBackgroundAnr) {
       // sentry does not yet have a capability to provide default server-side fingerprint rules,
       // so we're doing this on the SDK side to group background and foreground ANRs separately
       // even if they have similar stacktraces.
-      if (event.getFingerprints() == null) {
+      if (event.getFingerprints() != null) {
+        return;
+      }
+
+      if (options.isEnableAnrProfiling() && hasOnlySystemFrames(event)) {
+        // If profiling did not identify any app frames, we want to statically group these events
+        // to avoid ANR noise due to {{ default }} stacktrace grouping
+        event.setFingerprints(
+            Arrays.asList(
+                "system-frames-only-anr", isBackgroundAnr ? "background-anr" : "foreground-anr"));
+      } else {
         event.setFingerprints(
             Arrays.asList("{{ default }}", isBackgroundAnr ? "background-anr" : "foreground-anr"));
       }
@@ -777,5 +808,145 @@ private void setAnrExceptions(
       event.setExceptions(
           sentryExceptionFactory.getSentryExceptionsFromThread(mainThread, mechanism, anr));
     }
+
+    private void applyAnrProfile(
+        @NotNull SentryEvent event, @NotNull Backfillable hint, boolean isBackgroundAnr) {
+
+      // Skip background ANRs (as profiling only runs in foreground)
+      if (isBackgroundAnr) {
+        return;
+      }
+
+      final String cacheDirPath = options.getCacheDirPath();
+      if (cacheDirPath == null) {
+        return;
+      }
+      final File cacheDir = new File(cacheDirPath);
+
+      if (!(hint instanceof AbnormalExit)) {
+        return;
+      }
+      final Long anrTimestampObj = ((AbnormalExit) hint).timestamp();
+      final long anrTimestamp;
+      if (anrTimestampObj != null) {
+        anrTimestamp = anrTimestampObj;
+      } else if (event.getTimestamp() != null) {
+        anrTimestamp = event.getTimestamp().getTime();
+      } else {
+        return;
+      }
+
+      AnrProfile anrProfile = null;
+      try {
+        final File lastFile = AnrProfileRotationHelper.getLastFile(cacheDir);
+        if (lastFile.exists()) {
+          options.getLogger().log(SentryLevel.DEBUG, "Reading ANR profile");
+          try (final AnrProfileManager provider = new AnrProfileManager(options, lastFile)) {
+            anrProfile = provider.load();
+          }
+        } else {
+          options.getLogger().log(SentryLevel.DEBUG, "No ANR profile file found");
+        }
+      } catch (Throwable t) {
+        options.getLogger().log(SentryLevel.INFO, "Could not retrieve ANR profile", t);
+      } finally {
+        if (!AnrProfileRotationHelper.deleteLastFile(cacheDir)) {
+          options.getLogger().log(SentryLevel.INFO, "Could not delete ANR profile file");
+        }
+      }
+
+      if (anrProfile == null) {
+        return;
+      }
+
+      options.getLogger().log(SentryLevel.INFO, "ANR profile found");
+      if (anrTimestamp < anrProfile.startTimeMs || anrTimestamp > anrProfile.endTimeMs) {
+        options.getLogger().log(SentryLevel.DEBUG, "ANR profile found, but doesn't match");
+        return;
+      }
+
+      final AggregatedStackTrace culprit = AnrCulpritIdentifier.identify(anrProfile.stacks);
+      if (culprit == null) {
+        return;
+      }
+
+      // Capture profile chunk
+      final @Nullable SentryId profilerId = captureAnrProfile(anrTimestamp, anrProfile);
+      final @NotNull StackTraceElement[] stack = culprit.getStack();
+
+      if (stack.length > 0) {
+        final StackTraceElement stackTraceElement = stack[0];
+        final String message =
+            stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName();
+        final ApplicationNotResponding exception = new ApplicationNotResponding(message);
+        exception.setStackTrace(stack);
+
+        final Mechanism mechanism = new Mechanism();
+        mechanism.setType("ANR");
+        final ExceptionMechanismException error =
+            new ExceptionMechanismException(mechanism, exception, null, false);
+
+        final @NotNull List<SentryException> sentryException =
+            sentryExceptionFactory.getSentryExceptions(error);
+
+        // Replace the original ANR exception with the profile-derived one,
+        // as we assume the profiling culprit identification is more valuable
+        // the event threads are kept as-is, so the original main thread stacktrace is still
+        // available
+        event.setExceptions(sentryException);
+
+        if (profilerId != null) {
+          event.getContexts().setProfile(new ProfileContext(profilerId));
+        }
+      }
+    }
+
+    @Nullable
+    private SentryId captureAnrProfile(final long anrTimestampMs, @NotNull AnrProfile anrProfile) {
+      final SentryProfile profile = StackTraceConverter.convert(anrProfile);
+      final ProfileChunk chunk =
+          new ProfileChunk(
+              new SentryId(),
+              new SentryId(),
+              null,
+              new HashMap<>(0),
+              anrTimestampMs / 1000.0d,
+              ProfileChunk.PLATFORM_JAVA,
+              options);
+      chunk.setSentryProfile(profile);
+
+      final SentryId profilerId = Sentry.getCurrentScopes().captureProfileChunk(chunk);
+      if (SentryId.EMPTY_ID.equals(profilerId)) {
+        return null;
+      } else {
+        return chunk.getProfilerId();
+      }
+    }
+
+    private boolean hasOnlySystemFrames(@NotNull SentryEvent event) {
+      final List<SentryException> exceptions = event.getExceptions();
+      if (exceptions == null || exceptions.isEmpty()) {
+        return false;
+      }
+
+      for (final SentryException exception : exceptions) {
+        final SentryStackTrace stacktrace = exception.getStacktrace();
+        if (stacktrace != null) {
+          final List<SentryStackFrame> frames = stacktrace.getFrames();
+          if (frames != null && !frames.isEmpty()) {
+            for (final SentryStackFrame frame : frames) {
+              if (frame.isInApp() != null && frame.isInApp()) {
+                return false;
+              }
+              final String module = frame.getModule();
+              if (module != null && !AnrCulpritIdentifier.isSystemFrame(module)) {
+                return false;
+              }
+            }
+          }
+        }
+      }
+      return true;
+    }
   }
 }