Merge 0cd877d into 0eaac1e

Author: markushi

CHANGELOG.md

@@ -68,8 +68,13 @@
 - 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 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.enable-profiling" android:value="true" />`
 - 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.
   - If enabled alongside the NDK integration, crashes will be reported as two separate events. Users should enable only one; deduplication between both integrations will be added in a future release.

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

@@ -351,6 +351,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
@@ -379,6 +380,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
@@ -533,6 +535,84 @@ 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/AnrException : java/lang/Exception {
+	public fun <init> ()V
+	public fun <init> (Ljava/lang/String;)V
+}
+
+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/io/Closeable {
+	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);
   }
@@ -399,6 +403,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/AnrV2Integration.java

@@ -12,9 +12,20 @@
 import io.sentry.ILogger;
 import io.sentry.IScopes;
 import io.sentry.Integration;
+import io.sentry.ProfileChunk;
+import io.sentry.ProfileContext;
 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.AnrCulpritIdentifier;
+import io.sentry.android.core.anr.AnrException;
+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.cache.AndroidEnvelopeCache;
 import io.sentry.android.core.internal.threaddump.Lines;
 import io.sentry.android.core.internal.threaddump.ThreadDumpParser;
@@ -24,8 +35,12 @@
 import io.sentry.protocol.DebugImage;
 import io.sentry.protocol.DebugMeta;
 import io.sentry.protocol.Message;
+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.profiling.SentryProfile;
 import io.sentry.transport.CurrentDateProvider;
 import io.sentry.transport.ICurrentDateProvider;
 import io.sentry.util.HintUtils;
@@ -34,9 +49,12 @@
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.Closeable;
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
@@ -86,7 +104,11 @@ public void register(@NotNull IScopes scopes, @NotNull SentryOptions options) {
             .getExecutorService()
             .submit(
                 new ApplicationExitInfoHistoryDispatcher(
-                    context, scopes, this.options, dateProvider, new AnrV2Policy(this.options)));
+                    context,
+                    scopes,
+                    this.options,
+                    dateProvider,
+                    new AnrV2Policy(scopes, this.options)));
       } catch (Throwable e) {
         options.getLogger().log(SentryLevel.DEBUG, "Failed to start ANR processor.", e);
       }
@@ -105,9 +127,11 @@ public void close() throws IOException {
   private static final class AnrV2Policy
       implements ApplicationExitInfoHistoryDispatcher.ApplicationExitInfoPolicy {
 
+    private final @NotNull IScopes scopes;
     private final @NotNull SentryAndroidOptions options;
 
-    AnrV2Policy(final @NotNull SentryAndroidOptions options) {
+    AnrV2Policy(final @NotNull IScopes scopes, final @NotNull SentryAndroidOptions options) {
+      this.scopes = scopes;
       this.options = options;
     }
 
@@ -183,9 +207,111 @@ public boolean shouldReportHistorical() {
         }
       }
 
+      if (options.isEnableAnrProfiling()) {
+        applyAnrProfile(isBackground, anrTimestamp, event);
+        // TODO: maybe move to AnrV2EventProcessor instead
+        if (hasOnlySystemFrames(event)) {
+          // By omitting the {{ default }} fingerprint, the stacktrace will be completely ignored
+          // and all events will be grouped
+          // into the same issue
+          event.setFingerprints(
+              Arrays.asList(
+                  "{{ system-frames-only-anr }}",
+                  isBackground ? "background-anr" : "foreground-anr"));
+        }
+      }
+
       return new ApplicationExitInfoHistoryDispatcher.Report(event, hint, anrHint);
     }
 
+    private void applyAnrProfile(
+        final boolean isBackground, final long anrTimestamp, final @NotNull SentryEvent event) {
+
+      // as of now AnrProfilingIntegration only generates profiles in foreground
+      if (isBackground) {
+        return;
+      }
+
+      final @Nullable String cacheDirPath = options.getCacheDirPath();
+      if (cacheDirPath == null) {
+        return;
+      }
+      final @NotNull File cacheDir = new File(cacheDirPath);
+
+      @Nullable 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) {
+        options.getLogger().log(SentryLevel.INFO, "ANR profile found");
+        if (anrTimestamp >= anrProfile.startTimeMs && anrTimestamp <= anrProfile.endtimeMs) {
+          final @Nullable AggregatedStackTrace culprit =
+              AnrCulpritIdentifier.identify(anrProfile.stacks);
+          if (culprit != null) {
+            final @Nullable SentryId profilerId = captureAnrProfile(anrTimestamp, anrProfile);
+
+            final @NotNull StackTraceElement[] stack = culprit.getStack();
+            if (stack.length > 0) {
+              final StackTraceElement stackTraceElement = culprit.getStack()[0];
+              final String message =
+                  stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName();
+              final AnrException exception = new AnrException(message);
+              exception.setStackTrace(stack);
+
+              // TODO should this be re-used from somewhere else?
+              final SentryExceptionFactory factory =
+                  new SentryExceptionFactory(new SentryStackTraceFactory(options));
+              event.setExceptions(factory.getSentryExceptions(exception));
+              if (profilerId != null) {
+                event.getContexts().setProfile(new ProfileContext(profilerId));
+              }
+            }
+          }
+        } else {
+          options.getLogger().log(SentryLevel.DEBUG, "ANR profile found, but doesn't match");
+        }
+      }
+    }
+
+    @Nullable
+    private SentryId captureAnrProfile(
+        final long anrTimestamp, final @NotNull AnrProfile anrProfile) {
+      final SentryProfile profile = StackTraceConverter.convert(anrProfile);
+      final ProfileChunk chunk =
+          new ProfileChunk(
+              new SentryId(),
+              new SentryId(),
+              null,
+              new HashMap<>(0),
+              anrTimestamp / 1000.0d,
+              ProfileChunk.PLATFORM_JAVA,
+              options);
+      chunk.setSentryProfile(profile);
+      final SentryId profilerId = scopes.captureProfileChunk(chunk);
+      if (profilerId.equals(SentryId.EMPTY_ID)) {
+        return null;
+      } else {
+        return chunk.getProfilerId();
+      }
+    }
+
     private @NotNull ParseResult parseThreadDump(
         final @NotNull ApplicationExitInfo exitInfo, final boolean isBackground) {
       final byte[] dump;
@@ -239,6 +365,33 @@ private byte[] getDumpBytes(final @NotNull InputStream trace) throws IOException
     }
   }
 
+  private static boolean hasOnlySystemFrames(final @NotNull SentryEvent event) {
+    final List<SentryException> exceptions = event.getExceptions();
+    if (exceptions == null || exceptions.isEmpty()) {
+      // No exceptions means we haven't verified frames - don't apply special fingerprinting
+      return false;
+    }
+
+    for (final SentryException exception : exceptions) {
+      final @Nullable SentryStackTrace stacktrace = exception.getStacktrace();
+      if (stacktrace != null) {
+        final @Nullable List<SentryStackFrame> frames = stacktrace.getFrames();
+        if (frames != null && !frames.isEmpty()) {
+          for (final SentryStackFrame frame : frames) {
+            if (frame.isInApp() != null && frame.isInApp()) {
+              return false;
+            }
+            final @Nullable String module = frame.getModule();
+            if (module != null && !AnrCulpritIdentifier.isSystemFrame(frame.getModule())) {
+              return false;
+            }
+          }
+        }
+      }
+    }
+    return true;
+  }
+
   @ApiStatus.Internal
   public static final class AnrV2Hint extends BlockingFlushHint
       implements Backfillable, AbnormalExit {

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

@@ -168,6 +168,8 @@ final class ManifestMetadataReader {
 
   static final String SPOTLIGHT_CONNECTION_URL = "io.sentry.spotlight.url";
 
+  static final String ENABLE_ANR_PROFILING = "io.sentry.anr.enable-profiling";
+
   /** ManifestMetadataReader ctor */
   private ManifestMetadataReader() {}
 
@@ -655,6 +657,9 @@ static void applyMetadata(
         if (spotlightUrl != null) {
           options.setSpotlightConnectionUrl(spotlightUrl);
         }
+
+        options.setEnableAnrProfiling(
+            readBool(metadata, logger, ENABLE_ANR_PROFILING, options.isEnableAnrProfiling()));
       }
       options
           .getLogger()