Add options

Author: noahsmartin

Samples/SentrySampleShared/SentrySampleShared/SentrySDKWrapper.swift

@@ -43,7 +43,7 @@ public struct SentrySDKWrapper {
         }
         options.beforeCaptureScreenshot = { _ in !SentrySDKOverrides.Other.rejectScreenshots.boolValue }
         options.beforeCaptureViewHierarchy = { _ in !SentrySDKOverrides.Other.rejectViewHierarchy.boolValue }
-        options.debug = false // !SentrySDKOverrides.Special.disableDebugMode.boolValue
+        options.debug = !SentrySDKOverrides.Special.disableDebugMode.boolValue
 
 #if !os(macOS) && !os(watchOS) && !os(visionOS)
         if #available(iOS 16.0, *), !SentrySDKOverrides.SessionReplay.disableSessionReplay.boolValue {

Sentry.xcodeproj/project.pbxproj

@@ -1091,7 +1091,7 @@
 		FAB359982E05D7E90083D5E3 /* SentryEventSwiftHelper.h in Headers */ = {isa = PBXBuildFile; fileRef = FAB359972E05D7E90083D5E3 /* SentryEventSwiftHelper.h */; };
 		FAB3599A2E05D8080083D5E3 /* SentryEventSwiftHelper.m in Sources */ = {isa = PBXBuildFile; fileRef = FAB359992E05D8080083D5E3 /* SentryEventSwiftHelper.m */; };
 		FAC62B652E15A4100003909D /* SentrySDKThreadTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = FAC62B642E15A40C0003909D /* SentrySDKThreadTests.swift */; };
-		FAE2DABC2E1F55C500262307 /* RunloopObserver.swift in Sources */ = {isa = PBXBuildFile; fileRef = FAE2DABB2E1F55C100262307 /* RunloopObserver.swift */; };
+		FAE2DABC2E1F55C500262307 /* HangTracker.swift in Sources */ = {isa = PBXBuildFile; fileRef = FAE2DABB2E1F55C100262307 /* HangTracker.swift */; };
 		FAEC270E2DF3526000878871 /* SentryUserFeedback.swift in Sources */ = {isa = PBXBuildFile; fileRef = FAEC270D2DF3526000878871 /* SentryUserFeedback.swift */; };
 		FAEC273D2DF3933A00878871 /* NSData+Unzip.m in Sources */ = {isa = PBXBuildFile; fileRef = FAEC273C2DF3933200878871 /* NSData+Unzip.m */; };
 /* End PBXBuildFile section */
@@ -2362,7 +2362,7 @@
 		FAB359972E05D7E90083D5E3 /* SentryEventSwiftHelper.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SentryEventSwiftHelper.h; path = include/SentryEventSwiftHelper.h; sourceTree = "<group>"; };
 		FAB359992E05D8080083D5E3 /* SentryEventSwiftHelper.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryEventSwiftHelper.m; sourceTree = "<group>"; };
 		FAC62B642E15A40C0003909D /* SentrySDKThreadTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentrySDKThreadTests.swift; sourceTree = "<group>"; };
-		FAE2DABB2E1F55C100262307 /* RunloopObserver.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunloopObserver.swift; sourceTree = "<group>"; };
+		FAE2DABB2E1F55C100262307 /* HangTracker.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HangTracker.swift; sourceTree = "<group>"; };
 		FAEC270D2DF3526000878871 /* SentryUserFeedback.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryUserFeedback.swift; sourceTree = "<group>"; };
 		FAEC273C2DF3933200878871 /* NSData+Unzip.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "NSData+Unzip.m"; sourceTree = "<group>"; };
 		FAEC273E2DF393E000878871 /* NSData+Unzip.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "NSData+Unzip.h"; sourceTree = "<group>"; };
@@ -4165,7 +4165,7 @@
 		D800942328F82E8D005D3943 /* Swift */ = {
 			isa = PBXGroup;
 			children = (
-				FAE2DABB2E1F55C100262307 /* RunloopObserver.swift */,
+				FAE2DABB2E1F55C100262307 /* HangTracker.swift */,
 				FA67DCF32DDBD4EA00896B02 /* Core */,
 				D8CAC02D2BA0663E00E38F34 /* Integrations */,
 				621D9F2D2B9B030E003D94DE /* Helper */,
@@ -5543,7 +5543,7 @@
 				63FE70FD20DA4C1000CDBAE8 /* SentryCrashCachedData.c in Sources */,
 				A8F17B2E2901765900990B25 /* SentryRequest.m in Sources */,
 				7BE1E33424F7E3CB009D3AD0 /* SentryMigrateSessionInit.m in Sources */,
-				FAE2DABC2E1F55C500262307 /* RunloopObserver.swift in Sources */,
+				FAE2DABC2E1F55C500262307 /* HangTracker.swift in Sources */,
 				D80299502BA83A88000F0081 /* SentryPixelBuffer.swift in Sources */,
 				15E0A8F22411A45A00F044E3 /* SentrySession.m in Sources */,
 				844EDCE62947DC3100C86F34 /* SentryNSTimerFactory.m in Sources */,

Sources/Sentry/SentryDependencyContainer.m

@@ -262,14 +262,14 @@ - (SentryCrash *)crashReporter SENTRY_THREAD_SANITIZER_DOUBLE_CHECKED_LOCK
         [[SentryCrash alloc] initWithBasePath:SentrySDK.options.cacheDirectoryPath]);
 }
 
-- (RunLoopObserverObjcBridge *)observer SENTRY_THREAD_SANITIZER_DOUBLE_CHECKED_LOCK
+- (HangTrackerObjcBridge *)hangTracker SENTRY_THREAD_SANITIZER_DOUBLE_CHECKED_LOCK
 {
-    SENTRY_LAZY_INIT(_observer,
-        [[RunLoopObserverObjcBridge alloc] initWithDateProvider:self.dateProvider
-                                                threadInspector:self.threadInspector
-                                                debugImageCache:self.debugImageProvider
-                                                    fileManager:self.fileManager
-                                                   crashWrapper:self.crashWrapper]);
+    SENTRY_LAZY_INIT(_hangTracker,
+        [[HangTrackerObjcBridge alloc] initWithDateProvider:self.dateProvider
+                                            threadInspector:self.threadInspector
+                                            debugImageCache:self.debugImageProvider
+                                                fileManager:self.fileManager
+                                               crashWrapper:self.crashWrapper]);
 }
 
 - (id<SentryANRTracker>)getANRTracker:(NSTimeInterval)timeout

Sources/Sentry/SentrySDK.m

@@ -217,7 +217,6 @@ + (void)startWithOptions:(SentryOptions *)options
         NSLog(@"[SENTRY] [WARNING] SentrySDK not started. Running from Xcode preview.");
         return;
     }
-    [SentryDependencyContainer.sharedInstance.observer start];
 
     [SentrySDKLogSupport configure:options.debug diagnosticLevel:options.diagnosticLevel];
 
@@ -265,6 +264,10 @@ + (void)startWithOptions:(SentryOptions *)options
         [SentryCrashWrapper.sharedInstance startBinaryImageCache];
         [SentryDependencyContainer.sharedInstance.binaryImageCache start];
 
+        if (options.experimental.enableRunLoopObserverAppHangs) {
+            [SentryDependencyContainer.sharedInstance.hangTracker start];
+        }
+
         [SentrySDK installIntegrations];
 
 #if SENTRY_TARGET_PROFILING_SUPPORTED
@@ -580,20 +583,28 @@ + (void)reportFullyDisplayed
 
 + (void)pauseAppHangTracking
 {
-    SentryANRTrackingIntegration *anrTrackingIntegration
-        = (SentryANRTrackingIntegration *)[SentrySDK.currentHub
-            getInstalledIntegration:[SentryANRTrackingIntegration class]];
+    if (currentHub.client.options.experimental.enableRunLoopObserverAppHangs) {
+        [SentryDependencyContainer.sharedInstance.hangTracker stop];
+    } else {
+        SentryANRTrackingIntegration *anrTrackingIntegration
+            = (SentryANRTrackingIntegration *)[SentrySDK.currentHub
+                getInstalledIntegration:[SentryANRTrackingIntegration class]];
 
-    [anrTrackingIntegration pauseAppHangTracking];
+        [anrTrackingIntegration pauseAppHangTracking];
+    }
 }
 
 + (void)resumeAppHangTracking
 {
-    SentryANRTrackingIntegration *anrTrackingIntegration
-        = (SentryANRTrackingIntegration *)[SentrySDK.currentHub
-            getInstalledIntegration:[SentryANRTrackingIntegration class]];
+    if (currentHub.client.options.experimental.enableRunLoopObserverAppHangs) {
+        [SentryDependencyContainer.sharedInstance.hangTracker start];
+    } else {
+        SentryANRTrackingIntegration *anrTrackingIntegration
+            = (SentryANRTrackingIntegration *)[SentrySDK.currentHub
+                getInstalledIntegration:[SentryANRTrackingIntegration class]];
 
-    [anrTrackingIntegration resumeAppHangTracking];
+        [anrTrackingIntegration resumeAppHangTracking];
+    }
 }
 
 + (void)flush:(NSTimeInterval)timeout

Sources/Sentry/include/HybridPublic/SentryDependencyContainer.h

@@ -46,7 +46,7 @@
 @class SentryUIViewControllerPerformanceTracker;
 @class SentryWatchdogTerminationScopeObserver;
 @class SentryWatchdogTerminationAttributesProcessor;
-@class RunLoopObserverObjcBridge;
+@class HangTrackerObjcBridge;
 @class SentryWatchdogTerminationBreadcrumbProcessor;
 #endif // SENTRY_UIKIT_AVAILABLE
 
@@ -123,7 +123,7 @@ SENTRY_NO_INIT
 @property (nonatomic, strong) id<SentryDispatchQueueProviderProtocol> dispatchQueueProvider;
 @property (nonatomic, strong) SentryNSTimerFactory *timerFactory;
 
-@property (nonatomic, strong) RunLoopObserverObjcBridge *observer;
+@property (nonatomic, strong) HangTrackerObjcBridge *hangTracker;
 
 @property (nonatomic, strong) SentrySwizzleWrapper *swizzleWrapper;
 #if SENTRY_UIKIT_AVAILABLE

Sources/Sentry/include/SentryPrivate.h

@@ -28,6 +28,5 @@
 #import "SentrySession.h"
 #import "SentrySpanDataKey.h"
 #import "SentrySpanOperation.h"
-#import "SentryThreadInspector.h"
 #import "SentryTraceHeader.h"
 #import "SentryTraceOrigin.h"

Sources/Swift/RunloopObserver.swift renamed to Sources/Swift/HangTracker.swift

@@ -3,7 +3,21 @@
 import UIKit
 #endif
 
-final class RunLoopObserver {
+// A hang is parameterized by the its minimum duration, HangDuration, and is defined by a period of time lasting longer than HangDuration*2 when the delay
+// of all frames started during that time sums to more than HangDuration. If there is only one frame during this time that is delayed then it is a "fullyBlocking"
+// hang, otherwise it is a "nonFullyBlocking" hang.
+//
+// We measure late frames using a runloop observer. Any frame that is more than 50% delayed has its stacktrace sampled once, when we first detect it is delayed.
+// After the hang ends (or the app restarts in the case of fatal hangs) the most recently recorded stacktrace is used to report the hang. Since a hang is not one
+// stacktrace, like a crash, but rather a period of time, it would make sense to talk about a flamegraph sampled during the hang but the API does not support this.
+// Note that stacktraces are always sampled from a background thread, since it’s the main thread that gets sampled.
+//
+// There are two ways we trigger saving hang data. One is on the main thread, when the hang is over. When each frame finishes rendering we collect its delay and
+// if the sum of delays during the last HangDuration*2 is greather than the threshold, we report the last stack trace as a hang. The other way is on a background
+// thread. Once a frame is delayed more than 50% we sample the thread and start tracking it. If the total delay becomes more than our threshold the event
+// is recorded. If the hang never ends (thus transfering us back to the previous main thread case) then the hang is saved on the filesystem and
+// sent as a fatal hang the next time the app is launched.
+final class HangTracker {
 
     static let SentryANRMechanismDataAppHangDuration = "app_hang_duration"
 
@@ -40,7 +54,7 @@ final class RunLoopObserver {
         #endif
         expectedFrameDuration = 1.0 / maxFPS
         thresholdForFrameStacktrace = expectedFrameDuration * 0.5
-            captureStoredAppHang()
+        captureStoredAppHang()
     }
 
     // This queue is used to detect main thread hangs, they need to be detected on a background thread
@@ -52,6 +66,7 @@ final class RunLoopObserver {
 
     // MARK: Main queue
 
+    private var observer: CFRunLoopObserver?
     private var semaphore = DispatchSemaphore(value: 0)
     private var lastFrameTime: TimeInterval
     private var running = false
@@ -79,9 +94,16 @@ final class RunLoopObserver {
                 fatalError()
             }
         }
+        self.observer = observer
         CFRunLoopAddObserver(CFRunLoopGetMain(), observer, .commonModes)
     }
 
+    func stop() {
+        guard let observer else { return }
+
+        CFRunLoopRemoveObserver(CFRunLoopGetMain(), observer, .commonModes)
+    }
+    
     private func updateFrameStatistics() -> Double {
         dispatchPrecondition(condition: .onQueue(.main))
 
@@ -103,19 +125,19 @@ final class RunLoopObserver {
             let totalTime = frameStatistics.map({ $0.delayTime }).reduce(0, +)
             let type: SentryANRType = frameStatistics.count > 0 ? .nonFullyBlocking : .fullyBlocking
             if totalTime > minHangTime {
-                print("[HANG] Hang detected \(totalTime)")
+                SentrySDKLog.debug("Detected app hang for \(totalTime) seconds")
                 let maxTime = max(maxHangTime ?? 0, totalTime)
                 maxHangTime = maxTime
                 // Update on disk hang
                 queue.async { [weak self] in
                     guard let self, let threads = threads, !threads.isEmpty else { return }
-                    let event = makeEvent(duration: maxTime, threads: threads, type: type)
+                    let event = makeEvent(duration: maxTime, threads: threads, type: type, addMechanismData: true)
                     fileManager.storeAppHang(event)
                 }
             } else {
                 if let maxHangTime {
                     // The hang has ended
-                    print("[HANG] Hang reporting \(maxHangTime)")
+                    SentrySDKLog.debug("Reporting app hang with \(maxHangTime) seconds")
                     // Note: A non fully blocking hang always has multiple stacktraces
                     // because it is composed of multpile delayed frames. Each delayed frame has a stacktrace.
                     // We only support sending one stacktrace per event so we take the most recent one.
@@ -125,7 +147,7 @@ final class RunLoopObserver {
                     // overal hang event with just one stacktrace.
                     queue.async { [weak self] in
                         guard let self, let threads = threads, !threads.isEmpty else { return }
-                        let event = makeEvent(duration: maxHangTime, threads: threads, type: type)
+                        let event = makeEvent(duration: maxHangTime, threads: threads, type: type, addMechanismData: false)
                         SentrySDK.capture(event: event)
                     }
                 }
@@ -198,7 +220,7 @@ final class RunLoopObserver {
         dispatchPrecondition(condition: .onQueue(queue))
 
         if isStarting {
-            // A hang lasts a while, but we only support showing the stacktrace when it was first detected
+            // A hang lasts a while, we show the stacktrace when it was first detected
             threads = threadInspector.getCurrentThreadsWithStackTrace()
             threads?.forEach { $0.current = false }
             threads?[0].current = true
@@ -208,13 +230,13 @@ final class RunLoopObserver {
         if let threads, !threads.isEmpty, duration > minHangTime {
             // Hangs detected in the background are always fully blocking
             // Otherwise we'd be detecting them on the main thread.
-            fileManager.storeAppHang(makeEvent(duration: duration, threads: threads, type: .fullyBlocking))
+            fileManager.storeAppHang(makeEvent(duration: duration, threads: threads, type: .fullyBlocking, addMechanismData: true))
         }
 
     }
 
     // Safe to call from any thread
-    private func makeEvent(duration: TimeInterval, threads: [SentryThread], type: SentryANRType) -> Event {
+    private func makeEvent(duration: TimeInterval, threads: [SentryThread], type: SentryANRType, addMechanismData: Bool) -> Event {
         let event = Event()
         SentryLevelBridge.setBreadcrumbLevelOn(event, level: SentryLevel.error.rawValue)
         let exceptionType = SentryAppHangTypeMapper.getExceptionType(anrType: type)
@@ -223,7 +245,9 @@ final class RunLoopObserver {
         // We only temporarily store the app hang duration info, so we can change the error message
         // when either sending a normal or fatal app hang event. Otherwise, we would have to rely on
         // string parsing to retrieve the app hang duration info from the error message.
-        mechanism.data = [Self.SentryANRMechanismDataAppHangDuration: "\(duration) seconds"]
+        if addMechanismData {
+            mechanism.data = [Self.SentryANRMechanismDataAppHangDuration: "\(duration) seconds"]
+        }
         exception.mechanism = mechanism
         exception.stacktrace = threads[0].stacktrace
         exception.stacktrace?.snapshot = true
@@ -237,17 +261,17 @@ final class RunLoopObserver {
 }
 
 @objc
-@_spi(Private) public final class RunLoopObserverObjcBridge: NSObject {
+@_spi(Private) public final class HangTrackerObjcBridge: NSObject {
 
-    private let observer: RunLoopObserver
+    private let observer: HangTracker
 
     @objc public init(
         dateProvider: SentryCurrentDateProvider,
         threadInspector: ThreadInspector,
         debugImageCache: DebugImageCache,
         fileManager: SentryFileManager,
         crashWrapper: CrashWrapper) {
-        observer = RunLoopObserver(
+        observer = HangTracker(
             dateProvider: dateProvider,
             threadInspector: threadInspector,
             debugImageCache: debugImageCache,
@@ -259,6 +283,10 @@ final class RunLoopObserver {
     @objc public func start() {
         observer.start()
     }
+    
+    @objc public func stop() {
+        observer.stop()
+    }
 }
 
 @objc @_spi(Private) public protocol ThreadInspector {

Sources/Swift/SentryExperimentalOptions.swift

@@ -30,6 +30,8 @@ public class SentryExperimentalOptions: NSObject {
      * - Experiment: This is an experimental feature and is therefore disabled by default. We'll enable it by default in a future major release.
      */
     public var enableUnhandledCPPExceptionsV2 = false
+    
+    public var enableRunLoopObserverAppHangs = false
 
     @_spi(Private) public func validateOptions(_ options: [String: Any]?) {
     }