ref: Hub passes the Scope

CHANGELOG.md

@@ -21,6 +21,7 @@
 - expect a sdkName based on the test platform #105
 - Added Scope and Breadcrumb ring buffer #109
 - Added Hub to SDK #113
+- Ref: Hub passes the Scope to SentryClient
 
 # `package:sentry` changelog
 

dart/lib/src/client.dart

@@ -197,12 +197,13 @@ abstract class SentryClient {
   }
 
   /// Reports the [throwable] and optionally its [stackTrace] to Sentry.io.
-  Future<SentryId> captureException(dynamic throwable, {dynamic stackTrace}) {
+  Future<SentryId> captureException(dynamic throwable,
+      {dynamic stackTrace, Scope scope}) {
     final event = Event(
       exception: throwable,
       stackTrace: stackTrace,
     );
-    return captureEvent(event);
+    return captureEvent(event, scope: scope);
   }
 
   /// Reports the [template]
@@ -211,12 +212,13 @@ abstract class SentryClient {
     SeverityLevel level = SeverityLevel.info,
     String template,
     List<dynamic> params,
+    Scope scope,
   }) {
     final event = Event(
       message: Message(formatted, template: template, params: params),
       level: level,
     );
-    return captureEvent(event);
+    return captureEvent(event, scope: scope);
   }
 
   Future<void> close() async {

dart/lib/src/hub.dart

@@ -22,7 +22,10 @@ class Hub {
     );
   }
 
-  final ListQueue<_StackItem> _stack;
+  final ListQueue<_StackItem> _stack = ListQueue();
+
+  /// if stack is empty, it throws IterableElementError.noElement()
+  _StackItem _peek() => _stack.isNotEmpty ? _stack.first : null;
 
   final SentryOptions _options;
 
@@ -32,20 +35,18 @@ class Hub {
     return Hub._(options);
   }
 
-  Hub._(SentryOptions options)
-      : _options = options,
-        _stack = ListQueue() {
+  Hub._(SentryOptions options) : _options = options {
     _stack.add(_StackItem(_getClient(fromOptions: options), Scope(_options)));
     _isEnabled = true;
   }
 
   static void _validateOptions(SentryOptions options) {
     if (options == null) {
-      throw ArgumentError.notNull('options');
+      throw ArgumentError.notNull('SentryOptions is required.');
     }
 
-    if (options.dsn == null) {
-      throw ArgumentError.notNull('options.dsn');
+    if (options.dsn?.isNotEmpty != true) {
+      throw ArgumentError.notNull('DSN is required.');
     }
   }
 
@@ -54,7 +55,7 @@ class Hub {
   /// Check if the Hub is enabled/active.
   bool get isEnabled => _isEnabled;
 
-  SentryId _lastEventId;
+  SentryId _lastEventId = SentryId.empty();
 
   /// Last event id recorded in the current scope
   SentryId get lastEventId => _lastEventId;
@@ -74,7 +75,7 @@ class Hub {
         'captureEvent called with null parameter.',
       );
     } else {
-      final item = _stack.first;
+      final item = _peek();
       if (item != null) {
         try {
           sentryId = await item.client.captureEvent(event, scope: item.scope);
@@ -115,14 +116,11 @@ class Hub {
         'captureException called with null parameter.',
       );
     } else {
-      final item = _stack.first;
+      final item = _peek();
       if (item != null) {
         try {
-          // TODO pass the scope
-          sentryId = await item.client.captureException(
-            throwable,
-            stackTrace: stackTrace,
-          );
+          sentryId = await item.client.captureException(throwable,
+              stackTrace: stackTrace, scope: item.scope);
         } catch (err) {
           _options.logger(
             SeverityLevel.error,
@@ -162,15 +160,15 @@ class Hub {
         'captureMessage called with null parameter.',
       );
     } else {
-      final item = _stack.first;
+      final item = _peek();
       if (item != null) {
         try {
-          // TODO pass the scope
           sentryId = await item.client.captureMessage(
             message,
             level: level,
             template: template,
             params: params,
+            scope: item.scope,
           );
         } catch (err) {
           _options.logger(
@@ -196,7 +194,7 @@ class Hub {
       _options.logger(SeverityLevel.warning,
           "Instance is disabled and this 'bindClient' call is a no-op.");
     } else {
-      final item = _stack.first;
+      final item = _peek();
       if (item != null) {
         if (client != null) {
           _options.logger(SeverityLevel.debug, 'New client bound to scope.');
@@ -234,7 +232,7 @@ class Hub {
         "Instance is disabled and this 'close' call is a no-op.",
       );
     } else {
-      final item = _stack.first;
+      final item = _peek();
       if (item != null) {
         try {
           item.client.close();
@@ -262,7 +260,7 @@ class Hub {
         "Instance is disabled and this 'configureScope' call is a no-op.",
       );
     } else {
-      final item = _stack.first;
+      final item = _peek();
       if (item != null) {
         try {
           callback(item.scope);

dart/lib/src/noop_client.dart

@@ -4,8 +4,17 @@ import 'package:http/src/client.dart';
 
 import 'client.dart';
 import 'protocol.dart';
+import 'scope.dart';
 
 class NoOpSentryClient implements SentryClient {
+  NoOpSentryClient._();
+
+  static final NoOpSentryClient _instance = NoOpSentryClient._();
+
+  factory NoOpSentryClient() {
+    return _instance;
+  }
+
   @override
   User userContext;
 
@@ -24,7 +33,7 @@ class NoOpSentryClient implements SentryClient {
       Future.value(SentryId.empty());
 
   @override
-  Future<SentryId> captureException(throwable, {stackTrace}) =>
+  Future<SentryId> captureException(throwable, {stackTrace, scope}) =>
       Future.value(SentryId.empty());
 
   @override
@@ -33,6 +42,7 @@ class NoOpSentryClient implements SentryClient {
     SeverityLevel level = SeverityLevel.info,
     String template,
     List<dynamic> params,
+    Scope scope,
   }) =>
       Future.value(SentryId.empty());
 

dart/lib/src/noop_hub.dart

@@ -0,0 +1,51 @@
+import 'dart:async';
+
+import 'client.dart';
+import 'hub.dart';
+import 'protocol/event.dart';
+import 'protocol/level.dart';
+import 'protocol/sentry_id.dart';
+
+class NoOpHub implements Hub {
+  NoOpHub._();
+
+  static final NoOpHub _instance = NoOpHub._();
+
+  factory NoOpHub() {
+    return _instance;
+  }
+
+  @override
+  void bindClient(SentryClient client) {}
+
+  @override
+  Future<SentryId> captureEvent(Event event) => Future.value(SentryId.empty());
+
+  @override
+  Future<SentryId> captureException(throwable, {stackTrace}) =>
+      Future.value(SentryId.empty());
+
+  @override
+  Future<SentryId> captureMessage(
+    String message, {
+    SeverityLevel level = SeverityLevel.info,
+    String template,
+    List params,
+  }) =>
+      Future.value(SentryId.empty());
+
+  @override
+  Hub clone() => this;
+
+  @override
+  void close() {}
+
+  @override
+  void configureScope(callback) {}
+
+  @override
+  bool get isEnabled => false;
+
+  @override
+  SentryId get lastEventId => SentryId.empty();
+}

dart/lib/src/protocol/sentry_id.dart

@@ -1,16 +1,16 @@
 /// Sentry response id
 
 class SentryId {
-  static const String emptyId = '00000000-0000-0000-0000-000000000000';
+  static const String _emptyId = '00000000-0000-0000-0000-000000000000';
 
   /// The ID Sentry.io assigned to the submitted event for future reference.
   final String _id;
 
-  String get id => _id;
+  // TODO: should we generate the new UUID here with an empty ctor?
 
   const SentryId(this._id);
 
-  factory SentryId.empty() => SentryId(emptyId);
+  factory SentryId.empty() => SentryId(_emptyId);
 
   @override
   String toString() => _id.replaceAll('-', '');

dart/lib/src/sentry.dart

@@ -6,40 +6,76 @@ import 'client.dart';
 import 'hub.dart';
 import 'protocol.dart';
 import 'sentry_options.dart';
+import 'noop_hub.dart';
 
 /// Configuration options callback
 typedef OptionsConfiguration = void Function(SentryOptions);
 
 /// Sentry SDK main entry point
 ///
 class Sentry {
-  static Hub _hub;
+  static Hub _hub = NoOpHub();
 
   Sentry._();
 
+  /// Returns the current hub
+  static Hub get currentHub => _hub;
+
+  /// Initializes the SDK
   static void init(OptionsConfiguration optionsConfiguration) {
     final options = SentryOptions();
     optionsConfiguration(options);
+    _init(options);
+  }
+
+  /// Initializes the SDK
+  static void _init(SentryOptions options) {
+    if (isEnabled) {
+      options.logger(
+        SeverityLevel.warning,
+        'Sentry has been already initialized. Previous configuration will be overwritten.',
+      );
+    }
+
+    final hub = currentHub;
     _hub = Hub(options);
+    hub.close();
   }
 
   /// Reports an [event] to Sentry.io.
   static Future<SentryId> captureEvent(Event event) async {
-    return _hub.captureEvent(event);
+    return currentHub.captureEvent(event);
   }
 
   /// Reports the [exception] and optionally its [stackTrace] to Sentry.io.
   static Future<SentryId> captureException(
     dynamic error, {
     dynamic stackTrace,
   }) async {
-    return _hub.captureException(error, stackTrace: stackTrace);
+    return currentHub.captureException(error, stackTrace: stackTrace);
+  }
+
+  Future<SentryId> captureMessage(
+    String message, {
+    SeverityLevel level,
+    String template,
+    List<dynamic> params,
+  }) async {
+    return currentHub.captureMessage(
+      message,
+      level: level,
+      template: template,
+      params: params,
+    );
   }
 
   /// Close the client SDK
-  static Future<void> close() async => _hub.close();
+  static Future<void> close() async => currentHub.close();
+
+  /// Check if the current Hub is enabled/active.
+  static bool get isEnabled => currentHub.isEnabled;
 
   /// client injector only use for testing
   @visibleForTesting
-  static void initClient(SentryClient client) => _hub.bindClient(client);
+  static void initClient(SentryClient client) => currentHub.bindClient(client);
 }

dart/test/hub_test.dart

@@ -70,13 +70,18 @@ void main() {
     test('should capture exception', () {
       hub.captureException(fakeException);
 
-      verify(client.captureException(fakeException)).called(1);
+      verify(client.captureException(fakeException, scope: anyNamed('scope')))
+          .called(1);
     });
 
     test('should capture message', () {
       hub.captureMessage(fakeMessage.formatted, level: SeverityLevel.info);
       verify(
-        client.captureMessage(fakeMessage.formatted, level: SeverityLevel.info),
+        client.captureMessage(
+          fakeMessage.formatted,
+          level: SeverityLevel.info,
+          scope: anyNamed('scope'),
+        ),
       ).called(1);
     });
   });

dart/test/sentry_test.dart

@@ -47,7 +47,11 @@ void main() {
     test('should capture the exception', () async {
       await Sentry.captureException(anException);
       verify(
-        client.captureException(anException, stackTrace: null),
+        client.captureException(
+          anException,
+          stackTrace: null,
+          scope: anyNamed('scope'),
+        ),
       ).called(1);
     });
   });

dart/test/stack_trace_test.dart

@@ -80,6 +80,7 @@ void main() {
     });
 
     test('allows changing the stack frame list before sending', () {
+      // ignore: omit_local_variable_types
       final StackFrameFilter filter =
           (list) => list.where((f) => f['abs_path'] != 'secret.dart').toList();