feat(js-sdk): use js transport

dart/lib/src/client_reports/client_report.dart

@@ -1,10 +1,10 @@
 import 'package:meta/meta.dart';
 
+import '../../sentry.dart';
 import 'discarded_event.dart';
-import '../utils.dart';
 
 @internal
-class ClientReport {
+class ClientReport implements SentryEnvelopeItemPayload {
   ClientReport(this.timestamp, this.discardedEvents);
 
   final DateTime? timestamp;
@@ -27,4 +27,7 @@ class ClientReport {
 
     return json;
   }
+
+  @override
+  Future<dynamic> asPayload() => Future.value(toJson());
 }

dart/lib/src/platform_checker.dart

@@ -1,4 +1,5 @@
 import 'dart:async';
+
 import 'platform/platform.dart';
 
 /// Helper to check in which environment the library is running.

dart/lib/src/protocol/sentry_event.dart

@@ -1,14 +1,14 @@
-import 'package:meta/meta.dart';
 import 'package:collection/collection.dart';
+import 'package:meta/meta.dart';
 
-import '../protocol.dart';
-import '../throwable_mechanism.dart';
-import '../utils.dart';
+import '../../sentry.dart';
 import 'access_aware_map.dart';
 
 /// An event to be reported to Sentry.io.
 @immutable
-class SentryEvent with SentryEventLike<SentryEvent> {
+class SentryEvent
+    with SentryEventLike<SentryEvent>
+    implements SentryEnvelopeItemPayload {
   /// Creates an event.
   SentryEvent({
     SentryId? eventId,
@@ -418,4 +418,7 @@ class SentryEvent with SentryEventLike<SentryEvent> {
   SentryStackTrace? get stacktrace =>
       exceptions?.firstWhereOrNull((e) => e.stackTrace != null)?.stackTrace ??
       threads?.firstWhereOrNull((t) => t.stacktrace != null)?.stacktrace;
+
+  @override
+  Future<dynamic> asPayload() => Future.value(toJson());
 }

dart/lib/src/sentry_attachment/sentry_attachment.dart

@@ -1,16 +1,15 @@
 import 'dart:async';
 import 'dart:typed_data';
 
-import '../protocol/sentry_view_hierarchy.dart';
-import '../utils.dart';
+import '../../sentry.dart';
 
 // https://develop.sentry.dev/sdk/features/#attachments
 // https://develop.sentry.dev/sdk/envelopes/#attachment
 
 typedef ContentLoader = FutureOr<Uint8List> Function();
 
 /// Arbitrary content which gets attached to an event.
-class SentryAttachment {
+class SentryAttachment implements SentryEnvelopeItemPayload {
   /// Standard attachment without special meaning.
   static const String typeAttachmentDefault = 'event.attachment';
 
@@ -122,4 +121,7 @@ class SentryAttachment {
   /// If true, attachment should be added to every transaction.
   /// Defaults to false.
   final bool addToTransactions;
+
+  @override
+  Future<dynamic> asPayload() async => await bytes;
 }

dart/lib/src/sentry_envelope_item.dart

@@ -10,10 +10,14 @@ import 'sentry_item_type.dart';
 import 'sentry_user_feedback.dart';
 import 'utils.dart';
 
+abstract class SentryEnvelopeItemPayload {
+  Future<dynamic> asPayload();
+}
+
 /// Item holding header information and JSON encoded data.
 class SentryEnvelopeItem {
   /// The original, non-encoded object, used when direct access to the source data is needed.
-  Object? originalObject;
+  SentryEnvelopeItemPayload? originalObject;
 
   SentryEnvelopeItem(this.header, this.dataFactory, {this.originalObject});
 
@@ -102,7 +106,7 @@ class SentryEnvelopeItem {
     return SentryEnvelopeItem(
       header,
       dataFactory,
-      originalObject: buckets,
+      originalObject: null,
     );
   }
 

dart/lib/src/sentry_user_feedback.dart

@@ -1,10 +1,10 @@
 import 'package:meta/meta.dart';
 
-import 'protocol.dart';
+import '../sentry.dart';
 import 'protocol/access_aware_map.dart';
 
 @Deprecated('Will be removed in a future version. Use [SentryFeedback] instead')
-class SentryUserFeedback {
+class SentryUserFeedback implements SentryEnvelopeItemPayload {
   SentryUserFeedback({
     required this.eventId,
     this.name,
@@ -66,4 +66,7 @@ class SentryUserFeedback {
       unknown: unknown,
     );
   }
+
+  @override
+  Future<dynamic> asPayload() => Future.value(toJson());
 }

dart/lib/src/version.dart

@@ -9,7 +9,7 @@
 library version;
 
 /// The SDK version reported to Sentry.io in the submitted events.
-const String sdkVersion = '8.12.0-beta.2';
+const String sdkVersion = '8.12.0';
 
 String sdkName(bool isWeb) => isWeb ? _browserSdkName : _ioSdkName;
 

flutter/example/integration_test/web_sdk_test.dart

@@ -3,12 +3,14 @@
 @TestOn('browser')
 library flutter_test;
 
+import 'dart:async';
 import 'dart:js_interop';
 import 'dart:js_interop_unsafe';
 
 import 'package:flutter_test/flutter_test.dart';
 import 'package:integration_test/integration_test.dart';
 import 'package:sentry_flutter/sentry_flutter.dart';
+import 'package:sentry_flutter/src/web/javascript_transport.dart';
 import 'package:sentry_flutter_example/main.dart' as app;
 
 import 'utils.dart';
@@ -17,7 +19,30 @@ import 'utils.dart';
 external JSObject get globalThis;
 
 @JS('Sentry.getClient')
-external JSObject? _getClient();
+external SentryClient? _getClient();
+
+@JS()
+@staticInterop
+class SentryClient {
+  external factory SentryClient();
+}
+
+extension _SentryClientExtension on SentryClient {
+  external void on(JSString event, JSFunction callback);
+
+  external SentryOptions getOptions();
+}
+
+@JS()
+@staticInterop
+class SentryOptions {
+  external factory SentryOptions();
+}
+
+extension _SentryOptionsExtension on SentryOptions {
+  external JSString get dsn;
+  external JSArray get defaultIntegrations;
+}
 
 void main() {
   group('Web SDK Integration', () {
@@ -37,16 +62,67 @@ void main() {
         expect(globalThis['Sentry'], isNotNull);
 
         final client = _getClient()!;
-        final options = client.callMethod('getOptions'.toJS)! as JSObject;
+        final options = client.getOptions();
+
+        final dsn = options.dsn.toDart;
+        final defaultIntegrations = options.defaultIntegrations.toDart;
 
-        final dsn = options.getProperty('dsn'.toJS).toString();
-        final defaultIntegrations = options
-            .getProperty('defaultIntegrations'.toJS)
-            .dartify() as List<Object?>;
+        await Sentry.captureException(Exception('test'));
 
         expect(dsn, fakeDsn);
         expect(defaultIntegrations, isEmpty);
       });
+
+      testWidgets('sends the correct envelope', (tester) async {
+        SentryFlutterOptions? configuredOptions;
+        SentryEvent? dartEvent;
+
+        await restoreFlutterOnErrorAfter(() async {
+          await SentryFlutter.init((options) {
+            options.enableSentryJs = true;
+            options.dsn = app.exampleDsn;
+            options.beforeSend = (event, hint) {
+              dartEvent = event;
+              return event;
+            };
+            configuredOptions = options;
+          }, appRunner: () async {
+            await tester.pumpWidget(const app.MyApp());
+          });
+        });
+
+        expect(configuredOptions!.transport, isA<JavascriptTransport>());
+
+        final client = _getClient()!;
+        final completer = Completer<List<Object?>>();
+
+        JSFunction beforeEnvelopeCallback = ((JSArray envelope) {
+          final envelopDart = envelope.dartify() as List<Object?>;
+          completer.complete(envelopDart);
+        }).toJS;
+
+        client.on('beforeEnvelope'.toJS, beforeEnvelopeCallback);
+
+        final id = await Sentry.captureException(Exception('test'));
+
+        final envelope = await completer.future;
+
+        final header = envelope.first as Map<Object?, Object?>;
+        expect(header['event_id'], id.toString());
+        expect((header['sdk'] as Map<Object?, Object?>)['name'],
+            'sentry.dart.flutter');
+
+        final item = (envelope[1] as List<Object?>).first as List<Object?>;
+        final itemPayload = item[1] as Map<Object?, Object?>;
+        final jsEventJson = (itemPayload).map((key, value) {
+          return MapEntry(key.toString(), value as dynamic);
+        });
+        final dartEventJson = dartEvent!.toJson();
+
+        // Make sure what we send from the Flutter layer is the same as what's being
+        // sent in the JS layer
+        expect(jsEventJson, equals(dartEventJson));
+      });
     });
 
     group('disabled', () {

flutter/lib/src/integrations/web_sdk_integration.dart

@@ -5,6 +5,7 @@ import 'package:sentry/sentry.dart';
 
 import '../native/sentry_native_binding.dart';
 import '../sentry_flutter_options.dart';
+import '../web/javascript_transport.dart';
 import '../web/script_loader/sentry_script_loader.dart';
 import '../web/sentry_js_bundle.dart';
 
@@ -38,6 +39,9 @@ class WebSdkIntegration implements Integration<SentryFlutterOptions> {
           : productionScripts;
       await _scriptLoader.loadWebSdk(scripts);
       await _web.init(hub);
+      if (_web.supportsCaptureEnvelope) {
+        options.transport = JavascriptTransport(_web, options);
+      }
       options.sdk.addIntegration(name);
     } catch (exception, stackTrace) {
       options.logger(

flutter/lib/src/native/c/sentry_native.dart

@@ -104,6 +104,11 @@
     throw UnsupportedError('$SentryNative.captureEnvelope() is not supported');
   }
 
+  @override
+  FutureOr<void> captureEnvelopeObject(SentryEnvelope envelope) {
+    throw UnsupportedError("Not supported on this platform");
+  }
+
   @override
   FutureOr<void> beginNativeFrames() {}
 

flutter/lib/src/native/sentry_native_binding.dart

@@ -22,6 +22,8 @@ abstract class SentryNativeBinding {
   FutureOr<void> captureEnvelope(
       Uint8List envelopeData, bool containsUnhandledException);
 
+  FutureOr<void> captureEnvelopeObject(SentryEnvelope envelope);
+
   FutureOr<void> beginNativeFrames();
 
   FutureOr<NativeFrames?> endNativeFrames(SentryId id);

flutter/lib/src/native/sentry_native_channel.dart

@@ -97,6 +97,11 @@
         'captureEnvelope', [envelopeData, containsUnhandledException]);
   }
 
+  @override
+  FutureOr<void> captureEnvelopeObject(SentryEnvelope envelope) {
+    throw UnsupportedError("Not supported on this platform");
+  }
+
   @override
   bool get supportsLoadContexts => true;
 

flutter/lib/src/sentry_flutter.dart

@@ -123,7 +123,12 @@ mixin SentryFlutter {
     // Not all platforms have a native integration.
     if (_native != null) {
       if (_native!.supportsCaptureEnvelope) {
-        options.transport = FileSystemTransport(_native!, options);
+        // Sentry's native web integration is only enabled when enableSentryJs=true.
+        // Transport configuration happens in web_integration because the configuration
+        // options aren't available until after the options callback executes.
+        if (!options.platformChecker.isWeb) {
+          options.transport = FileSystemTransport(_native!, options);
+        }
       }
       if (!options.platformChecker.isWeb) {
         options.addScopeObserver(NativeScopeObserver(_native!));

flutter/lib/src/web/html_sentry_js_binding.dart

@@ -10,11 +10,13 @@ class HtmlSentryJsBinding implements SentryJsBinding {
   HtmlSentryJsBinding({JsObject? sentry}) : _sentry = sentry;
 
   JsObject? _sentry;
+  dynamic _client;
 
   @override
   void init(Map<String, dynamic> options) {
     _sentry ??= context['Sentry'] as JsObject;
     _sentry!.callMethod('init', [JsObject.jsify(options)]);
+    _client = _sentry!.callMethod('getClient');
   }
 
   @override
@@ -25,4 +27,11 @@ class HtmlSentryJsBinding implements SentryJsBinding {
       context['Sentry'] = null;
     }
   }
+
+  @override
+  void captureEnvelope(List<Object> envelope) {
+    if (_client != null) {
+      _client.callMethod('sendEnvelope', [JsObject.jsify(envelope)]);
+    }
+  }
 }

flutter/lib/src/web/javascript_transport.dart

@@ -0,0 +1,26 @@
+import '../../sentry_flutter.dart';
+import '../native/sentry_native_binding.dart';
+
+class JavascriptTransport implements Transport {
+  JavascriptTransport(this._binding, this._options);
+
+  final SentryFlutterOptions _options;
+  final SentryNativeBinding _binding;
+
+  @override
+  Future<SentryId?> send(SentryEnvelope envelope) async {
+    try {
+      await _binding.captureEnvelopeObject(envelope);
+    } catch (exception, stackTrace) {
+      _options.logger(
+        SentryLevel.error,
+        'Failed to send envelope',
+        exception: exception,
+        stackTrace: stackTrace,
+      );
+      return Future.value(SentryId.empty());
+    }
+
+    return envelope.header.eventId;
+  }
+}

flutter/lib/src/web/noop_sentry_js_binding.dart

@@ -12,4 +12,7 @@ class NoOpSentryJsBinding implements SentryJsBinding {
 
   @override
   void close() {}
+
+  @override
+  void captureEnvelope(List<Object> envelope) {}
 }

flutter/lib/src/web/sentry_js_binding.dart

@@ -5,4 +5,5 @@ export 'noop_sentry_js_binding.dart'
 abstract class SentryJsBinding {
   void init(Map<String, dynamic> options);
   void close();
+  void captureEnvelope(List<Object> envelope);
 }