[v9]: Flutter Web release health

CHANGELOG.md

@@ -7,6 +7,9 @@
 - Cleanup platform mocking ([#2730](https://github.com/getsentry/sentry-dart/pull/2730))
   - The `PlatformChecker` was renamed to `RuntimeChecker`
   - Moved `PlatformChecker.platform` to `options.platform`
+- Bump Javascript SDK from v8.42.0 to v9.5.0 ([#2784](https://github.com/getsentry/sentry-dart/pull/2784))
+  - [changelog](https://github.com/getsentry/sentry-javascript/blob/main/CHANGELOG.md#950)
+  - [diff](https://github.com/getsentry/sentry-javascript/compare/8.42.0...9.5.0)
 
 ## 9.0.0-alpha.1
 

dart/lib/sentry.dart

@@ -5,6 +5,8 @@
 /// A pure Dart client for Sentry.io crash reporting.
 library;
 
+// ignore: invalid_export_of_internal_element
+export 'src/constants.dart';
 export 'src/event_processor.dart';
 export 'src/exception_cause.dart';
 export 'src/exception_cause_extractor.dart';
@@ -18,12 +20,13 @@ export 'src/hub_adapter.dart';
 export 'src/integration.dart';
 export 'src/noop_isolate_error_integration.dart'
     if (dart.library.io) 'src/isolate_error_integration.dart';
+export 'src/observers.dart';
 export 'src/performance_collector.dart';
-export 'src/runtime_checker.dart';
 export 'src/protocol.dart';
 export 'src/protocol/sentry_feedback.dart';
 export 'src/protocol/sentry_proxy.dart';
 export 'src/run_zoned_guarded_integration.dart';
+export 'src/runtime_checker.dart';
 export 'src/scope.dart';
 export 'src/scope_observer.dart';
 export 'src/sentry.dart';
@@ -34,8 +37,6 @@ export 'src/sentry_envelope.dart';
 export 'src/sentry_envelope_item.dart';
 export 'src/sentry_options.dart';
 // ignore: invalid_export_of_internal_element
-export 'src/constants.dart';
-// ignore: invalid_export_of_internal_element
 export 'src/sentry_trace_origins.dart';
 export 'src/span_data_convention.dart';
 export 'src/spotlight.dart';

dart/lib/src/observers.dart

@@ -0,0 +1,12 @@
+import 'dart:async';
+
+import '../sentry.dart';
+
+// This file will contain observer definitions that are executed during
+// specific points in the SDK such as as right before an event is sent.
+
+/// Called right before an event is sent, after all processing is complete.
+/// Should not modify the event at this point.
+abstract class BeforeSendEventObserver {
+  FutureOr<void> onBeforeSendEvent(SentryEvent event, Hint hint);
+}

dart/lib/src/sentry_client.dart

@@ -160,6 +160,9 @@
       return _emptySentryId;
     }
 
+    // Event is fully processed and ready to be sent, emit beforeSendEvent observer
+    await _emitBeforeSendEventObserver(preparedEvent, hint);
+
     var attachments = List<SentryAttachment>.from(scope?.attachments ?? []);
     attachments.addAll(hint.attachments);
     var screenshot = hint.screenshot;
@@ -563,4 +566,26 @@
     }
     return DataCategory.error;
   }
+
+  FutureOr<void> _emitBeforeSendEventObserver(
+      SentryEvent event, Hint hint) async {
+    for (final callback in _options.beforeSendEventObservers) {
+      try {
+        final result = callback.onBeforeSendEvent(event, hint);
+        if (result is Future) {
+          await result;
+        }
+      } catch (exception, stackTrace) {
+        _options.logger(
+          SentryLevel.error,
+          'Error while running beforeSendEvent callback',
+          exception: exception,
+          stackTrace: stackTrace,
+        );
+        if (_options.automatedTestMode) {
+          rethrow;
+        }
+      }
+    }
+  }
 }

dart/lib/src/sentry_options.dart

@@ -498,6 +498,17 @@ class SentryOptions {
   /// iOS only supports http proxies, while macOS also supports socks.
   SentryProxy? proxy;
 
+  final List<BeforeSendEventObserver> _beforeSendEventObserver = [];
+
+  List<BeforeSendEventObserver> get beforeSendEventObservers =>
+      List.unmodifiable(_beforeSendEventObserver);
+
+  /// Adds an observer which is called right before an event is sent.
+  /// This should not be used to mutate the event.
+  void addBeforeSendEventObserver(BeforeSendEventObserver observer) {
+    _beforeSendEventObserver.add(observer);
+  }
+
   SentryOptions({String? dsn, Platform? platform, RuntimeChecker? checker}) {
     this.dsn = dsn;
     if (platform != null) {

dart/test/sentry_client_before_send_event_test.dart

@@ -0,0 +1,130 @@
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:sentry/sentry.dart';
+import 'package:sentry/src/sentry_tracer.dart';
+import 'package:test/test.dart';
+
+import 'mocks/mock_transport.dart';
+import 'test_utils.dart';
+
+void main() {
+  group('SentryClient beforeSendEvent', () {
+    late Fixture fixture;
+
+    setUp(() {
+      fixture = Fixture();
+    });
+
+    test('beforeSendEvent is called with correct event and hint', () async {
+      final observer = _TestEventObserver();
+      fixture.options.addBeforeSendEventObserver(observer);
+
+      final client = fixture.getSut();
+      final hint = Hint();
+      final event = SentryEvent().copyWith(type: 'some random type');
+
+      await client.captureEvent(event, hint: hint);
+
+      expect(observer.inspectedEvent?.type, 'some random type');
+      expect(observer.inspectedHint, same(hint));
+    });
+
+    test('beforeSendEvent is called for transactions', () async {
+      final observer = _TestEventObserver();
+      fixture.options.addBeforeSendEventObserver(observer);
+
+      final client = fixture.getSut();
+      final hint = Hint();
+      final tracer = SentryTracer(
+        SentryTransactionContext('name', 'op'),
+        Sentry.currentHub,
+      );
+      final event = SentryTransaction(tracer);
+
+      await client.captureEvent(event, hint: hint);
+
+      expect(
+          (observer.inspectedEvent as SentryTransaction).tracer.name, 'name');
+      expect(
+          (observer.inspectedEvent as SentryTransaction)
+              .tracer
+              .context
+              .operation,
+          'op');
+      expect(observer.inspectedHint, same(hint));
+    });
+
+    test('beforeSendEvent is called after all other processors', () async {
+      final processingOrder = <String>[];
+
+      fixture.options.addEventProcessor(_TestEventProcessor(processingOrder));
+      fixture.options.beforeSend = (event, hint) {
+        processingOrder.add('beforeSend');
+        return event;
+      };
+
+      fixture.options
+          .addBeforeSendEventObserver(_TestOrderObserver(processingOrder));
+
+      final client = fixture.getSut();
+      final event = SentryEvent();
+
+      await client.captureEvent(event);
+
+      expect(
+          processingOrder, ['eventProcessor', 'beforeSend', 'beforeSendEvent']);
+    });
+  });
+}
+
+Future<SentryEvent> eventFromEnvelope(SentryEnvelope envelope) async {
+  final data = await envelope.items.first.dataFactory();
+  final utf8Data = utf8.decode(data);
+  final envelopeItemJson = jsonDecode(utf8Data);
+  return SentryEvent.fromJson(envelopeItemJson as Map<String, dynamic>);
+}
+
+class Fixture {
+  final options = defaultTestOptions();
+
+  SentryClient getSut() {
+    options.transport = MockTransport();
+
+    return SentryClient(options);
+  }
+}
+
+class _TestEventObserver implements BeforeSendEventObserver {
+  SentryEvent? inspectedEvent;
+  Hint? inspectedHint;
+
+  @override
+  FutureOr<void> onBeforeSendEvent(SentryEvent event, Hint hint) {
+    inspectedEvent = event;
+    inspectedHint = hint;
+  }
+}
+
+class _TestEventProcessor extends EventProcessor {
+  _TestEventProcessor(this._processingOrder);
+
+  final List<String> _processingOrder;
+
+  @override
+  FutureOr<SentryEvent?> apply(SentryEvent event, Hint hint) {
+    _processingOrder.add('eventProcessor');
+    return event;
+  }
+}
+
+class _TestOrderObserver extends BeforeSendEventObserver {
+  final List<String> _processingOrder;
+
+  _TestOrderObserver(this._processingOrder);
+
+  @override
+  FutureOr<void> onBeforeSendEvent(SentryEvent event, Hint hint) {
+    _processingOrder.add('beforeSendEvent');
+  }
+}

flutter/example/integration_test/web_sdk_test.dart

@@ -155,6 +155,32 @@
           findsOneWidget,
         );
       });
+
+      testWidgets('sends the session update for error event', (tester) async {
+        await restoreFlutterOnErrorAfter(() async {
+          await SentryFlutter.init((options) {
+            options.dsn = fakeDsn;
+          }, appRunner: () async {
+            await tester.pumpWidget(
+              SentryWidget(child: const app.MyApp()),
+            );
+          });
+        });
+
+        final client = _getClient()!;
+        final completer = Completer<Map<dynamic, dynamic>>();
+
+        JSFunction beforeSendSessionCallback = ((JSObject session) {
+          final sessionDart = session.dartify() as Map<dynamic, dynamic>;
+          completer.complete(sessionDart);
+        }).toJS;
+
+        client.on('beforeSendSession'.toJS, beforeSendSessionCallback);
+
+        await Sentry.captureException(Exception('test'));
+
+        final session = await completer.future;
+      });
     });
 
     group('disabled', () {

flutter/lib/src/native/c/sentry_native.dart

@@ -287,6 +287,27 @@ class SentryNative with SentryNativeSafeInvoker implements SentryNativeBinding {
     _logNotSupported('capturing replay');
     return SentryId.empty();
   }
+
+  @override
+  FutureOr<void> startSession({bool ignoreDuration = false}) {
+    _logNotSupported('starting session');
+  }
+
+  @override
+  FutureOr<void> captureSession() {
+    _logNotSupported('capturing session');
+  }
+
+  @override
+  FutureOr<Map<dynamic, dynamic>?> getSession() {
+    _logNotSupported('getting session');
+    return null;
+  }
+
+  @override
+  FutureOr<void> updateSession({int? errors, String? status}) {
+    _logNotSupported('updating session');
+  }
 }
 
 extension on binding.sentry_value_u {

flutter/lib/src/native/sentry_native_binding.dart

@@ -72,4 +72,28 @@ abstract class SentryNativeBinding {
   FutureOr<void> setReplayConfig(ReplayConfig config);
 
   FutureOr<SentryId> captureReplay(bool isCrash);
+
+  /// Starts a new session.
+  ///
+  /// Note: This is used on web platforms. Android and iOS handle sessions
+  /// automatically through their respective native SDKs.
+  /// Windows and Linux currently don't support sessions.
+  ///
+  /// @param ignoreDurations If true, the session will ignore the configured session duration
+  FutureOr<void> startSession({bool ignoreDuration = false});
+
+  /// Gets the current active session.
+  ///
+  /// Note: This is used on web platforms. Returns null on other platforms.
+  FutureOr<Map<dynamic, dynamic>?> getSession();
+
+  /// Updates the current session with the provided status and/or error count.
+  ///
+  /// Note: This is primarily used on web platforms. No-op on other platforms.
+  FutureOr<void> updateSession({int? errors, String? status});
+
+  /// Sends the current session immediately.
+  ///
+  /// Note: This is primarily used on web platforms. No-op on other platforms.
+  FutureOr<void> captureSession();
 }

flutter/lib/src/native/sentry_native_channel.dart

@@ -29,6 +29,9 @@
   SentryNativeChannel(this.options)
       : channel = SentrySafeMethodChannel(options);
 
+  void _logNotSupported(String operation) => options.logger(
+      SentryLevel.debug, 'SentryNativeChannel: $operation is not supported');
+
   @override
   Future<void> init(Hub hub) async {
     return channel.invokeMethod('initNativeSdk', <String, dynamic>{
@@ -246,4 +249,25 @@
       channel.invokeMethod('captureReplay', {
         'isCrash': isCrash,
       }).then((value) => SentryId.fromId(value as String));
+
+  @override
+  FutureOr<void> captureSession() {
+    _logNotSupported('capturing session');
+  }
+
+  @override
+  FutureOr<void> startSession({bool ignoreDuration = false}) {
+    _logNotSupported('starting session');
+  }
+
+  @override
+  FutureOr<Map<dynamic, dynamic>?> getSession() {
+    _logNotSupported('getting session');
+    return null;
+  }
+
+  @override
+  FutureOr<void> updateSession({int? errors, String? status}) {
+    _logNotSupported('updating session');
+  }
 }