feat: Add App Hangs tracking

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### Features
 
+- feat: Add App Hangs tracking (#1861) 
 - Implement description for SentryBreadcrumb (#1880)
 
 ## 7.16.1

Samples/iOS-Swift/iOS-Swift/AppDelegate.swift

@@ -27,6 +27,8 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
             options.enableCoreDataTracking = true
             options.enableProfiling = true
             options.attachScreenshot = true
+            options.enableAppHangTracking = true
+            options.appHangTimeoutInterval = 2 
             options.enableUserInteractionTracing = true
         }
 

Sentry.xcodeproj/project.pbxproj

@@ -643,9 +643,11 @@
 		D875ED0B276CC84700422FAC /* SentryNSDataTrackerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D875ED0A276CC84700422FAC /* SentryNSDataTrackerTests.swift */; };
 		D884A20527C80F6300074664 /* SentryCoreDataTrackerTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = D884A20327C80F2700074664 /* SentryCoreDataTrackerTest.swift */; };
 		D885266427739D01001269FC /* SentryFileIOTrackingIntegrationTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D885266327739D01001269FC /* SentryFileIOTrackingIntegrationTests.swift */; };
+		D8853C842833EABC00700D64 /* SentryANRTracker.h in Headers */ = {isa = PBXBuildFile; fileRef = 7BCFA71427D0BAB7008C662C /* SentryANRTracker.h */; };
 		D88817D826D7149100BF2251 /* SentryTraceState.m in Sources */ = {isa = PBXBuildFile; fileRef = D88817D626D7149100BF2251 /* SentryTraceState.m */; };
 		D88817DA26D72AB800BF2251 /* SentryTraceState.h in Headers */ = {isa = PBXBuildFile; fileRef = D88817D926D72AB800BF2251 /* SentryTraceState.h */; };
 		D88817DD26D72BA500BF2251 /* SentryTraceStateTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D88817DB26D72B7B00BF2251 /* SentryTraceStateTests.swift */; };
+		D8918B222849FA6D00701F9A /* SentrySDKIntegrationTestsBase.swift in Sources */ = {isa = PBXBuildFile; fileRef = D8918B212849FA6D00701F9A /* SentrySDKIntegrationTestsBase.swift */; };
 		D8AB40DB2806EC1900E5E9F7 /* SentryScreenshotIntegration.h in Headers */ = {isa = PBXBuildFile; fileRef = D8AB40DA2806EC1900E5E9F7 /* SentryScreenshotIntegration.h */; };
 		D8ACE3C72762187200F5A213 /* SentryNSDataSwizzling.m in Sources */ = {isa = PBXBuildFile; fileRef = D8ACE3C42762187200F5A213 /* SentryNSDataSwizzling.m */; };
 		D8ACE3C82762187200F5A213 /* SentryNSDataTracker.m in Sources */ = {isa = PBXBuildFile; fileRef = D8ACE3C52762187200F5A213 /* SentryNSDataTracker.m */; };
@@ -1376,6 +1378,7 @@
 		D88817D626D7149100BF2251 /* SentryTraceState.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryTraceState.m; sourceTree = "<group>"; };
 		D88817D926D72AB800BF2251 /* SentryTraceState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SentryTraceState.h; path = include/SentryTraceState.h; sourceTree = "<group>"; };
 		D88817DB26D72B7B00BF2251 /* SentryTraceStateTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryTraceStateTests.swift; sourceTree = "<group>"; };
+		D8918B212849FA6D00701F9A /* SentrySDKIntegrationTestsBase.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentrySDKIntegrationTestsBase.swift; sourceTree = "<group>"; };
 		D8AB40DA2806EC1900E5E9F7 /* SentryScreenshotIntegration.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SentryScreenshotIntegration.h; path = include/SentryScreenshotIntegration.h; sourceTree = "<group>"; };
 		D8ACE3C42762187200F5A213 /* SentryNSDataSwizzling.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SentryNSDataSwizzling.m; sourceTree = "<group>"; };
 		D8ACE3C52762187200F5A213 /* SentryNSDataTracker.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SentryNSDataTracker.m; sourceTree = "<group>"; };
@@ -1766,6 +1769,7 @@
 				7B4260332630315C00B36EDD /* SampleError.swift */,
 				7B6D1262265F7CC600C9BE4B /* PrivateSentrySDKOnlyTests.swift */,
 				8ED3D305264DFE700049393B /* SentryUIViewControllerSanitizerTests.swift */,
+				D8918B212849FA6D00701F9A /* SentrySDKIntegrationTestsBase.swift */,
 			);
 			path = SentryTests;
 			sourceTree = "<group>";
@@ -2906,6 +2910,7 @@
 				7BE1E32824F7AE08009D3AD0 /* SentrySession+Private.h in Headers */,
 				7B5CAF7127F5953400ED0DB6 /* SentryEnvelope+Private.h in Headers */,
 				63FE713320DA4C1100CDBAE8 /* SentryCrashCPU.h in Headers */,
+				D8853C842833EABC00700D64 /* SentryANRTracker.h in Headers */,
 				63FE715B20DA4C1100CDBAE8 /* SentryCrashSignalInfo.h in Headers */,
 				63FE70E520DA4C1000CDBAE8 /* SentryCrashMonitor_CPPException.h in Headers */,
 				7B127B0D27CF6F2300A71ED2 /* SentryANRTrackingIntegration.h in Headers */,
@@ -3485,6 +3490,7 @@
 				7B59398224AB47650003AAD2 /* SentrySessionTrackerTests.swift in Sources */,
 				7B05A61824A4D14A00EF211D /* SentrySessionGeneratorTests.swift in Sources */,
 				63FE720920DA66EC00CDBAE8 /* XCTestCase+SentryCrash.m in Sources */,
+				D8918B222849FA6D00701F9A /* SentrySDKIntegrationTestsBase.swift in Sources */,
 				7B85BD8E24C5C3A6000A4225 /* SentryFileManagerTestExtension.swift in Sources */,
 				7B0002342477F52D0035FEF1 /* SentrySessionTests.swift in Sources */,
 			);

Sentry.xcodeproj/xcshareddata/xcschemes/Sentry.xcscheme

@@ -54,6 +54,11 @@
                BlueprintName = "SentryTests"
                ReferencedContainer = "container:Sentry.xcodeproj">
             </BuildableReference>
+            <SkippedTests>
+               <Test
+                  Identifier = "SentrySDKIntegrationTestsBase">
+               </Test>
+            </SkippedTests>
          </TestableReference>
       </Testables>
    </TestAction>

Sources/Sentry/Public/SentryOptions.h

@@ -328,6 +328,19 @@ NS_SWIFT_NAME(Options)
  */
 @property (nonatomic, assign) BOOL sendClientReports;
 
+/**
+ * When enabled, the SDK tracks when the application stops responding for a specific amount of
+ * time defined by the `appHangsTimeoutInterval` option.
+ */
+@property (nonatomic, assign) BOOL enableAppHangTracking;
+
+/**
+ * The minimum amount of time an app shoud be unresponsive to be classified as an App Hanging.
+ * The actual amount may be a little longer.
+ * Avoid using values lower than 100ms, which may cause a lot of app hangs events being transmitted.
+ */
+@property (nonatomic, assign) NSTimeInterval appHangTimeoutInterval;
+
 @end
 
 NS_ASSUME_NONNULL_END

Sources/Sentry/SentryANRTracker.m

@@ -6,50 +6,47 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-#if SENTRY_HAS_UIKIT
-
 @interface
 SentryANRTracker ()
 
-@property (weak, nonatomic) id<SentryANRTrackerDelegate> delegate;
-@property (nonatomic, assign) NSTimeInterval timeoutInterval;
 @property (nonatomic, strong) id<SentryCurrentDateProvider> currentDate;
 @property (nonatomic, strong) SentryCrashWrapper *crashWrapper;
 @property (nonatomic, strong) SentryDispatchQueueWrapper *dispatchQueueWrapper;
 @property (nonatomic, strong) SentryThreadWrapper *threadWrapper;
+@property (nonatomic, strong) NSMutableSet<id<SentryANRTrackerDelegate>> *listeners;
+@property (nonatomic, assign) NSTimeInterval timeoutInterval;
 
 @property (weak, nonatomic) NSThread *thread;
 
 @end
 
-@implementation SentryANRTracker
+@implementation SentryANRTracker {
+    NSObject *threadLock;
+    BOOL running;
+}
 
-- (instancetype)initWithDelegate:(id<SentryANRTrackerDelegate>)delegate
-           timeoutIntervalMillis:(NSUInteger)timeoutIntervalMillis
-             currentDateProvider:(id<SentryCurrentDateProvider>)currentDateProvider
-                    crashWrapper:(SentryCrashWrapper *)crashWrapper
-            dispatchQueueWrapper:(SentryDispatchQueueWrapper *)dispatchQueueWrapper
-                   threadWrapper:(SentryThreadWrapper *)threadWrapper
+- (instancetype)initWithTimeoutInterval:(NSTimeInterval)timeoutInterval
+                    currentDateProvider:(id<SentryCurrentDateProvider>)currentDateProvider
+                           crashWrapper:(SentryCrashWrapper *)crashWrapper
+                   dispatchQueueWrapper:(SentryDispatchQueueWrapper *)dispatchQueueWrapper
+                          threadWrapper:(SentryThreadWrapper *)threadWrapper
 {
     if (self = [super init]) {
-        self.delegate = delegate;
-        self.timeoutInterval = (double)timeoutIntervalMillis / 1000;
+        self.timeoutInterval = timeoutInterval;
         self.currentDate = currentDateProvider;
         self.crashWrapper = crashWrapper;
         self.dispatchQueueWrapper = dispatchQueueWrapper;
         self.threadWrapper = threadWrapper;
+        self.listeners = [NSMutableSet new];
+        threadLock = [[NSObject alloc] init];
+        running = false;
     }
     return self;
 }
 
-- (void)start
-{
-    [NSThread detachNewThreadSelector:@selector(detectANRs) toTarget:self withObject:nil];
-}
-
 - (void)detectANRs
 {
-    NSThread.currentThread.name = @"io.sentry.anr-tracker";
+    NSThread.currentThread.name = @"io.sentry.app-hang-tracker";
 
     self.thread = NSThread.currentThread;
 
@@ -68,7 +65,7 @@ - (void)detectANRs
         if (blockExecutedOnMainThread) {
             if (wasPreviousANR) {
                 [SentryLog logWithMessage:@"ANR stopped." andLevel:kSentryLevelWarning];
-                [self.delegate anrStopped];
+                [self ANRStopped];
             }
 
             wasPreviousANR = NO;
@@ -103,18 +100,85 @@ - (void)detectANRs
 
         wasPreviousANR = YES;
         [SentryLog logWithMessage:@"ANR detected." andLevel:kSentryLevelWarning];
-        [self.delegate anrDetected];
+        [self ANRDetected];
+    }
+}
+
+- (void)ANRDetected
+{
+    NSArray *localListeners;
+    @synchronized(self.listeners) {
+        localListeners = [self.listeners allObjects];
+    }
+
+    for (id<SentryANRTrackerDelegate> target in localListeners) {
+        [target anrDetected];
+    }
+}
+
+- (void)ANRStopped
+{
+    NSArray *targets;
+    @synchronized(self.listeners) {
+        targets = [self.listeners allObjects];
+    }
+
+    for (id<SentryANRTrackerDelegate> target in targets) {
+        [target anrStopped];
+    }
+}
+
+- (void)addListener:(id<SentryANRTrackerDelegate>)listener
+{
+    @synchronized(self.listeners) {
+        [self.listeners addObject:listener];
+
+        if (self.listeners.count > 0 && !running) {
+            @synchronized(threadLock) {
+                if (!running) {
+                    [self start];
+                }
+            }
+        }
+    }
+}
+
+- (void)removeListener:(id<SentryANRTrackerDelegate>)listener
+{
+    @synchronized(self.listeners) {
+        [self.listeners removeObject:listener];
+
+        if (self.listeners.count == 0) {
+            [self stop];
+        }
+    }
+}
+
+- (void)clear
+{
+    @synchronized(self.listeners) {
+        [self.listeners removeAllObjects];
+        [self stop];
+    }
+}
+
+- (void)start
+{
+    @synchronized(threadLock) {
+        [NSThread detachNewThreadSelector:@selector(detectANRs) toTarget:self withObject:nil];
+        running = YES;
     }
 }
 
 - (void)stop
 {
-    [SentryLog logWithMessage:@"Stopping ANR detection" andLevel:kSentryLevelInfo];
-    [self.thread cancel];
+    @synchronized(threadLock) {
+        [SentryLog logWithMessage:@"Stopping ANR detection" andLevel:kSentryLevelInfo];
+        [self.thread cancel];
+        running = NO;
+    }
 }
 
 @end
 
-#endif
-
 NS_ASSUME_NONNULL_END

Sources/Sentry/SentryANRTrackingIntegration.m

@@ -1,9 +1,18 @@
 #import "SentryANRTrackingIntegration.h"
 #import "SentryANRTracker.h"
+#import "SentryClient+Private.h"
+#import "SentryCrashMachineContext.h"
 #import "SentryCrashWrapper.h"
 #import "SentryDefaultCurrentDateProvider.h"
 #import "SentryDispatchQueueWrapper.h"
+#import "SentryEvent.h"
+#import "SentryException.h"
+#import "SentryHub+Private.h"
 #import "SentryLog.h"
+#import "SentryMechanism.h"
+#import "SentrySDK+Private.h"
+#import "SentryThread.h"
+#import "SentryThreadInspector.h"
 #import "SentryThreadWrapper.h"
 #import <Foundation/Foundation.h>
 #import <SentryAppState.h>
@@ -13,55 +22,48 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-#if SENTRY_HAS_UIKIT
-
-/**
- * As we only use the ANR tracking integration for detecting falsely reported OOMs we can use a more
- * defensive value, because we are not reporting any ANRs.
- */
-static NSUInteger const SENTRY_ANR_TRACKER_TIMEOUT_MILLIS = 2000;
-
 @interface
 SentryANRTrackingIntegration ()
 
 @property (nonatomic, strong) SentryANRTracker *tracker;
-@property (nonatomic, strong) SentryAppStateManager *appStateManager;
-@property (nonatomic, strong) SentryCrashWrapper *crashWrapper;
+@property (nonatomic, strong) SentryOptions *options;
 
 @end
 
 @implementation SentryANRTrackingIntegration
 
 - (void)installWithOptions:(SentryOptions *)options
 {
-    SentryDependencyContainer *dependencies = [SentryDependencyContainer sharedInstance];
-    self.crashWrapper = dependencies.crashWrapper;
-
     if ([self shouldBeDisabled:options]) {
         [options removeEnabledIntegration:NSStringFromClass([self class])];
         return;
     }
 
-    self.appStateManager = dependencies.appStateManager;
-
     self.tracker =
-        [[SentryANRTracker alloc] initWithDelegate:self
-                             timeoutIntervalMillis:SENTRY_ANR_TRACKER_TIMEOUT_MILLIS
-                               currentDateProvider:[SentryDefaultCurrentDateProvider sharedInstance]
-                                      crashWrapper:dependencies.crashWrapper
-                              dispatchQueueWrapper:[[SentryDispatchQueueWrapper alloc] init]
-                                     threadWrapper:dependencies.threadWrapper];
-    [self.tracker start];
+        [SentryDependencyContainer.sharedInstance getANRTracker:options.appHangTimeoutInterval];
+
+    [self.tracker addListener:self];
+    self.options = options;
 }
 
 - (BOOL)shouldBeDisabled:(SentryOptions *)options
 {
-    if (!options.enableOutOfMemoryTracking) {
+    if (!options.enableAppHangTracking) {
+        [SentryLog logWithMessage:@"Not going to enable App Hanging integration because "
+                                  @"enableAppHangsTracking is disabled."
+                         andLevel:kSentryLevelDebug];
+        return YES;
+    }
+
+    if (options.appHangTimeoutInterval == 0) {
+        [SentryLog logWithMessage:@"Not going to enable App Hanging integration because "
+                                  @"appHangsTimeoutInterval is 0."
+                         andLevel:kSentryLevelDebug];
         return YES;
     }
 
     // In case the debugger is attached
-    if ([self.crashWrapper isBeingTraced]) {
+    if ([SentryDependencyContainer.sharedInstance.crashWrapper isBeingTraced]) {
         return YES;
     }
 
@@ -70,23 +72,37 @@ - (BOOL)shouldBeDisabled:(SentryOptions *)options
 
 - (void)uninstall
 {
-    [self.tracker stop];
+    [self.tracker removeListener:self];
 }
 
 - (void)anrDetected
 {
-    [self.appStateManager
-        updateAppState:^(SentryAppState *appState) { appState.isANROngoing = YES; }];
+    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 = [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];
+    [threads enumerateObjectsUsingBlock:^(SentryThread *_Nonnull obj, NSUInteger idx,
+        BOOL *_Nonnull stop) { obj.current = [NSNumber numberWithBool:idx == 0]; }];
+
+    event.exceptions = @[ sentryException ];
+    event.threads = threads;
+
+    [SentrySDK captureEvent:event];
 }
 
 - (void)anrStopped
 {
-    [self.appStateManager
-        updateAppState:^(SentryAppState *appState) { appState.isANROngoing = NO; }];
+    // We dont report when an ANR ends.
 }
 
 @end
 
-#endif
-
 NS_ASSUME_NONNULL_END