feat: Add App Hangs tracking

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### Features
 
+- Add App Hangs tracking (#1906) 
 - Replace tracestate header with baggage (#1867)
 
 ### Fixes

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

@@ -27,6 +27,9 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
             options.enableCoreDataTracking = true
             options.enableProfiling = true
             options.attachScreenshot = true
+            options.enableAppHangTracking = true
+            options.appHangTimeoutInterval = 2 
+            options.enableUserInteractionTracing = true
 
             // the benchmark test starts and stops a custom transaction using a UIButton, and automatic user interaction tracing stops the transaction that begins with that button press after the idle timeout elapses, stopping the profiler (only one profiler runs regardless of the number of concurrent transactions)
             if !ProcessInfo.processInfo.arguments.contains("--io.sentry.test.benchmarking") {

Sentry.xcodeproj/project.pbxproj

@@ -646,9 +646,11 @@
 		D880E3A728573E87008A90DB /* SentryBaggageTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D880E3A628573E87008A90DB /* SentryBaggageTests.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 /* SentryTraceContext.m in Sources */ = {isa = PBXBuildFile; fileRef = D88817D626D7149100BF2251 /* SentryTraceContext.m */; };
 		D88817DA26D72AB800BF2251 /* SentryTraceContext.h in Headers */ = {isa = PBXBuildFile; fileRef = D88817D926D72AB800BF2251 /* SentryTraceContext.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 */; };
@@ -1383,6 +1385,7 @@
 		D88817D626D7149100BF2251 /* SentryTraceContext.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryTraceContext.m; sourceTree = "<group>"; };
 		D88817D926D72AB800BF2251 /* SentryTraceContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SentryTraceContext.h; path = include/SentryTraceContext.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>"; };
@@ -1774,6 +1777,7 @@
 				7B4260332630315C00B36EDD /* SampleError.swift */,
 				7B6D1262265F7CC600C9BE4B /* PrivateSentrySDKOnlyTests.swift */,
 				8ED3D305264DFE700049393B /* SentryUIViewControllerSanitizerTests.swift */,
+				D8918B212849FA6D00701F9A /* SentrySDKIntegrationTestsBase.swift */,
 			);
 			path = SentryTests;
 			sourceTree = "<group>";
@@ -2918,6 +2922,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 */,
@@ -3499,6 +3504,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];
+
+    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