Fix replays and sessions

Author: buenaflor

flutter/example/lib/main.dart

@@ -83,16 +83,17 @@ Future<void> setupSentry(
       // going to log too much for your app, but can be useful when figuring out
       // configuration issues, e.g. finding out why your events are not uploaded.
       options.debug = true;
-      options.spotlight = Spotlight(enabled: true);
+      // options.spotlight = Spotlight(enabled: true);
       // options.enableTimeToFullDisplayTracing = true;
       options.enableMetrics = true;
+      options.release = '0.0.2-dart';
 
       options.maxRequestBodySize = MaxRequestBodySize.always;
       options.maxResponseBodySize = MaxResponseBodySize.always;
       options.navigatorKey = navigatorKey;
 
-      options.experimental.replay.sessionSampleRate = 0;
-      options.experimental.replay.errorSampleRate = 0;
+      options.experimental.replay.sessionSampleRate = 0.5;
+      options.experimental.replay.errorSampleRate = 1;
 
       _isIntegrationTest = isIntegrationTest;
       if (_isIntegrationTest) {

flutter/lib/src/sentry_flutter.dart

@@ -143,8 +143,8 @@ mixin SentryFlutter {
     if (options.platformChecker.isWeb) {
       options.transport = JavascriptEnvelopeTransport(_webBinding!);
 
-      // todo: only if replay enabled
-      options.addEventProcessor(WebReplayEventProcessor(_webBinding!));
+      options.addEventProcessor(
+          WebReplayEventProcessor(_webBinding!, options.experimental.replay));
     }
 
     options.addEventProcessor(FlutterEnricherEventProcessor(options));

flutter/lib/src/transport/file_system_transport.dart

@@ -1,5 +1,6 @@
 // backcompatibility for Flutter < 3.3
 // ignore: unnecessary_import
+import 'dart:convert';
 import 'dart:typed_data';
 
 import 'package:flutter/services.dart';

flutter/lib/src/web/factory_noop.dart

@@ -13,6 +13,17 @@ class NoOpWebInterop implements SentryWebBinding {
 
   @override
   Future<void> init(SentryFlutterOptions options) async {}
+
+  @override
+  Future<void> flushReplay() async {}
+
+  @override
+  Future<SentryId> getReplayId() {
+    return Future.value(SentryId.empty());
+  }
+
+  @override
+  Future<void> startReplay() async {}
 }
 
 SentryWebBinding createBinding(SentryFlutterOptions options) =>

flutter/lib/src/web/sentry_js_bridge.dart

@@ -29,11 +29,35 @@ class SentryJsBridge {
   external static _SentryJsClient getClient();
 
   external static JSAny? getReplay();
+
+  external static void captureSession();
+
+  external static _Scope? getCurrentScope();
+
+  external static _Scope? getIsolationScope();
+
+  static SentryJsSession? getSession() {
+    return getCurrentScope()?.getSession() ?? getIsolationScope()?.getSession();
+  }
 }
 
-@JS('Replay')
+@JS('Session')
 @staticInterop
-class _SentryReplay {}
+class SentryJsSession {}
+
+extension SentryJsSessionExtension on SentryJsSession {
+  external JSString status;
+
+  external JSNumber errors;
+}
+
+@JS('Scope')
+@staticInterop
+class _Scope {}
+
+extension SentryScopeExtension on _Scope {
+  external SentryJsSession? getSession();
+}
 
 extension SentryReplayExtension on JSAny? {
   external void start();
@@ -44,7 +68,7 @@ extension SentryReplayExtension on JSAny? {
 
   external void flush();
 
-  external JSString getReplayId();
+  external JSString? getReplayId();
 }
 
 @JS('Client')

flutter/lib/src/web/sentry_web_binding.dart

@@ -13,8 +13,6 @@ abstract class SentryWebBinding {
 
   Future<void> flushReplay();
 
-  Future<void> startReplay();
-
   Future<SentryId> getReplayId();
 
   Future<void> close();

flutter/lib/src/web/sentry_web_interop.dart

@@ -47,8 +47,9 @@ class SentryWebInterop
         'autoSessionTracking': options.enableAutoSessionTracking,
         'attachStacktrace': options.attachStacktrace,
         'maxBreadcrumbs': options.maxBreadcrumbs,
-        'replaysSessionSampleRate': 0,
-        'replaysOnErrorSampleRate': 0,
+        'replaysSessionSampleRate':
+            options.experimental.replay.sessionSampleRate,
+        'replaysOnErrorSampleRate': options.experimental.replay.errorSampleRate,
         // using defaultIntegrations ensures the we can control which integrations are added
         'defaultIntegrations': [
           replay,
@@ -61,38 +62,35 @@ class SentryWebInterop
 
       SentryJsBridge.init(config.jsify());
 
-      await startReplay();
+      // SpotlightBridge.init();
+
+      // await startReplay();
     });
   }
 
   @override
-  Future<void> captureEvent(SentryEvent event) async {
-    tryCatchSync('captureEvent', () {
-      print(event.toJson());
-      SentryJsBridge.captureEvent(event.toJson().jsify());
-    });
-  }
+  Future<void> captureEvent(SentryEvent event) async {}
 
   @override
   Future<void> captureEnvelope(SentryEnvelope envelope) async {
     return tryCatchAsync('captureEnvelope', () async {
       final List<dynamic> jsItems = [];
 
       for (final item in envelope.items) {
-        // todo: add support for different type of items
-        // maybe add a generic to sentryenvelope?
         final originalObject = item.originalObject;
-        final List<dynamic> jsItem = [(await item.header.toJson())];
-        if (originalObject is SentryTransaction) {
-          jsItem.add(originalObject.toJson().jsify());
-        }
+        jsItems.add([
+          (await item.header.toJson()),
+          (await originalObject?.getPayload())
+        ]);
+
         if (originalObject is SentryEvent) {
-          jsItem.add(originalObject.toJson().jsify());
+          final session = SentryJsBridge.getSession();
+          if (envelope.containsUnhandledException) {
+            session?.status = 'crashed'.toJS;
+          }
+          session?.errors = originalObject.exceptions?.length.toJS ?? 0.toJS;
+          SentryJsBridge.captureSession();
         }
-        if (originalObject is SentryAttachment) {
-          jsItem.add(await originalObject.bytes);
-        }
-        jsItems.add(jsItem);
       }
 
       final jsEnvelope = [envelope.header.toJson(), jsItems].jsify();
@@ -108,11 +106,6 @@ class SentryWebInterop
     });
   }
 
-  @override
-  Future<void> startReplay() async {
-    replay.startBuffering();
-  }
-
   @override
   Future<void> flushReplay() async {
     replay.flush();
@@ -133,6 +126,10 @@ Future<void> _loadSentryScripts(SentryFlutterOptions options,
 
   // todo: put this somewhere else so we can auto-update it as well and only enable non minified bundles in dev mode
   final scripts = [
+    // {
+    //   'url':
+    //       'https://unpkg.com/@spotlightjs/overlay@latest/dist/sentry-spotlight.iife.js',
+    // },
     {
       'url': 'https://browser.sentry-cdn.com/8.24.0/bundle.tracing.replay.js',
       // 'integrity':

flutter/lib/src/web_replay_event_processor.dart

@@ -1,32 +1,36 @@
 import 'dart:async';
 
 import '../sentry_flutter.dart';
+import 'sentry_replay_options.dart';
 import 'web/sentry_web_binding.dart';
 
 class WebReplayEventProcessor implements EventProcessor {
-  WebReplayEventProcessor(this._binding);
+  WebReplayEventProcessor(this._binding, this._replayOptions);
 
   final SentryWebBinding _binding;
+  final SentryReplayOptions _replayOptions;
+  bool hasFlushedReplay = false;
 
   @override
   FutureOr<SentryEvent?> apply(SentryEvent event, Hint hint) async {
     try {
-      await _binding.flushReplay();
+      if (!_replayOptions.isEnabled) {
+        return event;
+      }
 
-      await Future<void>.delayed(Duration(seconds: 1));
+      if (event.exceptions?.isNotEmpty == true && !hasFlushedReplay) {
+        await _binding.flushReplay();
+        hasFlushedReplay = true;
+      }
 
       final sentryId = await _binding.getReplayId();
 
-      print(sentryId);
       event = event.copyWith(tags: {
         ...?event.tags,
         'replayId': sentryId.toString(),
       });
-      event.tags?.forEach((key, value) {
-        print('$key: $value');
-      });
     } catch (exception, stackTrace) {
-      print('Failed to get replay id: $exception $stackTrace');
+      // todo: log
     }
 
     return event;