draft

dart/lib/src/protocol/sdk.dart

@@ -35,24 +35,30 @@ import 'package.dart';
 @immutable
 class Sdk {
   /// Creates an [Sdk] object which represents the SDK that created an [Event].
-  const Sdk({
+  Sdk({
     @required this.name,
     @required this.version,
-    this.integrations,
-    this.packages,
-  }) : assert(name != null || version != null);
+    List<String> integrations,
+    List<Package> packages,
+  })  : assert(name != null || version != null),
+        _integrations = integrations ?? [],
+        _packages = packages ?? [];
 
   /// The name of the SDK.
   final String name;
 
   /// The version of the SDK.
   final String version;
 
+  final List<String> _integrations;
+
   /// A list of integrations enabled in the SDK that created the [Event].
-  final List<String> integrations;
+  List<String> get integrations => List.unmodifiable(_integrations);
+
+  final List<Package> _packages;
 
   /// A list of packages that compose this SDK.
-  final List<Package> packages;
+  List<Package> get packages => List.unmodifiable(_packages);
 
   String get identifier => '${name}/${version}';
 
@@ -61,13 +67,26 @@ class Sdk {
     final json = <String, dynamic>{};
     json['name'] = name;
     json['version'] = version;
+
     if (packages != null && packages.isNotEmpty) {
       json['packages'] =
           packages.map((p) => p.toJson()).toList(growable: false);
     }
+
     if (integrations != null && integrations.isNotEmpty) {
       json['integrations'] = integrations;
     }
     return json;
   }
+
+  /// Adds a package
+  void addPackage(String name, String version) {
+    final package = Package(name, version);
+    _packages.add(package);
+  }
+
+  // Adds an integration
+  void addIntegration(String integration) {
+    _integrations.add(integration);
+  }
 }

dart/lib/src/sentry_options.dart

@@ -165,7 +165,9 @@ class SentryOptions {
   // TODO: sendDefaultPii
 
   // TODO: those ctor params could be set on Sentry._setDefaultConfiguration or instantiate by default here
-  SentryOptions({this.dsn});
+  SentryOptions({this.dsn}) {
+    sdk.addPackage('pub:sentry', sdkVersion);
+  }
 
   /// Adds an event processor
   void addEventProcessor(EventProcessor eventProcessor) {

flutter/example/lib/main.dart

@@ -21,7 +21,7 @@ void main() {
             options.dsn = _exampleDsn,
 
             // release is required on Web to match the source maps
-            options.release = _release,
+            // options.release = _release,
           },
       initMyApp);
 }

flutter/lib/default_integrations.dart

@@ -0,0 +1,74 @@
+import 'dart:async';
+import 'dart:isolate';
+
+import 'package:flutter/foundation.dart';
+import 'package:sentry/sentry.dart';
+
+// TODO: we might need flags on options to disable those integrations
+// not sure if its possible to use removeIntegration for runZonedGuardedIntegration
+// because its an internal method
+
+/// integration that capture errors on the current Isolate Error handler
+void isolateErrorIntegration(Hub hub, SentryOptions options) {
+  final receivePort = RawReceivePort(
+    (dynamic error) async {
+      options.logger(SentryLevel.debug, 'Capture from IsolateError $error');
+
+      // TODO: create mechanism
+
+      // https://api.dartlang.org/stable/2.7.0/dart-isolate/Isolate/addErrorListener.html
+      // error is a list of 2 elements
+      if (error is List<dynamic> && error.length == 2) {
+        dynamic stackTrace = error.last;
+        if (stackTrace != null) {
+          stackTrace = StackTrace.fromString(stackTrace as String);
+        }
+        await Sentry.captureException(error.first, stackTrace: stackTrace);
+      }
+    },
+  );
+
+  Isolate.current.addErrorListener(receivePort.sendPort);
+}
+
+/// integration that capture errors on the FlutterError handler
+void flutterErrorIntegration(Hub hub, SentryOptions options) {
+  final defaultOnError = FlutterError.onError;
+
+  FlutterError.onError = (FlutterErrorDetails errorDetails) async {
+    options.logger(
+        SentryLevel.debug, 'Capture from onError ${errorDetails.exception}');
+
+    // TODO: create mechanism
+
+    await hub.captureException(
+      errorDetails.exception,
+      stackTrace: errorDetails.stack,
+    );
+
+    // call original handler
+    if (defaultOnError != null) {
+      defaultOnError(errorDetails);
+    }
+  };
+}
+
+/// integration that capture errors on the runZonedGuarded error handler
+Integration runZonedGuardedIntegration(
+  Function callback,
+) {
+  void integration(Hub hub, SentryOptions options) {
+    runZonedGuarded(() {
+      callback();
+    }, (exception, stackTrace) async {
+      // TODO: create mechanism
+
+      await Sentry.captureException(
+        exception,
+        stackTrace: stackTrace,
+      );
+    });
+  }
+
+  return integration;
+}

flutter/lib/sentry_flutter.dart

@@ -1,11 +1,12 @@
 import 'dart:async';
-import 'dart:isolate';
 
 import 'package:flutter/foundation.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter/widgets.dart';
+import 'package:package_info/package_info.dart';
 import 'package:sentry/sentry.dart';
 
+import 'default_integrations.dart';
 import 'version.dart';
 
 mixin SentryFlutter {
@@ -16,97 +17,68 @@ mixin SentryFlutter {
     return version;
   }
 
-  static void _flutterErrorIntegration(Hub hub, SentryOptions options) {
-    final defaultOnError = FlutterError.onError;
+  static void init(
+    OptionsConfiguration optionsConfiguration,
+    Function callback,
+  ) {
+    Sentry.init((options) async {
+      await _initDefaultValues(options, callback);
 
-    FlutterError.onError = (FlutterErrorDetails errorDetails) async {
-      options.logger(
-          SentryLevel.debug, 'Capture from onError ${errorDetails.exception}');
+      optionsConfiguration(options);
+    });
+  }
 
-      // TODO: create mechanism
+  static Future<void> _initDefaultValues(
+      SentryOptions options, Function callback) async {
+    // it is necessary to initialize Flutter method channels so that
+    // our plugin can call into the native code.
+    WidgetsFlutterBinding.ensureInitialized();
 
-      await hub.captureException(
-        errorDetails.exception,
-        stackTrace: errorDetails.stack,
-      );
+    // TODO: we could read the window and add some stuff on contexts
+    // final window = WidgetsBinding.instance.window;
 
-      // call original handler
-      if (defaultOnError != null) {
-        defaultOnError(errorDetails);
-      }
-    };
-  }
+    options.debug = kDebugMode;
 
-  static void _isolateErrorIntegration(Hub hub, SentryOptions options) {
-    final receivePort = RawReceivePort(
-      (dynamic error) async {
-        options.logger(SentryLevel.debug, 'Capture from IsolateError $error');
-
-        // TODO: create mechanism
-
-        // https://api.dartlang.org/stable/2.7.0/dart-isolate/Isolate/addErrorListener.html
-        // error is a list of 2 elements
-        if (error is List<dynamic> && error.length == 2) {
-          dynamic stackTrace = error.last;
-          if (stackTrace != null) {
-            stackTrace = StackTrace.fromString(stackTrace as String);
-          }
-          await Sentry.captureException(error.first, stackTrace: stackTrace);
-        }
-      },
-    );
+    if (!kReleaseMode) {
+      options.environment = 'debug';
+    }
 
-    Isolate.current.addErrorListener(receivePort.sendPort);
-  }
+    options.release = await _formatRelease(options);
 
-  static Integration _runZonedGuardedIntegration(
-    Function callback,
-  ) {
-    void integration(Hub hub, SentryOptions options) {
-      runZonedGuarded(() {
-        // it is necessary to initialize Flutter method channels so that
-        // our plugin can call into the native code.
-        WidgetsFlutterBinding.ensureInitialized();
-
-        // TODO: we could read the window and add some stuff on contexts
-        // final window = WidgetsBinding.instance.window;
-
-        callback();
-      }, (exception, stackTrace) async {
-        // TODO: create mechanism
-
-        await Sentry.captureException(
-          exception,
-          stackTrace: stackTrace,
-        );
-      });
-    }
+    _addDefaultIntegrations(options, callback);
 
-    return integration;
+    _setSdk(options);
   }
 
-  static void init(
-    OptionsConfiguration optionsConfiguration,
-    Function callback,
-  ) {
-    Sentry.init((options) {
-      options.debug = kDebugMode;
-
-      if (!kReleaseMode) {
-        options.environment = 'debug';
-      }
+  static Future<String> _formatRelease(SentryOptions options) async {
+    final packageInfo = await PackageInfo.fromPlatform();
 
-      // overwrite sdk info with current flutter sdk
-      options.sdk = const Sdk(name: sdkName, version: sdkVersion);
+    final release =
+        '${packageInfo.packageName}@${packageInfo.version}+${packageInfo.buildNumber}';
+    options.logger(SentryLevel.debug, 'release: $release');
+    return release;
+  }
 
-      // Throws when running on the browser
-      if (!kIsWeb) {
-        options.addIntegration(_isolateErrorIntegration);
-      }
-      options.addIntegration(_flutterErrorIntegration);
-      options.addIntegration(_runZonedGuardedIntegration(callback));
+  static void _addDefaultIntegrations(
+      SentryOptions options, Function callback) {
+    // Throws when running on the browser
+    if (!kIsWeb) {
+      options.addIntegration(isolateErrorIntegration);
+    }
+    options.addIntegration(flutterErrorIntegration);
+    options.addIntegration(runZonedGuardedIntegration(callback));
+  }
 
-      optionsConfiguration(options);
-    });
+  static void _setSdk(SentryOptions options) {
+    // overwrite sdk info with current flutter sdk
+    final sdk = Sdk(
+      name: sdkName,
+      version: sdkVersion,
+      integrations:
+          List.from(options.sdk.integrations), // otherwise its readonly
+      packages: List.from(options.sdk.packages),
+    );
+    sdk.addPackage('pub:sentry_flutter', sdkVersion);
+    options.sdk = sdk;
   }
 }

flutter/pubspec.yaml

@@ -15,6 +15,8 @@ dependencies:
     sdk: flutter
   sentry: #^4.0.0 uncomment before publishing
     path: ../dart
+  #device_info: ^1.0.0
+  package_info: ^0.4.0
 
 dev_dependencies:
   flutter_test: