- hub capture exception

dart/example/main.dart

@@ -26,11 +26,6 @@ Future<void> main(List<String> rawArgs) async {
   final response = await Sentry.captureEvent(event);
 
   print('SentryId : ${response.id}');
-  /*if (response.isSuccessful) {
-    print('SUCCESS\nid: ${response.eventId}');
-  } else {
-    print('FAILURE: ${response.error}');
-  }*/
 
   try {
     await foo();

dart/lib/src/hub.dart

@@ -94,13 +94,46 @@ class Hub implements HubInterface {
   }
 
   @override
-  SentryId captureException({Message message, SeverityLevel level}) {
-    // TODO: implement captureException
-    throw UnimplementedError();
+  Future<SentryId> captureException(
+      {dynamic throwable, dynamic stackTrace}) async {
+    var sentryId = SentryId.empty();
+
+    if (!_isEnabled) {
+      _options.logger(
+        SeverityLevel.warning,
+        "Instance is disabled and this 'captureException' call is a no-op.",
+      );
+    } else if (throwable == null) {
+      _options.logger(
+        SeverityLevel.warning,
+        'captureException called with null parameter.',
+      );
+    } else {
+      final item = _stack.last;
+      if (item != null) {
+        try {
+          sentryId = await item.client
+              .captureException(exception: throwable, stackTrace: stackTrace);
+        } catch (err) {
+          _options.logger(
+            SeverityLevel.error,
+            'Error while capturing event with id: ${throwable}',
+          );
+        }
+      } else {
+        _options.logger(
+          SeverityLevel.fatal,
+          'Stack peek was null when captureException',
+        );
+      }
+    }
+    _lastEventId = sentryId;
+    return sentryId;
   }
 
   @override
-  SentryId captureMessage({Message message, SeverityLevel level}) {
+  Future<SentryId> captureMessage(
+      {Message message, SeverityLevel level}) async {
     // TODO: implement captureMessage
     throw UnimplementedError();
   }
@@ -238,10 +271,10 @@ abstract class HubInterface {
   Future<SentryId> captureEvent(Event event);
 
   /// Captures the exception
-  SentryId captureException({Message message, SeverityLevel level});
+  Future<SentryId> captureException({dynamic throwable, dynamic stackTrace});
 
   /// Captures the message.
-  SentryId captureMessage({Message message, SeverityLevel level});
+  Future<SentryId> captureMessage({Message message, SeverityLevel level});
 
   /// Starts a new session. If there's a running session, it ends it before starting the new one.
   void startSession();

dart/lib/src/sentry.dart

@@ -42,8 +42,8 @@ class Sentry {
     dynamic stackTrace,
   }) async {
     return _hub.captureException(
-      message: error,
-      //stackTrace: stackTrace,
+      throwable: error,
+      stackTrace: stackTrace,
     );
   }
 

dart/lib/src/sentry_options.dart

@@ -63,6 +63,6 @@ class SentryOptions {
   }) : _logger = logger;
 }
 
-void defaultLogger({SeverityLevel level, String message}) {
+void defaultLogger(SeverityLevel level, String message) {
   print('[$level] $message');
 }

dart/test/sentry_test.dart

@@ -12,6 +12,7 @@ void main() {
 
     setUp(() {
       Sentry.init((options) => options.dsn = fakeDns);
+      anException = Exception('anException');
 
       client = MockSentryClient();
       Sentry.initClient(client);
@@ -22,9 +23,29 @@ void main() {
       verify(client.captureEvent(event: event)).called(1);
     });
 
-    test('should capture the exception', () {
-      Sentry.captureException(anException);
-      verify(client.captureException(exception: anException)).called(1);
+    test('should not capture a null event', () async {
+      await Sentry.captureEvent(null);
+      verifyNever(client.captureEvent(event: event));
+    });
+
+    test('should not capture a null exception', () async {
+      await Sentry.captureException(null);
+      verifyNever(
+        client.captureException(
+          exception: anyNamed('exception'),
+          stackTrace: anyNamed('stackTrace'),
+        ),
+      );
+    });
+
+    test('should capture the exception', () async {
+      await Sentry.captureException(anException);
+      verify(
+        client.captureException(
+          exception: anException,
+          stackTrace: null,
+        ),
+      ).called(1);
     });
   });
 }