feat(replay): add Hybrid SDKs Replay interface (#3879)

SentryTestUtils/TestOptions.swift

@@ -4,7 +4,7 @@ import Sentry
 public extension Options {
     func setIntegrations(_ integrations: [AnyClass]) {
         self.integrations = integrations.map {
-            String(describing: $0)
+            NSStringFromClass($0)
         }
     }
 

Sources/Sentry/PrivateSentrySDKOnly.mm

@@ -21,7 +21,10 @@
 #import <SentryBreadcrumb.h>
 #import <SentryDependencyContainer.h>
 #import <SentryFramesTracker.h>
+#import <SentryScope+Private.h>
 #import <SentryScreenshot.h>
+#import <SentrySessionReplay.h>
+#import <SentrySessionReplayIntegration.h>
 #import <SentryUser.h>
 
 @implementation PrivateSentrySDKOnly
@@ -238,4 +241,35 @@ + (SentryBreadcrumb *)breadcrumbWithDictionary:(NSDictionary *)dictionary
     return [[SentryBreadcrumb alloc] initWithDictionary:dictionary];
 }
 
++ (void)captureReplay
+{
+#if SENTRY_HAS_UIKIT && !TARGET_OS_VISION
+    if (@available(iOS 16.0, *)) {
+        NSArray *integrations = [[SentrySDK currentHub] installedIntegrations];
+        SentrySessionReplayIntegration *replayIntegration;
+        for (id obj in integrations) {
+            if ([obj isKindOfClass:[SentrySessionReplayIntegration class]]) {
+                replayIntegration = obj;
+                break;
+            }
+        }
+
+        [replayIntegration captureReplay];
+    }
+#else
+    SENTRY_LOG_DEBUG(
+        @"PrivateSentrySDKOnly.captureReplay only works with UIKit enabled and target is "
+        @"not visionOS. Ensure you're using the right configuration of Sentry that links UIKit.");
+#endif
+}
+
++ (NSString *__nullable)getReplayId
+{
+    __block NSString *__nullable replayId;
+
+    [SentrySDK configureScope:^(SentryScope *_Nonnull scope) { replayId = scope.replayId; }];
+
+    return replayId;
+}
+
 @end

Sources/Sentry/SentryHub.m

@@ -41,7 +41,6 @@
 @property (nullable, nonatomic, strong) SentryClient *client;
 @property (nullable, nonatomic, strong) SentryScope *scope;
 @property (nonatomic, strong) SentryCrashWrapper *crashWrapper;
-@property (nonatomic, strong) NSMutableArray<id<SentryIntegrationProtocol>> *installedIntegrations;
 @property (nonatomic, strong) NSMutableSet<NSString *> *installedIntegrationNames;
 @property (nonatomic) NSUInteger errorsBeforeSession;
 

Sources/Sentry/SentrySessionReplayIntegration.m

@@ -109,6 +109,11 @@ - (void)stop
     [self.sessionReplay stop];
 }
 
+- (void)captureReplay
+{
+    [self.sessionReplay captureReplay];
+}
+
 - (SentryIntegrationOption)integrationOptions
 {
     return kIntegrationOptionEnableReplay;

Sources/Sentry/include/HybridPublic/PrivateSentrySDKOnly.h

@@ -162,6 +162,9 @@ typedef void (^SentryOnAppStartMeasurementAvailable)(
 
 + (SentryBreadcrumb *)breadcrumbWithDictionary:(NSDictionary *)dictionary;
 
++ (void)captureReplay;
++ (NSString *__nullable)getReplayId;
+
 @end
 
 NS_ASSUME_NONNULL_END

Sources/Sentry/include/SentryHub+Private.h

@@ -21,6 +21,8 @@ SentryHub ()
 
 @property (nullable, nonatomic, strong) SentrySession *session;
 
+@property (nonatomic, strong) NSMutableArray<id<SentryIntegrationProtocol>> *installedIntegrations;
+
 /**
  * Every integration starts with "Sentry" and ends with "Integration". To keep the payload of the
  * event small we remove both.

Sources/Sentry/include/SentrySessionReplayIntegration.h

@@ -6,6 +6,11 @@ NS_ASSUME_NONNULL_BEGIN
 #if SENTRY_HAS_UIKIT && !TARGET_OS_VISION
 @interface SentrySessionReplayIntegration : SentryBaseIntegration
 
+/**
+ * Captures Replay. Used by the Hybrid SDKs.
+ */
+- (void)captureReplay;
+
 @end
 #endif // SENTRY_HAS_UIKIT && !TARGET_OS_VISION
 NS_ASSUME_NONNULL_END

Tests/SentryTests/PrivateSentrySDKOnlyTests.swift

@@ -82,17 +82,17 @@ class PrivateSentrySDKOnlyTests: XCTestCase {
         XCTAssertGreaterThan(images.count, 100)
     }
 
-#if SENTRY_HAS_UIKIT
+    #if canImport(UIKit)
     func testGetAppStartMeasurement() {
-        let appStartMeasurement = TestData.getAppStartMeasurement(type: .warm)
+        let appStartMeasurement = TestData.getAppStartMeasurement(type: .warm, runtimeInitSystemTimestamp: 1)
         SentrySDK.setAppStartMeasurement(appStartMeasurement)
 
         XCTAssertEqual(appStartMeasurement, PrivateSentrySDKOnly.appStartMeasurement)
 
         SentrySDK.setAppStartMeasurement(nil)
         XCTAssertNil(PrivateSentrySDKOnly.appStartMeasurement)
     }
-#endif // SENTRY_HAS_UIKIT
+    #endif
 
     func testGetInstallationId() {
         XCTAssertEqual(SentryInstallation.id(withCacheDirectoryPath: PrivateSentrySDKOnly.options.cacheDirectoryPath), PrivateSentrySDKOnly.installationID)
@@ -204,4 +204,53 @@ class PrivateSentrySDKOnlyTests: XCTestCase {
     }
 
     #endif
+
+    func testCaptureReplayShouldNotFailIfMissingReplayIntegration() {
+        PrivateSentrySDKOnly.captureReplay()
+    }
+
+    #if canImport(UIKit)
+    func testCaptureReplayShouldCallReplayIntegration() {
+        guard #available(iOS 16.0, tvOS 16.0, *) else { return }
+
+        let options = Options()
+        options.setIntegrations([SentrySessionReplayIntegrationTest.self])
+        SentrySDK.start(options: options)
+
+        PrivateSentrySDKOnly.captureReplay()
+
+        XCTAssertTrue(SentrySessionReplayIntegrationTest.captureReplayShouldBeCalledAtLeastOnce())
+    }
+
+    func testGetReplayIdShouldBeNil() {
+        XCTAssertNil(PrivateSentrySDKOnly.getReplayId())
+    }
+
+    func testGetReplayIdShouldExist() {
+        let client = TestClient(options: Options())
+        let scope = Scope()
+        scope.replayId = VALID_REPLAY_ID
+        SentrySDK.setCurrentHub(TestHub(client: client, andScope: scope))
+
+        XCTAssertEqual(PrivateSentrySDKOnly.getReplayId(), VALID_REPLAY_ID)
+    }
+
+    let VALID_REPLAY_ID = "0eac7ab503354dd5819b03e263627a29"
+
+    final class SentrySessionReplayIntegrationTest: SentrySessionReplayIntegration {
+        static var captureReplayCalledTimes = 0
+
+        override func install(with options: Options) -> Bool {
+            return true
+        }
+
+        override func captureReplay() {
+            SentrySessionReplayIntegrationTest.captureReplayCalledTimes += 1
+        }
+
+        static func captureReplayShouldBeCalledAtLeastOnce() -> Bool {
+            return captureReplayCalledTimes > 0
+        }
+    }
+    #endif
 }