feat: iOS replay support

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Features
+
+- iOS Session Replay Alpha ([#2209](https://github.com/getsentry/sentry-dart/pull/2209))
+
 ## 8.6.0
 
 ### Improvements

flutter/ios/Classes/SentryFlutter.swift

@@ -70,6 +70,14 @@ public final class SentryFlutter {
         if let appHangTimeoutIntervalMillis = data["appHangTimeoutIntervalMillis"] as? NSNumber {
             options.appHangTimeoutInterval = appHangTimeoutIntervalMillis.doubleValue / 1000
         }
+#if canImport(UIKit) && !SENTRY_NO_UIKIT && (os(iOS) || os(tvOS))
+        if let replayOptions = data["replay"] as? [String: Any] {
+            options.experimental.sessionReplay.sessionSampleRate =
+                (replayOptions["sessionSampleRate"] as? NSNumber)?.floatValue ?? 0
+            options.experimental.sessionReplay.errorSampleRate =
+                (replayOptions["errorSampleRate"] as? NSNumber)?.floatValue ?? 0
+        }
+#endif
     }
 
     private func logLevelFrom(diagnosticLevel: String) -> SentryLevel {

flutter/ios/Classes/SentryFlutterPluginApple.swift

@@ -12,6 +12,7 @@ import CoreVideo
 
 // swiftlint:disable:next type_body_length
 public class SentryFlutterPluginApple: NSObject, FlutterPlugin {
+    private let channel: FlutterMethodChannel
 
     private static let nativeClientName = "sentry.cocoa.flutter"
 
@@ -38,12 +39,16 @@ public class SentryFlutterPluginApple: NSObject, FlutterPlugin {
         let channel = FlutterMethodChannel(name: "sentry_flutter", binaryMessenger: registrar.messenger)
 #endif
 
-        let instance = SentryFlutterPluginApple()
+        let instance = SentryFlutterPluginApple(channel: channel)
         instance.registerObserver()
-
         registrar.addMethodCallDelegate(instance, channel: channel)
     }
 
+    private init(channel: FlutterMethodChannel) {
+        self.channel = channel
+        super.init()
+    }
+
     private lazy var sentryFlutter = SentryFlutter()
 
     private func registerObserver() {
@@ -174,6 +179,14 @@ public class SentryFlutterPluginApple: NSObject, FlutterPlugin {
         case "resumeAppHangTracking":
             resumeAppHangTracking(result)
 
+        case "sendReplayForEvent":
+#if canImport(UIKit) && !SENTRY_NO_UIKIT && (os(iOS) || os(tvOS))
+            PrivateSentrySDKOnly.captureReplay()
+            result(PrivateSentrySDKOnly.getReplayId())
+#else
+            result(nil)
+#endif
+
         default:
             result(FlutterMethodNotImplemented)
         }
@@ -323,6 +336,14 @@ public class SentryFlutterPluginApple: NSObject, FlutterPlugin {
            didReceiveDidBecomeActiveNotification = false
        }
 
+#if canImport(UIKit) && !SENTRY_NO_UIKIT
+#if os(iOS) || os(tvOS)
+        let breadcrumbConverter = SentryFlutterReplayBreadcrumbConverter()
+        let screenshotProvider = SentryFlutterReplayScreenshotProvider(channel: self.channel)
+        PrivateSentrySDKOnly.configureSessionReplay(with: breadcrumbConverter, screenshotProvider: screenshotProvider)
+#endif
+#endif
+
         result("")
     }
 

flutter/ios/Classes/SentryFlutterReplayBreadcrumbConverter.h

@@ -0,0 +1,15 @@
+@import Sentry;
+
+#if SENTRY_TARGET_REPLAY_SUPPORTED
+@class SentryRRWebEvent;
+
+@interface SentryFlutterReplayBreadcrumbConverter
+    : NSObject <SentryReplayBreadcrumbConverter>
+
+- (instancetype _Nonnull)init;
+
+- (id<SentryRRWebEvent> _Nullable)convertFrom:
+    (SentryBreadcrumb *_Nonnull)breadcrumb;
+
+@end
+#endif

flutter/ios/Classes/SentryFlutterReplayBreadcrumbConverter.m

@@ -0,0 +1,117 @@
+#import "SentryFlutterReplayBreadcrumbConverter.h"
+
+@import Sentry;
+
+#if SENTRY_TARGET_REPLAY_SUPPORTED
+
+@implementation SentryFlutterReplayBreadcrumbConverter {
+  SentrySRDefaultBreadcrumbConverter *defaultConverter;
+}
+
+- (instancetype _Nonnull)init {
+  if (self = [super init]) {
+    self->defaultConverter =
+        [SentrySessionReplayIntegration createDefaultBreadcrumbConverter];
+  }
+  return self;
+}
+
+- (id<SentryRRWebEvent> _Nullable)convertFrom:
+    (SentryBreadcrumb *_Nonnull)breadcrumb {
+  assert(breadcrumb.timestamp != nil);
+
+  if (breadcrumb.category == nil
+      // Do not add Sentry Event breadcrumbs to replay
+      || [breadcrumb.category isEqualToString:@"sentry.event"] ||
+      [breadcrumb.category isEqualToString:@"sentry.transaction"]) {
+    return nil;
+  }
+
+  if ([breadcrumb.category isEqualToString:@"http"]) {
+    return [self convertNetwork:breadcrumb];
+  }
+
+  if ([breadcrumb.category isEqualToString:@"navigation"]) {
+    return [self convertFrom:breadcrumb withCategory:nil andMessage:nil];
+  }
+
+  if ([breadcrumb.category isEqualToString:@"ui.click"]) {
+    return [self convertFrom:breadcrumb
+                withCategory:@"ui.tap"
+                  andMessage:breadcrumb.data[@"path"]];
+  }
+
+  SentryRRWebEvent *nativeBreadcrumb =
+      [self->defaultConverter convertFrom:breadcrumb];
+
+  // ignore native navigation breadcrumbs
+  if (nativeBreadcrumb && nativeBreadcrumb.data &&
+      nativeBreadcrumb.data[@"payload"] &&
+      nativeBreadcrumb.data[@"payload"][@"category"] &&
+      [nativeBreadcrumb.data[@"payload"][@"category"]
+          isEqualToString:@"navigation"]) {
+    return nil;
+  }
+
+  return nativeBreadcrumb;
+}
+
+- (id<SentryRRWebEvent> _Nullable)convertFrom:
+                                      (SentryBreadcrumb *_Nonnull)breadcrumb
+                                 withCategory:(NSString *)category
+                                   andMessage:(NSString *)message {
+  return [SentrySessionReplayIntegration
+      createBreadcrumbwithTimestamp:breadcrumb.timestamp
+                           category:category ?: breadcrumb.category
+                            message:message ?: breadcrumb.message
+                              level:breadcrumb.level
+                               data:breadcrumb.data];
+}
+
+- (id<SentryRRWebEvent> _Nullable)convertNetwork:
+    (SentryBreadcrumb *_Nonnull)breadcrumb {
+  NSNumber *startTimestamp =
+      [breadcrumb.data[@"start_timestamp"] isKindOfClass:[NSNumber class]]
+          ? breadcrumb.data[@"start_timestamp"]
+          : nil;
+  NSNumber *endTimestamp =
+      [breadcrumb.data[@"end_timestamp"] isKindOfClass:[NSNumber class]]
+          ? breadcrumb.data[@"end_timestamp"]
+          : nil;
+  NSString *url = [breadcrumb.data[@"url"] isKindOfClass:[NSString class]]
+                      ? breadcrumb.data[@"url"]
+                      : nil;
+
+  if (startTimestamp == nil || endTimestamp == nil || url == nil) {
+    return nil;
+  }
+
+  NSMutableDictionary *data = [[NSMutableDictionary alloc] init];
+  if ([breadcrumb.data[@"method"] isKindOfClass:[NSString class]]) {
+    data[@"method"] = breadcrumb.data[@"method"];
+  }
+  if ([breadcrumb.data[@"status_code"] isKindOfClass:[NSNumber class]]) {
+    data[@"statusCode"] = breadcrumb.data[@"status_code"];
+  }
+  if ([breadcrumb.data[@"request_body_size"] isKindOfClass:[NSNumber class]]) {
+    data[@"requestBodySize"] = breadcrumb.data[@"request_body_size"];
+  }
+  if ([breadcrumb.data[@"response_body_size"] isKindOfClass:[NSNumber class]]) {
+    data[@"responseBodySize"] = breadcrumb.data[@"response_body_size"];
+  }
+
+  return [SentrySessionReplayIntegration
+      createNetworkBreadcrumbWithTimestamp:[self dateFrom:startTimestamp]
+                              endTimestamp:[self dateFrom:endTimestamp]
+                                 operation:@"resource.http"
+                               description:url
+                                      data:data];
+}
+
+- (NSDate *_Nonnull)dateFrom:(NSNumber *_Nonnull)timestamp {
+  return [NSDate dateWithTimeIntervalSince1970:(timestamp.doubleValue / 1000)];
+}
+
+@end
+
+#endif

flutter/ios/Classes/SentryFlutterReplayScreenshotProvider.h

@@ -0,0 +1,12 @@
+@import Sentry;
+
+#if SENTRY_TARGET_REPLAY_SUPPORTED
+@class SentryRRWebEvent;
+
+@interface SentryFlutterReplayScreenshotProvider
+    : NSObject <SentryViewScreenshotProvider>
+
+- (instancetype)initWithChannel:(id)FlutterMethodChannel;
+
+@end
+#endif

flutter/ios/Classes/SentryFlutterReplayScreenshotProvider.m

@@ -0,0 +1,46 @@
+@import Sentry;
+
+#if SENTRY_TARGET_REPLAY_SUPPORTED
+#import "SentryFlutterReplayScreenshotProvider.h"
+#import <Flutter/Flutter.h>
+
+@implementation SentryFlutterReplayScreenshotProvider {
+  FlutterMethodChannel *channel;
+}
+
+- (instancetype _Nonnull)initWithChannel:
+    (FlutterMethodChannel *_Nonnull)channel {
+  if (self = [super init]) {
+    self->channel = channel;
+  }
+  return self;
+}
+
+- (void)imageWithView:(UIView *_Nonnull)view
+              options:(id<SentryRedactOptions> _Nonnull)options
+           onComplete:(void (^_Nonnull)(UIImage *_Nonnull))onComplete {
+  [self->channel
+      invokeMethod:@"captureReplayScreenshot"
+         arguments:@{@"replayId" : [PrivateSentrySDKOnly getReplayId]}
+            result:^(id value) {
+              if (value == nil) {
+                NSLog(@"SentryFlutterReplayScreenshotProvider received null "
+                      @"result. "
+                      @"Cannot capture a replay screenshot.");
+              } else if ([value
+                             isKindOfClass:[FlutterStandardTypedData class]]) {
+                FlutterStandardTypedData *typedData =
+                    (FlutterStandardTypedData *)value;
+                UIImage *image = [UIImage imageWithData:typedData.data];
+                onComplete(image);
+              } else {
+                NSLog(@"SentryFlutterReplayScreenshotProvider received an "
+                      @"unexpected result. "
+                      @"Cannot capture a replay screenshot.");
+              }
+            }];
+}
+
+@end
+
+#endif

flutter/lib/src/native/cocoa/sentry_native_cocoa.dart

@@ -1,17 +1,76 @@
 import 'dart:ffi';
+import 'dart:typed_data';
+import 'dart:ui';
 
 import 'package:meta/meta.dart';
 
 import '../../../sentry_flutter.dart';
+import '../../event_processor/replay_event_processor.dart';
+import '../../replay/recorder.dart';
+import '../../replay/recorder_config.dart';
 import '../sentry_native_channel.dart';
 import 'binding.dart' as cocoa;
 
 @internal
 class SentryNativeCocoa extends SentryNativeChannel {
   late final _lib = cocoa.SentryCocoa(DynamicLibrary.process());
+  ScreenshotRecorder? _replayRecorder;
+  SentryId? _replayId;
 
   SentryNativeCocoa(super.options, super.channel);
 
+  @override
+  Future<void> init(Hub hub) async {
+    // We only need these when replay is enabled (session or error capture)
+    // so let's set it up conditionally. This allows Dart to trim the code.
+    if (options.experimental.replay.isEnabled &&
+        options.platformChecker.platform.isIOS) {
+      // We only need the integration when error-replay capture is enabled.
+      if ((options.experimental.replay.errorSampleRate ?? 0) > 0) {
+        options.addEventProcessor(ReplayEventProcessor(this));
+      }
+
+      channel.setMethodCallHandler((call) async {
+        switch (call.method) {
+          case 'captureReplayScreenshot':
+            _replayRecorder ??=
+                ScreenshotRecorder(ScreenshotRecorderConfig(), options);
+            final replayId =
+                SentryId.fromId(call.arguments['replayId'] as String);
+            if (_replayId != replayId) {
+              _replayId = replayId;
+              hub.configureScope((s) {
+                // ignore: invalid_use_of_internal_member
+                s.replayId = replayId;
+              });
+            }
+
+            Uint8List? imageBytes;
+            await _replayRecorder?.capture((image) async {
+              var imageData =
+                  await image.toByteData(format: ImageByteFormat.png);
+              if (imageData != null) {
+                options.logger(
+                    SentryLevel.debug,
+                    'Replay: captured screenshot ('
+                    '${image.width}x${image.height} pixels, '
+                    '${imageData.lengthInBytes} bytes)');
+                imageBytes = imageData.buffer.asUint8List();
+              } else {
+                options.logger(SentryLevel.warning,
+                    'Replay: failed to convert screenshot to PNG');
+              }
+            });
+            return imageBytes;
+          default:
+            throw UnimplementedError('Method ${call.method} not implemented');
+        }
+      });
+    }
+
+    return super.init(hub);
+  }
+
   @override
   int? startProfiler(SentryId traceId) => tryCatchSync('startProfiler', () {
         final cSentryId = cocoa.SentryId1.alloc(_lib)