add options.attachStacktrace

CHANGELOG.md

@@ -12,6 +12,7 @@
 - feat: add missing protocol classes
 - fix: logger method and refactoring little things
 - fix: sentry protocol is v7
+- feat: add an attachStackTrace options
 
 ## 4.0.0-alpha.1
 

dart/lib/src/protocol/sentry_event.dart

@@ -262,6 +262,8 @@ class SentryEvent {
       json['exception'] = {
         'values': [exception.toJson()].toList(growable: false)
       };
+    } else if (stackTrace is SentryStackTrace) {
+      json['stacktrace'] = (stackTrace as SentryStackTrace).toJson();
     }
 
     if (level != null) {

dart/lib/src/sentry_client.dart

@@ -99,6 +99,15 @@ class SentryClient {
       event = event.copyWith(exception: sentryException);
     }
 
+    if (_options.attachStackTrace &&
+        event.throwable == null &&
+        event.exception == null) {
+      final frames = _exceptionFactory.stacktraceFactory
+          .getStackFrames(StackTrace.current);
+
+      event = event.copyWith(stackTrace: SentryStackTrace(frames: frames));
+    }
+
     return event;
   }
 

dart/lib/src/sentry_exception_factory.dart

@@ -8,6 +8,8 @@ import 'sentry_stack_trace_factory.dart';
 class SentryExceptionFactory {
   SentryStackTraceFactory _stacktraceFactory;
 
+  SentryStackTraceFactory get stacktraceFactory => _stacktraceFactory;
+
   SentryExceptionFactory({
     SentryStackTraceFactory stacktraceFactory,
     @required SentryOptions options,

dart/lib/src/sentry_options.dart

@@ -162,6 +162,14 @@ class SentryOptions {
     _sdk = sdk ?? _sdk;
   }
 
+  bool _attachStackTrace = true;
+
+  bool get attachStackTrace => _attachStackTrace;
+
+  set attachStackTrace(bool attachStacktrace) {
+    _attachStackTrace = attachStacktrace ?? _attachStackTrace;
+  }
+
   // TODO: Scope observers, enableScopeSync
 
   // TODO: sendDefaultPii

dart/lib/src/sentry_stack_trace_factory.dart

@@ -36,8 +36,10 @@ class SentryStackTraceFactory {
 
     final frames = <SentryStackFrame>[];
     for (var t = 0; t < chain.traces.length; t += 1) {
-      final encodedFrames =
-          chain.traces[t].frames.map((f) => encodeStackTraceFrame(f));
+      final encodedFrames = chain.traces[t].frames
+          // we don't want to add our own frames
+          .where((frame) => frame.package != 'sentry')
+          .map((f) => encodeStackTraceFrame(f));
 
       frames.addAll(encodedFrames);
 
@@ -101,14 +103,14 @@ class SentryStackTraceFactory {
 
     if (_inAppIncludes != null) {
       for (final include in _inAppIncludes) {
-        if (frame.package != null && frame.package.startsWith(include)) {
+        if (frame.package != null && frame.package == include) {
           return true;
         }
       }
     }
     if (_inAppExcludes != null) {
       for (final exclude in _inAppExcludes) {
-        if (frame.package != null && frame.package.startsWith(exclude)) {
+        if (frame.package != null && frame.package == exclude) {
           return false;
         }
       }

dart/test/sentry_client_test.dart

@@ -29,6 +29,19 @@ void main() {
       expect(capturedEvent.message.formatted, 'simple message 1');
       expect(capturedEvent.message.template, 'simple message %d');
       expect(capturedEvent.message.params, [1]);
+
+      expect(capturedEvent.stackTrace is SentryStackTrace, true);
+    });
+
+    test('should capture message without stacktrace', () async {
+      final client = SentryClient(options..attachStackTrace = false);
+      await client.captureMessage('message', level: SentryLevel.error);
+
+      final capturedEvent = (verify(
+        options.transport.send(captureAny),
+      ).captured.first) as SentryEvent;
+
+      expect(capturedEvent.stackTrace, isNull);
     });
   });
 
@@ -141,6 +154,34 @@ void main() {
       expect(capturedEvent.exception.stacktrace.frames.first.lineNo, 46);
       expect(capturedEvent.exception.stacktrace.frames.first.colNo, 9);
     });
+
+    test('should not capture sentry frames exception', () async {
+      try {
+        throw Exception('Error');
+      } catch (err) {
+        exception = err;
+      }
+
+      final stacktrace = '''
+#0      init (package:sentry/sentry.dart:46:9)
+#1      bar (file:///pathto/test.dart:46:9)
+<asynchronous suspension>
+#2      capture (package:sentry/sentry.dart:46:9)
+      ''';
+
+      final client = SentryClient(options);
+      await client.captureException(exception, stackTrace: stacktrace);
+
+      final capturedEvent = (verify(
+        options.transport.send(captureAny),
+      ).captured.first) as SentryEvent;
+
+      expect(
+        capturedEvent.exception.stacktrace.frames
+            .every((frame) => frame.package != 'sentry'),
+        true,
+      );
+    });
   });
 
   group('SentryClient : apply scope to the captured event', () {

dart/test/sentry_event_test.dart

@@ -188,6 +188,29 @@ void main() {
       expect(serialized['exception'], null);
     });
 
+    test('should serialize stacktrace if SentryStacktrace', () {
+      final stacktrace =
+          SentryStackTrace(frames: [SentryStackFrame(function: 'main')]);
+      final serialized = SentryEvent(stackTrace: stacktrace).toJson();
+      expect(serialized['stacktrace'], isNotNull);
+    });
+
+    test('should not serialize event.stacktrace if event.exception is set', () {
+      final stacktrace =
+          SentryStackTrace(frames: [SentryStackFrame(function: 'main')]);
+      final serialized = SentryEvent(
+        exception: SentryException(value: 'Bad state', type: 'StateError'),
+        stackTrace: stacktrace,
+      ).toJson();
+      expect(serialized['stacktrace'], isNull);
+    });
+
+    test('should not serialize stacktrace if not SentryStacktrace', () {
+      final stacktrace = '#0      baz (file:///pathto/test.dart:50:3)';
+      final serialized = SentryEvent(stackTrace: stacktrace).toJson();
+      expect(serialized['stacktrace'], isNull);
+    });
+
     test('serializes to JSON with sentryException', () {
       var sentryException;
       try {