feat: Add flag stichAsyncCode (#1172)

Add stichAsyncCode to SentryOptions to be able to enable stitching stack traces
of async code together.

Fixes GH-1086

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- feat: Add flag stichAsyncCode (#1172)
 - feat: Support XCFramework for Carthage (#1175)
 - fix: Remove invalid excludes from `Package.swift` (#1169)
 

Sources/Sentry/Public/SentryOptions.h

@@ -134,6 +134,16 @@ NS_SWIFT_NAME(Options)
  */
 @property (nonatomic, assign) BOOL attachStacktrace;
 
+/**
+ * Attention: This is an experimental feature. Turning this feature on can have an impact on
+ * the grouping of your issues.
+ *
+ * When enabled, the SDK stitches stack traces of asynchronous code together.
+ *
+ * This feature is disabled by default.
+ */
+@property (nonatomic, assign) BOOL stitchAsyncCode;
+
 /**
  * Describes the Sentry SDK and its configuration used to capture and transmit an event.
  */

Sources/Sentry/SentryCrashAdapter.m

@@ -1,5 +1,6 @@
 #import "SentryCrashAdapter.h"
 #import "SentryCrash.h"
+#import "SentryHook.h"
 #import <Foundation/Foundation.h>
 #import <SentryCrashDebug.h>
 
@@ -30,6 +31,16 @@ - (BOOL)isBeingTraced
     return sentrycrashdebug_isBeingTraced();
 }
 
+- (void)installAsyncHooks
+{
+    sentrycrash_install_async_hooks();
+}
+
+- (void)deactivateAsyncHooks
+{
+    sentrycrash_deactivate_async_hooks();
+}
+
 @end
 
 NS_ASSUME_NONNULL_END

Sources/Sentry/SentryCrashIntegration.m

@@ -4,7 +4,6 @@
 #import "SentryDispatchQueueWrapper.h"
 #import "SentryEvent.h"
 #import "SentryFrameInAppLogic.h"
-#import "SentryHook.h"
 #import "SentryHub.h"
 #import "SentryOutOfMemoryLogic.h"
 #import "SentrySDK+Private.h"
@@ -37,20 +36,20 @@ @implementation SentryCrashIntegration
 
 - (instancetype)init
 {
-    if (self = [super init]) {
-        self.crashAdapter = [SentryCrashAdapter sharedInstance];
-        self.dispatchQueueWrapper = [[SentryDispatchQueueWrapper alloc] init];
-    }
+    self = [self initWithCrashAdapter:[SentryCrashAdapter sharedInstance]
+              andDispatchQueueWrapper:[[SentryDispatchQueueWrapper alloc] init]];
+
     return self;
 }
 
 /** Internal constructor for testing */
 - (instancetype)initWithCrashAdapter:(SentryCrashAdapter *)crashAdapter
              andDispatchQueueWrapper:(SentryDispatchQueueWrapper *)dispatchQueueWrapper
 {
-    self = [self init];
-    self.crashAdapter = crashAdapter;
-    self.dispatchQueueWrapper = dispatchQueueWrapper;
+    if (self = [super init]) {
+        self.crashAdapter = crashAdapter;
+        self.dispatchQueueWrapper = dispatchQueueWrapper;
+    }
 
     return self;
 }
@@ -88,8 +87,11 @@ - (void)installWithOptions:(nonnull SentryOptions *)options
                                                  outOfMemoryLogic:logic];
 
     [self startCrashHandler];
-    // TODO: enable with feature flag from SentryOptions because this is still experimental
-    //    sentrycrash_install_async_hooks();
+
+    if (options.stitchAsyncCode) {
+        [self.crashAdapter installAsyncHooks];
+    }
+
     [self configureScope];
 }
 
@@ -136,7 +138,7 @@ - (void)uninstall
         installation = nil;
         installationToken = 0;
     }
-    sentrycrash_deactivate_async_hooks();
+    [self.crashAdapter deactivateAsyncHooks];
 }
 
 - (void)configureScope

Sources/Sentry/SentryOptions.m

@@ -41,6 +41,7 @@ - (instancetype)init
         self.enableOutOfMemoryTracking = YES;
         self.sessionTrackingIntervalMillis = [@30000 unsignedIntValue];
         self.attachStacktrace = YES;
+        self.stitchAsyncCode = NO;
         self.maxAttachmentSize = 20 * 1024 * 1024;
         self.sendDefaultPii = NO;
         self.enableAutoUIPerformanceTracking = YES;
@@ -197,6 +198,10 @@ - (void)validateOptions:(NSDictionary<NSString *, id> *)options
         self.attachStacktrace = [options[@"attachStacktrace"] boolValue];
     }
 
+    if (nil != options[@"stitchAsyncCode"]) {
+        self.stitchAsyncCode = [options[@"stitchAsyncCode"] boolValue];
+    }
+
     if (nil != options[@"maxAttachmentSize"]) {
         self.maxAttachmentSize = [options[@"maxAttachmentSize"] unsignedIntValue];
     }

Sources/Sentry/include/SentryCrashAdapter.h

@@ -16,6 +16,10 @@ SENTRY_NO_INIT
 
 - (BOOL)isBeingTraced;
 
+- (void)installAsyncHooks;
+
+- (void)deactivateAsyncHooks;
+
 @end
 
 NS_ASSUME_NONNULL_END

Tests/SentryTests/Integrations/SentryCrashIntegrationTests.swift

@@ -7,33 +7,30 @@ class SentryCrashIntegrationTests: XCTestCase {
 
     private class Fixture {
 
-        var session: SentrySession {
-            let session = SentrySession(releaseName: "1.0.0")
-            session.incrementErrors()
-
-            return session
-        }
-
         let currentDateProvider = TestCurrentDateProvider()
         let dispatchQueueWrapper = TestSentryDispatchQueueWrapper()
+        let hub: SentryHub
+        let options: Options
+        let sentryCrash: TestSentryCrashAdapter
 
-        var options: Options {
-            let options = Options()
-            options.dsn = SentryCrashIntegrationTests.dsnAsString
-            options.releaseName = TestData.appState.releaseName
-            return options
-        }
-
-        var sentryCrash: TestSentryCrashAdapter {
-            let sentryCrash = TestSentryCrashAdapter.sharedInstance()
+        init() {
+            sentryCrash = TestSentryCrashAdapter.sharedInstance()
             sentryCrash.internalActiveDurationSinceLastCrash = 5.0
             sentryCrash.internalCrashedLastLaunch = true
-            return sentryCrash
+
+            options = Options()
+            options.dsn = SentryCrashIntegrationTests.dsnAsString
+            options.releaseName = TestData.appState.releaseName
+
+            let client = Client(options: options)
+            hub = TestHub(client: client, andScope: nil)
         }
 
-        var hub: SentryHub {
-            let client = Client(options: options)
-            return TestHub(client: client, andScope: nil)
+        var session: SentrySession {
+            let session = SentrySession(releaseName: "1.0.0")
+            session.incrementErrors()
+
+            return session
         }
 
         var fileManager: SentryFileManager {
@@ -172,6 +169,32 @@ class SentryCrashIntegrationTests: XCTestCase {
         XCTAssertNil(fileManager.readCrashedSession())
     }
 
+    func testInstall_WhenStitchAsyncCallsEnabled_CallsInstallAsyncHooks() {
+        let sut = fixture.getSut()
+
+        let options = Options()
+        options.stitchAsyncCode = true
+        sut.install(with: options)
+
+        XCTAssertTrue(fixture.sentryCrash.installAsyncHooksCalled)
+    }
+
+    func testInstall_WhenStitchAsyncCallsDisabled_DoesNotCallInstallAsyncHooks() {
+        fixture.getSut().install(with: Options())
+
+        XCTAssertFalse(fixture.sentryCrash.installAsyncHooksCalled)
+    }
+
+    func testUninstall_CallsDeactivateAsyncHooks() {
+        let sut = fixture.getSut()
+
+        sut.install(with: Options())
+
+        sut.uninstall()
+
+        XCTAssertTrue(fixture.sentryCrash.deactivateAsyncHooksCalled)
+    }
+
     func testOSCorrectlySetToScopeContext() {
         let hub = fixture.hub
         SentrySDK.setCurrentHub(hub)

Tests/SentryTests/SentryCrash/TestSentryCrashAdapter.h

@@ -17,6 +17,10 @@ SENTRY_NO_INIT
 
 @property (nonatomic, assign) BOOL internalIsBeingTraced;
 
+@property (nonatomic, assign) BOOL installAsyncHooksCalled;
+
+@property (nonatomic, assign) BOOL deactivateAsyncHooksCalled;
+
 @end
 
 NS_ASSUME_NONNULL_END

Tests/SentryTests/SentryCrash/TestSentryCrashAdapter.m

@@ -9,6 +9,8 @@ + (instancetype)sharedInstance
     instance.internalActiveDurationSinceLastCrash = NO;
     instance.internalActiveDurationSinceLastCrash = 0;
     instance.internalIsBeingTraced = NO;
+    instance.installAsyncHooksCalled = NO;
+    instance.deactivateAsyncHooksCalled = NO;
     return instance;
 }
 
@@ -27,4 +29,14 @@ - (BOOL)isBeingTraced
     return self.internalIsBeingTraced;
 }
 
+- (void)installAsyncHooks
+{
+    self.installAsyncHooksCalled = YES;
+}
+
+- (void)deactivateAsyncHooks
+{
+    self.deactivateAsyncHooksCalled = YES;
+}
+
 @end

Tests/SentryTests/SentryOptionsTest.m

@@ -401,6 +401,24 @@ - (void)testInvalidAttachStackTrace
     XCTAssertEqual(NO, options.attachStacktrace);
 }
 
+- (void)testStitchAsyncCodeDisabledPerDefault
+{
+    SentryOptions *options = [self getValidOptions:@{}];
+    XCTAssertEqual(NO, options.stitchAsyncCode);
+}
+
+- (void)testStitchAsyncCodeEnabled
+{
+    SentryOptions *options = [self getValidOptions:@{ @"stitchAsyncCode" : @YES }];
+    XCTAssertEqual(YES, options.stitchAsyncCode);
+}
+
+- (void)testInvalidStitchAsyncCode
+{
+    SentryOptions *options = [self getValidOptions:@{ @"stitchAsyncCode" : @"Invalid" }];
+    XCTAssertEqual(NO, options.stitchAsyncCode);
+}
+
 - (void)testEmptyConstructorSetsDefaultValues
 {
     SentryOptions *options = [[SentryOptions alloc] init];
@@ -418,6 +436,7 @@ - (void)testEmptyConstructorSetsDefaultValues
     XCTAssertEqual(YES, options.enableOutOfMemoryTracking);
     XCTAssertEqual([@30000 unsignedIntValue], options.sessionTrackingIntervalMillis);
     XCTAssertEqual(YES, options.attachStacktrace);
+    XCTAssertEqual(NO, options.stitchAsyncCode);
     XCTAssertEqual(20 * 1024 * 1024, options.maxAttachmentSize);
     XCTAssertTrue(options.enableAutoUIPerformanceTracking);
 }