Feat: Sync Scope to Native

.github/workflows/flutter.yml

@@ -208,6 +208,7 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       # 1.20.0
+      # To recreate baseline run: detekt -i flutter/android,flutter/example/android -b flutter/config/detekt-bl.xml -cb
       - uses: natiginfo/action-detekt-all@74990bda6bfc47977e1e06aae9f47f320e7587ce
         with:
-          args: -i flutter --baseline flutter/config/detekt-bl.xml
+          args: -i flutter/android,flutter/example/android --baseline flutter/config/detekt-bl.xml

CHANGELOG.md

@@ -6,6 +6,8 @@
 * Fix: Fix `SentryAssetBundle` on Flutter >= 3.1 (#877)
 * Feat: Add Android thread to platform stacktraces (#853)
 * Fix: Rename auto initialize property (#857)
+* Feat: Sync Scope to Native (#858)
+* Bump: Sentry-Android to 6.0.0-beta.4 (#871)
 * Bump: Sentry-Android to 6.0.0 (#879)
 
 ## 6.6.0-alpha.2

dart/example/bin/example.dart

@@ -40,14 +40,14 @@ Future<void> runApp() async {
   );
 
   Sentry.configureScope((scope) {
+    scope.setUser(SentryUser(
+      id: '800',
+      username: 'first-user',
+      email: '[email protected]',
+      // ipAddress: '127.0.0.1', sendDefaultPii feature is enabled
+      extras: <String, String>{'first-sign-in': '2020-01-01'},
+    ));
     scope
-      ..user = SentryUser(
-        id: '800',
-        username: 'first-user',
-        email: '[email protected]',
-        // ipAddress: '127.0.0.1', sendDefaultPii feature is enabled
-        extras: <String, String>{'first-sign-in': '2020-01-01'},
-      )
       // ..fingerprint = ['example-dart'], fingerprint forces events to group together
       ..transaction = '/example/app'
       ..level = SentryLevel.warning

dart/example_web/web/main.dart

@@ -40,18 +40,21 @@ void runApp() {
 
   Sentry.configureScope((scope) {
     scope
-      ..user = SentryUser(
-        id: '800',
-        username: 'first-user',
-        email: '[email protected]',
-        // ipAddress: '127.0.0.1',
-        extras: <String, String>{'first-sign-in': '2020-01-01'},
-      )
       // ..fingerprint = ['example-dart']
       ..transaction = '/example/app'
       ..level = SentryLevel.warning
       ..setTag('build', '579')
       ..setExtra('company-name', 'Dart Inc');
+
+    scope.setUser(
+      SentryUser(
+        id: '800',
+        username: 'first-user',
+        email: '[email protected]',
+        // ipAddress: '127.0.0.1',
+        extras: <String, String>{'first-sign-in': '2020-01-01'},
+      ),
+    );
   });
 
   querySelector('#btEvent')

dart/lib/sentry.dart

@@ -12,6 +12,7 @@ export 'src/noop_isolate_error_integration.dart'
     if (dart.library.io) 'src/isolate_error_integration.dart';
 export 'src/protocol.dart';
 export 'src/scope.dart';
+export 'src/scope_observer.dart';
 export 'src/sentry.dart';
 export 'src/sentry_envelope.dart';
 export 'src/sentry_envelope_item.dart';

dart/lib/src/scope.dart

@@ -1,11 +1,13 @@
+import 'dart:async';
 import 'dart:collection';
 
-import 'sentry_attachment/sentry_attachment.dart';
 import 'event_processor.dart';
 import 'protocol.dart';
+import 'scope_observer.dart';
+import 'sentry_attachment/sentry_attachment.dart';
 import 'sentry_options.dart';
+import 'sentry_span_interface.dart';
 import 'sentry_tracer.dart';
-import 'tracing.dart';
 
 /// Scope data to be sent with the event
 class Scope {
@@ -46,8 +48,17 @@ class Scope {
     }
   }
 
-  /// Information about the current user.
-  SentryUser? user;
+  SentryUser? _user;
+
+  /// Get the current user.
+  SentryUser? get user => _user;
+
+  /// Set the current user.
+  Future<void> setUser(SentryUser? user) async {
+    _user = user;
+    await _callScopeObservers(
+        (scopeObserver) async => await scopeObserver.setUser(user));
+  }
 
   List<String> _fingerprint = [];
 
@@ -93,15 +104,21 @@ class Scope {
   Map<String, dynamic> get contexts => Map.unmodifiable(_contexts);
 
   /// add an entry to the Scope's contexts
-  void setContexts(String key, dynamic value) {
+  Future<void> setContexts(String key, dynamic value) async {
     _contexts[key] = (value is num || value is bool || value is String)
         ? {'value': value}
         : value;
+
+    await _callScopeObservers(
+        (scopeObserver) async => await scopeObserver.setContexts(key, value));
   }
 
   /// Removes a value from the Scope's contexts
-  void removeContexts(String key) {
+  Future<void> removeContexts(String key) async {
     _contexts.remove(key);
+
+    await _callScopeObservers(
+        (scopeObserver) async => await scopeObserver.removeContexts(key));
   }
 
   /// Scope's event processor list
@@ -114,14 +131,17 @@ class Scope {
 
   final SentryOptions _options;
 
-  final List<SentryAttachment> _attachements = [];
+  final List<SentryAttachment> _attachments = [];
+
+  List<SentryAttachment> get attachments => List.unmodifiable(_attachments);
 
-  List<SentryAttachment> get attachements => List.unmodifiable(_attachements);
+  @Deprecated('Use attachments instead')
+  List<SentryAttachment> get attachements => attachments;
 
   Scope(this._options);
 
   /// Adds a breadcrumb to the breadcrumbs queue
-  void addBreadcrumb(Breadcrumb breadcrumb, {dynamic hint}) {
+  Future<void> addBreadcrumb(Breadcrumb breadcrumb, {dynamic hint}) async {
     // bail out if maxBreadcrumbs is zero
     if (_options.maxBreadcrumbs == 0) {
       return;
@@ -151,19 +171,25 @@ class Scope {
     }
 
     _breadcrumbs.add(breadcrumb);
+
+    await _callScopeObservers(
+        (scopeObserver) async => await scopeObserver.addBreadcrumb(breadcrumb));
   }
 
   void addAttachment(SentryAttachment attachment) {
-    _attachements.add(attachment);
+    _attachments.add(attachment);
   }
 
   void clearAttachments() {
-    _attachements.clear();
+    _attachments.clear();
   }
 
   /// Clear all the breadcrumbs
-  void clearBreadcrumbs() {
+  Future<void> clearBreadcrumbs() async {
     _breadcrumbs.clear();
+
+    await _callScopeObservers(
+        (scopeObserver) async => await scopeObserver.clearBreadcrumbs());
   }
 
   /// Adds an event processor
@@ -172,36 +198,46 @@ class Scope {
   }
 
   /// Resets the Scope to its default state
-  void clear() {
-    clearBreadcrumbs();
+  Future<void> clear() async {
+    await clearBreadcrumbs();
     clearAttachments();
     level = null;
     _span = null;
     _transaction = null;
-    user = null;
+    await setUser(null);
     _fingerprint = [];
     _tags.clear();
     _extra.clear();
     _eventProcessors.clear();
   }
 
   /// Sets a tag to the Scope
-  void setTag(String key, String value) {
+  Future<void> setTag(String key, String value) async {
     _tags[key] = value;
+    await _callScopeObservers(
+        (scopeObserver) async => await scopeObserver.setTag(key, value));
   }
 
   /// Removes a tag from the Scope
-  void removeTag(String key) {
+  Future<void> removeTag(String key) async {
     _tags.remove(key);
+    await _callScopeObservers(
+        (scopeObserver) async => await scopeObserver.removeTag(key));
   }
 
   /// Sets an extra to the Scope
-  void setExtra(String key, dynamic value) {
+  Future<void> setExtra(String key, dynamic value) async {
     _extra[key] = value;
+    await _callScopeObservers(
+        (scopeObserver) async => await scopeObserver.setExtra(key, value));
   }
 
   /// Removes an extra from the Scope
-  void removeExtra(String key) => _extra.remove(key);
+  Future<void> removeExtra(String key) async {
+    _extra.remove(key);
+    await _callScopeObservers(
+        (scopeObserver) async => await scopeObserver.removeExtra(key));
+  }
 
   Future<SentryEvent?> applyToEvent(
     SentryEvent event, {
@@ -327,11 +363,12 @@ class Scope {
   Scope clone() {
     final clone = Scope(_options)
       ..level = level
-      ..user = user
       ..fingerprint = List.from(fingerprint)
       .._transaction = _transaction
       .._span = _span;
 
+    clone.setUser(user);
+
     for (final tag in _tags.keys) {
       clone.setTag(tag, _tags[tag]!);
     }
@@ -354,10 +391,19 @@ class Scope {
       }
     });
 
-    for (final attachment in _attachements) {
+    for (final attachment in _attachments) {
       clone.addAttachment(attachment);
     }
 
     return clone;
   }
+
+  Future<void> _callScopeObservers(
+      Future<void> Function(ScopeObserver) action) async {
+    if (_options.enableScopeSync) {
+      for (final scopeObserver in _options.scopeObservers) {
+        await action(scopeObserver);
+      }
+    }
+  }
 }

dart/lib/src/scope_observer.dart

@@ -0,0 +1,16 @@
+import 'dart:async';
+
+import 'protocol/breadcrumb.dart';
+import 'protocol/sentry_user.dart';
+
+abstract class ScopeObserver {
+  Future<void> setContexts(String key, dynamic value);
+  Future<void> removeContexts(String key);
+  Future<void> setUser(SentryUser? user);
+  Future<void> addBreadcrumb(Breadcrumb breadcrumb);
+  Future<void> clearBreadcrumbs();
+  Future<void> setExtra(String key, dynamic value);
+  Future<void> removeExtra(String key);
+  Future<void> setTag(String key, String value);
+  Future<void> removeTag(String key);
+}

dart/lib/src/sentry_client.dart

@@ -115,10 +115,24 @@ class SentryClient {
         return _sentryId;
       }
     }
+
+    if (_options.platformChecker.platform.isAndroid &&
+        _options.enableScopeSync) {
+      /*
+      We do this to avoid duplicate breadcrumbs on Android as sentry-android applies the breadcrumbs
+      from the native scope onto every envelope sent through it. This scope will contain the breadcrumbs
+      sent through the scope sync feature. This causes duplicate breadcrumbs.
+      We then remove the breadcrumbs in all cases but if it is handled == false,
+      this is a signal that the app would crash and android would lose the breadcrumbs by the time the app is restarted to read
+      the envelope.
+      */
+      preparedEvent = _eventWithRemovedBreadcrumbsIfHandled(preparedEvent);
+    }
+
     final envelope = SentryEnvelope.fromEvent(
       preparedEvent,
       _options.sdk,
-      attachments: scope?.attachements,
+      attachments: scope?.attachments,
     );
 
     final id = await captureEnvelope(envelope);
@@ -297,7 +311,7 @@ class SentryClient {
 
     final id = await captureEnvelope(
       SentryEnvelope.fromTransaction(preparedTransaction, _options.sdk,
-          attachments: scope?.attachements
+          attachments: scope?.attachments
               .where((element) => element.addToTransactions)
               .toList()),
     );
@@ -363,6 +377,19 @@ class SentryClient {
     _options.recorder.recordLostEvent(reason, category);
   }
 
+  SentryEvent _eventWithRemovedBreadcrumbsIfHandled(SentryEvent event) {
+    final exceptions = event.exceptions ?? [];
+    final handled = exceptions.isNotEmpty
+        ? exceptions.first.mechanism?.handled == true
+        : false;
+
+    if (handled) {
+      return event.copyWith(breadcrumbs: []);
+    } else {
+      return event;
+    }
+  }
+
   Future<SentryId?> _attachClientReportsAndSend(SentryEnvelope envelope) {
     final clientReport = _options.recorder.flush();
     envelope.addClientReport(clientReport);

dart/lib/src/sentry_options.dart

@@ -16,7 +16,6 @@ import 'transport/noop_transport.dart';
 import 'utils.dart';
 import 'version.dart';
 
-// TODO: Scope observers, enableScopeSync
 // TODO: shutdownTimeout, flushTimeoutMillis
 // https://api.dart.dev/stable/2.10.2/dart-io/HttpClient/close.html doesn't have a timeout param, we'd need to implement manually
 
@@ -269,6 +268,17 @@ class SentryOptions {
   /// Send statistics to sentry when the client drops events.
   bool sendClientReports = true;
 
+  /// If enabled, [scopeObservers] will be called when mutating scope.
+  bool enableScopeSync = true;
+
+  final List<ScopeObserver> _scopeObservers = [];
+
+  List<ScopeObserver> get scopeObservers => _scopeObservers;
+
+  void addScopeObserver(ScopeObserver scopeObserver) {
+    _scopeObservers.add(scopeObserver);
+  }
+
   @internal
   late ClientReportRecorder recorder = NoOpClientReportRecorder();