[v9]: Flutter Web release health

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Add support for Flutter Web release health ([#2794](https://github.com/getsentry/sentry-dart/pull/2794))
+  - Requires using `SentryNavigatorObserver`;
 - Bump Native SDK from v0.7.20 to v0.8.1 ([#2761](https://github.com/getsentry/sentry-dart/pull/2761))
   - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#081)
   - [diff](https://github.com/getsentry/sentry-native/compare/0.7.20...0.8.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,14 @@ 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';
+// ignore: invalid_export_of_internal_element
+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 +38,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,18 @@
+import 'dart:async';
+
+import 'package:meta/meta.dart';
+
+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.
+// Only for internal use, e.g updating sessions only when an event is fully processed.
+// Not to be confused with the public callbacks such as beforeSend.
+// These should not mutate the data that is passed through the observer.
+
+/// Called right before an event is sent, after all processing is complete.
+/// Should not modify the event at this point.
+@internal
+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 observer in _options.beforeSendEventObservers) {
+      try {
+        final result = observer.onBeforeSendEvent(event, hint);
+        if (result is Future) {
+          await result;
+        }
+      } catch (exception, stackTrace) {
+        _options.logger(
+          SentryLevel.error,
+          'Error while running beforeSendEvent observer',
+          exception: exception,
+          stackTrace: stackTrace,
+        );
+        if (_options.automatedTestMode) {
+          rethrow;
+        }
+      }
+    }
+  }
 }

dart/lib/src/sentry_options.dart

@@ -498,6 +498,26 @@
   /// iOS only supports http proxies, while macOS also supports socks.
   SentryProxy? proxy;
 
+  final List<BeforeSendEventObserver> _beforeSendEventObserver = [];
+
+  @internal
+  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.
+  ///
+  /// Note: this is not triggered for transactions/spans with startTransaction or startChild.
+  @internal
+  void addBeforeSendEventObserver(BeforeSendEventObserver observer) {
+    _beforeSendEventObserver.add(observer);
+  }
+
+  @internal
+  void removeBeforeSendEventObserver(BeforeSendEventObserver observer) {
+    _beforeSendEventObserver.remove(observer);
+  }
+
   SentryOptions({String? dsn, Platform? platform, RuntimeChecker? checker}) {
     this.dsn = dsn;
     if (platform != null) {

dart/test/sentry_client_test.dart

@@ -2197,6 +2197,49 @@ void main() {
       await client.captureEvent(fakeEvent, stackTrace: StackTrace.current);
     });
   });
+
+  group('beforeSendEvent observer', () {
+    late Fixture fixture;
+
+    setUp(() {
+      fixture = Fixture();
+    });
+
+    test('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('is called after all other processors', () async {
+      final processingOrder = <String>[];
+      final beforeSend = (SentryEvent event, Hint hint) {
+        processingOrder.add('beforeSend');
+        return event;
+      };
+
+      fixture.options
+          .addBeforeSendEventObserver(_TestOrderObserver(processingOrder));
+
+      final client = fixture.getSut(
+          beforeSend: beforeSend,
+          eventProcessor: _TestEventProcessor(processingOrder));
+      final event = SentryEvent();
+
+      await client.captureEvent(event);
+
+      expect(
+          processingOrder, ['eventProcessor', 'beforeSend', 'beforeSendEvent']);
+    });
+  });
 }
 
 Future<SentryEvent> eventFromEnvelope(SentryEnvelope envelope) async {
@@ -2416,3 +2459,37 @@ class ExceptionWithStackTraceExtractor
     return error.stackTrace;
   }
 }
+
+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

@@ -91,9 +91,14 @@ void main() {
         final client = _getClient()!;
         final completer = Completer<List<Object?>>();
 
+        int count = 0;
         JSFunction beforeEnvelopeCallback = ((JSArray envelope) {
           final envelopDart = envelope.dartify() as List<Object?>;
-          completer.complete(envelopDart);
+          // the first envelope will be session envelope, we can ignore that
+          if (count == 1) {
+            completer.complete(envelopDart);
+          }
+          count += 1;
         }).toJS;
 
         client.on('beforeEnvelope'.toJS, beforeEnvelopeCallback);
@@ -155,22 +160,86 @@ void main() {
           findsOneWidget,
         );
       });
-    });
 
-    group('disabled', () {
-      testWidgets('Sentry JS SDK is not initialized', (tester) async {
+      testWidgets('send session update if unhandled error', (tester) async {
         await restoreFlutterOnErrorAfter(() async {
           await SentryFlutter.init((options) {
             options.dsn = fakeDsn;
-            options.autoInitializeNativeSdk = false;
           }, appRunner: () async {
-            await tester.pumpWidget(const app.MyApp());
+            await tester.pumpWidget(
+              SentryWidget(child: const app.MyApp()),
+            );
           });
         });
 
-        expect(globalThis['Sentry'], isNull);
-        expect(() => _getClient(), throwsA(anything));
+        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);
+
+        final mechanism = Mechanism(type: 'FlutterError', handled: false);
+        final throwableMechanism =
+            ThrowableMechanism(mechanism, Exception('test'));
+        await Sentry.captureException(throwableMechanism);
+
+        final session =
+            await completer.future.timeout(const Duration(seconds: 5));
+
+        expect(session['status'], 'crashed');
+        expect(session['errors'], 1);
       });
+
+      testWidgets('send session update if handled error and error count = 0',
+          (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.timeout(const Duration(seconds: 5));
+
+        expect(session['status'], 'ok');
+        expect(session['errors'], 1);
+      });
+    });
+  });
+
+  group('disabled', () {
+    testWidgets('Sentry JS SDK is not initialized', (tester) async {
+      await restoreFlutterOnErrorAfter(() async {
+        await SentryFlutter.init((options) {
+          options.dsn = fakeDsn;
+          options.autoInitializeNativeSdk = false;
+        }, appRunner: () async {
+          await tester.pumpWidget(const app.MyApp());
+        });
+      });
+
+      expect(globalThis['Sentry'], isNull);
+      expect(() => _getClient(), throwsA(anything));
     });
   });
 }