feat: Hang tracker updates

noahsmartin · noahsmartin · commit c7cfc400eb42 · 2025-09-22T15:19:07.000-04:00
diff --git a/Sentry.xcodeproj/project.pbxproj b/Sentry.xcodeproj/project.pbxproj
@@ -1116,6 +1116,8 @@
 		FAE2DABA2E1F318900262307 /* SentryProfilingSwiftHelpers.h in Headers */ = {isa = PBXBuildFile; fileRef = FAE2DAB92E1F318900262307 /* SentryProfilingSwiftHelpers.h */; };
 		FAE5798D2E7D9D4C00B710F9 /* SentrySysctl.swift in Sources */ = {isa = PBXBuildFile; fileRef = FAE579872E7D9D4900B710F9 /* SentrySysctl.swift */; };
 		FAE579C22E7DDDE700B710F9 /* SentryThreadWrapper.swift in Sources */ = {isa = PBXBuildFile; fileRef = FAE579BC2E7DDDE400B710F9 /* SentryThreadWrapper.swift */; };
+		FAE579D52E7F238100B710F9 /* HangTracker.swift in Sources */ = {isa = PBXBuildFile; fileRef = FAE579CF2E7F237A00B710F9 /* HangTracker.swift */; };
+		FAE57A3C2E81C55900B710F9 /* SentryWatchdogTerminationTrackingIntegrationSwift.swift in Sources */ = {isa = PBXBuildFile; fileRef = FAE57A362E81C54F00B710F9 /* SentryWatchdogTerminationTrackingIntegrationSwift.swift */; };
 		FAE579CC2E7DE14900B710F9 /* SentryFrameRemover.swift in Sources */ = {isa = PBXBuildFile; fileRef = FAE579C62E7DE14400B710F9 /* SentryFrameRemover.swift */; };
 		FAE80C242E4695B40010A595 /* SentryEvent+Serialize.h in Headers */ = {isa = PBXBuildFile; fileRef = FAE80C232E4695AE0010A595 /* SentryEvent+Serialize.h */; };
 		FAEC270E2DF3526000878871 /* SentryUserFeedback.swift in Sources */ = {isa = PBXBuildFile; fileRef = FAEC270D2DF3526000878871 /* SentryUserFeedback.swift */; };
@@ -2461,6 +2463,8 @@
 		FAE2DAB92E1F318900262307 /* SentryProfilingSwiftHelpers.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SentryProfilingSwiftHelpers.h; path = Sources/Sentry/include/SentryProfilingSwiftHelpers.h; sourceTree = SOURCE_ROOT; };
 		FAE579872E7D9D4900B710F9 /* SentrySysctl.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentrySysctl.swift; sourceTree = "<group>"; };
 		FAE579BC2E7DDDE400B710F9 /* SentryThreadWrapper.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryThreadWrapper.swift; sourceTree = "<group>"; };
+		FAE579CF2E7F237A00B710F9 /* HangTracker.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HangTracker.swift; sourceTree = "<group>"; };
+		FAE57A362E81C54F00B710F9 /* SentryWatchdogTerminationTrackingIntegrationSwift.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryWatchdogTerminationTrackingIntegrationSwift.swift; sourceTree = "<group>"; };
 		FAE579C62E7DE14400B710F9 /* SentryFrameRemover.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryFrameRemover.swift; sourceTree = "<group>"; };
 		FAE80C232E4695AE0010A595 /* SentryEvent+Serialize.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = "SentryEvent+Serialize.h"; path = "include/SentryEvent+Serialize.h"; sourceTree = "<group>"; };
 		FAEC270D2DF3526000878871 /* SentryUserFeedback.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryUserFeedback.swift; sourceTree = "<group>"; };
@@ -4232,6 +4236,7 @@
 		D452FCBC2DDB6FA800AFF56F /* WatchdogTerminations */ = {
 			isa = PBXGroup;
 			children = (
+				FAE57A362E81C54F00B710F9 /* SentryWatchdogTerminationTrackingIntegrationSwift.swift */,
 				D452FCBD2DDB6FC200AFF56F /* Processors */,
 			);
 			path = WatchdogTerminations;
@@ -4329,6 +4334,7 @@
 		D800942328F82E8D005D3943 /* Swift */ = {
 			isa = PBXGroup;
 			children = (
+				FAE579CF2E7F237A00B710F9 /* HangTracker.swift */,
 				F4FE9E062E6248BB0014FED5 /* SentryCrash */,
 				FABB48B22E59310D0071397E /* Transaction */,
 				FAAB29F02E3D252000ACD577 /* SentrySession.swift */,
@@ -5869,6 +5875,7 @@
 				FA01BCB22E69352A00968DFA /* SentryDiscardedEvent.swift in Sources */,
 				7BAF3DCE243DCBFE008A5414 /* SentryTransportFactory.m in Sources */,
 				F4E3DCCB2E1579240093CB80 /* SentryScopePersistentStore.swift in Sources */,
+				FAE57A3C2E81C55900B710F9 /* SentryWatchdogTerminationTrackingIntegrationSwift.swift in Sources */,
 				7D65260E237F649E00113EA2 /* SentryScope.m in Sources */,
 				D4EDF9842D0B2A210071E7B3 /* Data+SentryTracing.swift in Sources */,
 				84281C472A57905700EE88F2 /* SentrySample.m in Sources */,
@@ -5892,6 +5899,7 @@
 				0A2D8DA9289BC905008720F6 /* SentryViewHierarchyProvider.m in Sources */,
 				D84D2CDD2C2BF7370011AF8A /* SentryReplayEvent.swift in Sources */,
 				D8BC28CC2BFF78220054DA4D /* SentryRRWebTouchEvent.swift in Sources */,
+				FAE579D52E7F238100B710F9 /* HangTracker.swift in Sources */,
 				D452FC592DDB4B1700AFF56F /* SentryWatchdogTerminationBreadcrumbProcessor.m in Sources */,
 				FAE2DAB82E1F317900262307 /* SentryProfilingSwiftHelpers.m in Sources */,
 				8EA1ED0B2668F8C400E62B98 /* SentryUIViewControllerSwizzling.m in Sources */,
diff --git a/Sources/Sentry/SentryDependencyContainer.m b/Sources/Sentry/SentryDependencyContainer.m
@@ -141,6 +141,9 @@ - (instancetype)init
     if (self = [super init]) {
         isInitialializingDependencyContainer = YES;
 
+        _hangTracker = [[SentryHangTrackerObjcBridge alloc]
+            initWithDateProvider:SentryDependencies.dateProvider];
+
         _dispatchQueueWrapper = SentryDependencies.dispatchQueueWrapper;
         _random = [[SentryRandom alloc] init];
         _threadWrapper = [[SentryThreadWrapper alloc] init];
diff --git a/Sources/Sentry/SentryWatchdogTerminationTrackingIntegration.m b/Sources/Sentry/SentryWatchdogTerminationTrackingIntegration.m
@@ -18,12 +18,13 @@
 #    import <SentryWatchdogTerminationTracker.h>
 NS_ASSUME_NONNULL_BEGIN
 
-@interface SentryWatchdogTerminationTrackingIntegration () <SentryANRTrackerDelegate>
+@interface SentryWatchdogTerminationTrackingIntegration ()
 
 @property (nonatomic, strong) SentryWatchdogTerminationTracker *tracker;
-@property (nonatomic, strong) id<SentryANRTracker> anrTracker;
 @property (nullable, nonatomic, copy) NSString *testConfigurationFilePath;
 @property (nonatomic, strong) SentryAppStateManager *appStateManager;
+@property (nonatomic, strong) SentryWatchdogTerminationTrackingIntegrationSwift *swiftImpl;
+@property (nonatomic, strong) SentryDispatchQueueWrapper *queue;
 
 @end
 
@@ -36,6 +37,15 @@ - (instancetype)init
             = SentryDependencyContainer.sharedInstance.processInfoWrapper;
         self.testConfigurationFilePath
             = processInfoWrapper.environment[@"XCTestConfigurationFilePath"];
+        dispatch_queue_attr_t attributes = dispatch_queue_attr_make_with_qos_class(
+            DISPATCH_QUEUE_SERIAL, DISPATCH_QUEUE_PRIORITY_HIGH, 0);
+        self.queue = [[SentryDispatchQueueWrapper alloc]
+            initWithName:"io.sentry.watchdog-termination-tracker"
+              attributes:attributes];
+        self.swiftImpl = [[SentryWatchdogTerminationTrackingIntegrationSwift alloc]
+            initWithHangTracker:SentryDependencyContainer.sharedInstance.hangTracker
+            hangStarted:^{ [self hangStarted]; }
+            hangStopped:^{ [self hangStopped]; }];
     }
     return self;
 }
@@ -50,12 +60,6 @@ - (BOOL)installWithOptions:(SentryOptions *)options
         return NO;
     }
 
-    dispatch_queue_attr_t attributes = dispatch_queue_attr_make_with_qos_class(
-        DISPATCH_QUEUE_SERIAL, DISPATCH_QUEUE_PRIORITY_HIGH, 0);
-    SentryDispatchQueueWrapper *dispatchQueueWrapper =
-        [[SentryDispatchQueueWrapper alloc] initWithName:"io.sentry.watchdog-termination-tracker"
-                                              attributes:attributes];
-
     SentryFileManager *fileManager = [[[SentrySDKInternal currentHub] getClient] fileManager];
     SentryAppStateManager *appStateManager =
         [SentryDependencyContainer sharedInstance].appStateManager;
@@ -70,22 +74,12 @@ - (BOOL)installWithOptions:(SentryOptions *)options
     self.tracker = [[SentryWatchdogTerminationTracker alloc] initWithOptions:options
                                                     watchdogTerminationLogic:logic
                                                              appStateManager:appStateManager
-                                                        dispatchQueueWrapper:dispatchQueueWrapper
+                                                        dispatchQueueWrapper:self.queue
                                                                  fileManager:fileManager
                                                         scopePersistentStore:scopeStore];
 
     [self.tracker start];
-
-#    if SDK_V9
-    BOOL isV2Enabled = YES;
-#    else
-    BOOL isV2Enabled = options.enableAppHangTrackingV2;
-#    endif // SDK_V9
-
-    self.anrTracker =
-        [SentryDependencyContainer.sharedInstance getANRTracker:options.appHangTimeoutInterval
-                                                    isV2Enabled:isV2Enabled];
-    [self.anrTracker addListener:self];
+    [self.swiftImpl start];
 
     self.appStateManager = appStateManager;
 
@@ -125,19 +119,23 @@ - (void)uninstall
     if (nil != self.tracker) {
         [self.tracker stop];
     }
-    [self.anrTracker removeListener:self];
+    [self.swiftImpl stop];
 }
 
-- (void)anrDetectedWithType:(enum SentryANRType)type
+- (void)hangStarted
 {
-    [self.appStateManager
-        updateAppState:^(SentryAppState *appState) { appState.isANROngoing = YES; }];
+    [self.queue dispatchAsyncWithBlock:^{
+        [self.appStateManager
+            updateAppState:^(SentryAppState *appState) { appState.isANROngoing = YES; }];
+    }];
 }
 
-- (void)anrStoppedWithResult:(SentryANRStoppedResult *_Nullable)result
+- (void)hangStopped
 {
-    [self.appStateManager
-        updateAppState:^(SentryAppState *appState) { appState.isANROngoing = NO; }];
+    [self.queue dispatchAsyncWithBlock:^{
+        [self.appStateManager
+            updateAppState:^(SentryAppState *appState) { appState.isANROngoing = NO; }];
+    }];
 }
 
 @end
diff --git a/Sources/Sentry/include/HybridPublic/SentryDependencyContainer.h b/Sources/Sentry/include/HybridPublic/SentryDependencyContainer.h
@@ -25,6 +25,7 @@
 @class SentryOptions;
 @class SentrySessionTracker;
 @class SentryGlobalEventProcessor;
+@class SentryHangTrackerObjcBridge;
 
 @protocol SentryANRTracker;
 @protocol SentryRandomProtocol;
@@ -95,6 +96,7 @@ SENTRY_NO_INIT
 @property (nonatomic, strong) id<SentryRateLimits> rateLimits;
 @property (nonatomic, strong) id<SentryApplication> application;
 @property (nonatomic, strong) SentryThreadsafeApplication *threadsafeApplication;
+@property (nonatomic, strong) SentryHangTrackerObjcBridge *hangTracker;
 
 #if SENTRY_HAS_REACHABILITY
 @property (nonatomic, strong) SentryReachability *reachability;
diff --git a/Sources/Sentry/include/SentryPrivate.h b/Sources/Sentry/include/SentryPrivate.h
@@ -20,6 +20,7 @@
 
 // Headers that also import SentryDefines should be at the end of this list
 // otherwise it wont compile
+#import "SentryAppStateManager.h"
 #import "SentryAsyncLog.h"
 #import "SentryClient+Logs.h"
 #import "SentryCrash.h"
diff --git a/Sources/Swift/HangTracker.swift b/Sources/Swift/HangTracker.swift
@@ -0,0 +1,185 @@
+@_implementationOnly import _SentryPrivate
+#if canImport(UIKit) && !SENTRY_NO_UIKIT
+import UIKit
+#endif
+
+struct RunLoopIteration {
+    let startTime: TimeInterval
+    let endTime: TimeInterval
+}
+
+protocol HangTrackerProtocol {
+    // The callback must be called on a background thread, because the main thread is blocked
+    func addLateRunLoopObserver(handler: @escaping (UUID, TimeInterval) -> Void) -> UUID
+    
+    func removeLateRunLoopObserver(id: UUID)
+
+    // The callback is always called on the main thread
+    func addFinishedRunLoopObserver(handler: @escaping (RunLoopIteration) -> Void) -> UUID
+    
+    func removeFinishedRunLoopObserver(id: UUID)
+}
+
+final class HangTracker: HangTrackerProtocol {
+
+    private let dateProvider: SentryCurrentDateProvider
+
+    init(
+        dateProvider: SentryCurrentDateProvider) {
+        self.dateProvider = dateProvider
+#if canImport(UIKit) && !SENTRY_NO_UIKIT && !os(visionOS) && !os(watchOS)
+        var maxFPS = 60.0
+        if #available(iOS 13.0, tvOS 13.0, *) {
+            let window = UIApplication.shared.connectedScenes.flatMap { ($0 as? UIWindowScene)?.windows ?? [] }.first { $0.isKeyWindow }
+            maxFPS = Double(window?.screen.maximumFramesPerSecond ?? 60)
+        } else {
+            maxFPS = Double(UIScreen.main.maximumFramesPerSecond)
+        }
+#else
+        let maxFPS: Double = 60.0
+        #endif
+        let expectedFrameDuration = 1.0 / maxFPS
+        hangNotifyThreshold = expectedFrameDuration * 1.5
+    }
+    
+    func addLateRunLoopObserver(handler: @escaping (UUID, TimeInterval) -> Void) -> UUID {
+        let id = UUID()
+        queue.async { [weak self] in
+            self?.lateRunLoop[id] = handler
+            DispatchQueue.main.async {
+                self?.startIfNecessary()
+            }
+        }
+        return id
+    }
+    
+    func removeLateRunLoopObserver(id: UUID) {
+        queue.async { [weak self] in
+            guard let self else { return }
+            lateRunLoop.removeValue(forKey: id)
+            if lateRunLoop.isEmpty {
+                DispatchQueue.main.async { [weak self] in
+                    if self?.finishedRunLoop.isEmpty ?? false {
+                        self?.stop()
+                    }
+                }
+            }
+        }
+    }
+    
+    func addFinishedRunLoopObserver(handler: @escaping (RunLoopIteration) -> Void) -> UUID {
+        let id = UUID()
+        finishedRunLoop[id] = handler
+        startIfNecessary()
+        return id
+    }
+    
+    func removeFinishedRunLoopObserver(id: UUID) {
+        finishedRunLoop.removeValue(forKey: id)
+        if finishedRunLoop.isEmpty {
+            queue.async { [weak self] in
+                if self?.lateRunLoop.isEmpty ?? false {
+                    DispatchQueue.main.async {
+                        if self?.finishedRunLoop.isEmpty ?? false {
+                            self?.stop()
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    // This queue is used to detect main thread hangs, they need to be detected on a background thread
+    // since the main thread is hanging.
+    private let queue = DispatchQueue(label: "io.sentry.runloop-observer-checker")
+    private let hangNotifyThreshold: TimeInterval
+    
+    // MARK: Main queue
+
+    private var observer: CFRunLoopObserver?
+    private var finishedRunLoop = [UUID: (RunLoopIteration) -> Void]()
+    private var semaphore: DispatchSemaphore?
+    private var loopStartTime: TimeInterval?
+    
+    private func startIfNecessary() {
+        guard observer == nil else {
+            // Already running
+            return
+        }
+
+        let observer = CFRunLoopObserverCreateWithHandler(nil, CFRunLoopActivity.beforeWaiting.rawValue | CFRunLoopActivity.afterWaiting.rawValue, true, CFIndex(INT_MAX)) { [weak self] _, activity in
+            guard let self else { return }
+
+            let currentTime = dateProvider.systemUptime()
+            switch activity {
+            case .beforeWaiting:
+                print("before")
+                semaphore?.signal()
+                if let loopStartTime {
+                    for handler in finishedRunLoop.values {
+                        handler(RunLoopIteration(startTime: loopStartTime, endTime: currentTime))
+                    }
+                }
+            case .afterWaiting:
+                print("after")
+                let started = currentTime
+                loopStartTime = currentTime
+                let localSemaphore = DispatchSemaphore(value: 0)
+                semaphore = localSemaphore
+                queue.async { [weak self] in
+                    self?.waitForHang(semaphore: localSemaphore, started: started, isStarting: true)
+                }
+            default:
+                fatalError()
+            }
+        }
+        self.observer = observer
+        CFRunLoopAddObserver(CFRunLoopGetMain(), observer, .commonModes)
+    }
+    
+    private func stop() {
+        dispatchPrecondition(condition: .onQueue(.main))
+
+        guard let observer else {
+            return
+        }
+        CFRunLoopRemoveObserver(CFRunLoopGetMain(), observer, .commonModes)
+        self.observer = nil
+    }
+    
+    // MARK: Background queue
+    
+    private var lateRunLoop = [UUID: (UUID, TimeInterval) -> Void]()
+    private var hangId = UUID()
+    
+    private func waitForHang(semaphore: DispatchSemaphore, started: TimeInterval, isStarting: Bool) {
+        dispatchPrecondition(condition: .onQueue(queue))
+        
+        let timeout = DispatchTime.now() + DispatchTimeInterval.milliseconds(Int(hangNotifyThreshold * 1_000))
+        let result = semaphore.wait(timeout: timeout)
+        switch result {
+        case .timedOut:
+            print("[HANG] Timeout, hang detected")
+            if isStarting {
+                hangId = UUID()
+            }
+            lateRunLoop.values.forEach { $0(hangId, dateProvider.systemUptime() - started) }
+            waitForHang(semaphore: semaphore, started: started, isStarting: false)
+        case .success:
+            break
+        }
+    }
+}
+
+@objc
+@_spi(Private) public final class SentryHangTrackerObjcBridge: NSObject {
+
+    let tracker: HangTracker
+
+    @objc public init(
+        dateProvider: SentryCurrentDateProvider,
+    ) {
+        tracker = HangTracker(
+            dateProvider: dateProvider)
+    }
+}
diff --git a/Sources/Swift/Integrations/WatchdogTerminations/SentryWatchdogTerminationTrackingIntegrationSwift.swift b/Sources/Swift/Integrations/WatchdogTerminations/SentryWatchdogTerminationTrackingIntegrationSwift.swift
