feat: Add App Hangs tracking

Sources/Sentry/Public/SentryThread.h

@@ -34,6 +34,11 @@ SENTRY_NO_INIT
  */
 @property (nonatomic, copy) NSNumber *_Nullable current;
 
+/**
+ * The thread from which this SentryThread extracted its information
+ */
+@property (nonatomic) uintptr_t thread;
+
 /**
  * Initializes a SentryThread with its id
  * @param threadId NSNumber

Sources/Sentry/SentryANRTracker.m

@@ -46,7 +46,7 @@ - (instancetype)initWithTimeoutInterval:(NSTimeInterval)timeoutInterval
 
 - (void)detectANRs
 {
-    NSThread.currentThread.name = @"io.sentry.anr-tracker";
+    NSThread.currentThread.name = @"io.sentry.app-hang-tracker";
 
     self.thread = NSThread.currentThread;
 

Sources/Sentry/SentryANRTrackingIntegration.m

@@ -77,17 +77,31 @@ - (void)uninstall
 
 - (void)anrDetected
 {
+    SentryThreadInspector *threadInspector = SentrySDK.currentHub.getClient.threadInspector;
+
     NSString *message = [NSString stringWithFormat:@"App hanging for at least %li ms.",
                                   (long)(self.options.appHangTimeoutInterval * 1000)];
 
-    NSArray<SentryThread *> *threads =
-        [SentrySDK.currentHub.getClient.threadInspector getCurrentThreadsWithStackTrace:YES];
+    NSArray<SentryThread *> *threads = [threadInspector getCurrentThreadsWithStackTrace:YES];
 
     SentryEvent *event = [[SentryEvent alloc] initWithLevel:kSentryLevelError];
     SentryException *sentryException = [[SentryException alloc] initWithValue:message
                                                                          type:@"App Hanging"];
     sentryException.mechanism = [[SentryMechanism alloc] initWithType:@"AppHang"];
-    sentryException.stacktrace = threads[0].stacktrace;
+
+    SentryThread *mainThread;
+
+    for (SentryThread *sentryThread in threads) {
+        if ([threadInspector isMainThread:sentryThread.thread]) {
+            sentryThread.current = @YES;
+            mainThread = sentryThread;
+        } else {
+            sentryThread.current = @NO;
+        }
+    }
+
+    sentryException.stacktrace = [mainThread stacktrace];
+
     event.exceptions = @[ sentryException ];
     event.threads = threads;
 

Sources/Sentry/SentryThreadInspector.m

@@ -3,6 +3,9 @@
 #import "SentryStacktrace.h"
 #import "SentryStacktraceBuilder.h"
 #import "SentryThread.h"
+#include <pthread.h>
+
+SentryCrashThread mainThreadID;
 
 @interface
 SentryThreadInspector ()
@@ -14,6 +17,11 @@
 
 @implementation SentryThreadInspector
 
++ (void)initialize
+{
+    mainThreadID = pthread_mach_thread_np(pthread_self());
+}
+
 - (id)initWithStacktraceBuilder:(SentryStacktraceBuilder *)stacktraceBuilder
        andMachineContextWrapper:(id<SentryCrashMachineContextWrapper>)machineContextWrapper
 {
@@ -47,14 +55,14 @@ - (id)initWithStacktraceBuilder:(SentryStacktraceBuilder *)stacktraceBuilder
     for (int i = 0; i < threadCount; i++) {
         SentryCrashThread thread = [self.machineContextWrapper getThread:context withIndex:i];
         SentryThread *sentryThread = [[SentryThread alloc] initWithThreadId:@(i)];
+        sentryThread.thread = thread;
 
         sentryThread.name = [self getThreadName:thread];
 
         sentryThread.crashed = @NO;
         bool isCurrent = thread == sentrycrashthread_self();
         sentryThread.current = @(isCurrent);
 
-        // For now we can only retrieve the stack trace of the current thread.
         if (isCurrent) {
             sentryThread.stacktrace = [self.stacktraceBuilder buildStacktraceForCurrentThread];
         } else if (getAllStacktraces) {
@@ -84,4 +92,9 @@ - (NSString *)getThreadName:(SentryCrashThread)thread
     return threadName;
 }
 
+- (BOOL)isMainThread:(SentryCrashThread)thread
+{
+    return thread == mainThreadID;
+}
+
 @end

Sources/Sentry/include/SentryThreadInspector.h

@@ -19,6 +19,8 @@ SENTRY_NO_INIT
 - (NSArray<SentryThread *> *)getCurrentThreads;
 
 - (NSArray<SentryThread *> *)getCurrentThreadsWithStackTrace:(BOOL)getAllStacktraces;
+
+- (BOOL)isMainThread:(SentryCrashThread)thread;
 @end
 
 NS_ASSUME_NONNULL_END

Tests/SentryTests/Integrations/ANR/SentryANRTrackingIntegrationTests.swift

@@ -28,6 +28,7 @@ class SentryANRTrackingIntegrationTests: SentrySDKIntegrationTestsBase {
 
     override func tearDown() {
         sut.uninstall()
+        clearTestState()
         super.tearDown()
     }
 
@@ -66,6 +67,7 @@ class SentryANRTrackingIntegrationTests: SentrySDKIntegrationTestsBase {
 
     func testANRDetected_EventCaptured() {
         givenInitializedTracker()
+        setUpThreadInspector()
 
         Dynamic(sut).anrDetected()
 
@@ -80,6 +82,8 @@ class SentryANRTrackingIntegrationTests: SentrySDKIntegrationTestsBase {
             XCTAssertEqual(ex.type, "App Hanging")
             XCTAssertEqual(ex.value, "App hanging for at least 4500 ms.")
             XCTAssertNotNil(ex.stacktrace)
+            XCTAssertEqual(ex.stacktrace?.frames.first?.function, "main")
+            XCTAssertTrue(event?.threads?[1].current?.boolValue ?? false)
 
             guard let threads = event?.threads else {
                 XCTFail("ANR Exception not found")
@@ -102,4 +106,32 @@ class SentryANRTrackingIntegrationTests: SentrySDKIntegrationTestsBase {
         sut = SentryANRTrackingIntegration()
         sut.install(with: self.options)
     }
+
+    private func setUpThreadInspector() {
+        let threadInspector = TestThreadInspector.instance
+        threadInspector.mainThread = 256
+
+        let frame1 = Sentry.Frame()
+        frame1.function = "Second_frame_function"
+
+        let thread1 = Sentry.Thread(threadId: 0)
+        thread1.thread = 245_432
+        thread1.stacktrace = Stacktrace(frames: [frame1], registers: [:])
+        thread1.current = true
+
+        let frame2 = Sentry.Frame()
+        frame2.function = "main"
+
+        let thread2 = Sentry.Thread(threadId: 1)
+        thread2.thread = 256
+        thread2.stacktrace = Stacktrace(frames: [frame2], registers: [:])
+        thread2.current = false
+
+        threadInspector.allThreds = [
+            thread1,
+            thread2
+        ]
+
+        SentrySDK.currentHub().getClient()?.threadInspector = threadInspector
+    }
 }

Tests/SentryTests/SentryCrash/TestThreadInspector.swift

@@ -2,6 +2,9 @@ import Foundation
 
 class TestThreadInspector: SentryThreadInspector {
 
+    var mainThread: SentryCrashThread?
+    var allThreds: [Sentry.Thread]?
+
     static var instance: TestThreadInspector {
         // We need something to pass to the super initializer, because the empty initializer has been marked unavailable.
         let inAppLogic = SentryInAppLogic(inAppIncludes: [], inAppExcludes: [])
@@ -11,7 +14,15 @@ class TestThreadInspector: SentryThreadInspector {
     }
 
     override func getCurrentThreads() -> [Sentry.Thread] {
-        return [TestData.thread]
+        return allThreds ?? [TestData.thread]
     }
 
+    override func getCurrentThreads(withStackTrace getAllStacktraces: Bool) -> [Sentry.Thread] {
+        return allThreds ?? [TestData.thread]
+    }
+
+    override func isMainThread(_ thread: SentryCrashThread) -> Bool {
+        return thread == mainThread
+    }
+
 }