Report Flutter framework feature flags

CHANGELOG.md

@@ -18,6 +18,8 @@
 // configure your feedback widget
 options.feedback.showBranding = false;
 ```
+- Report Flutter framework feature flags ([#2991](https://github.com/getsentry/sentry-dart/pull/2991))
+  - This works on Flutter builds that include [this PR](https://github.com/flutter/flutter/pull/171545)
 
 ## 9.2.0
 

flutter/lib/src/integrations/flutter_framework_feature_flag_integration.dart

@@ -0,0 +1,42 @@
+import 'dart:async';
+
+import 'package:flutter/foundation.dart';
+import 'package:sentry/sentry.dart';
+
+const _featureFlag = 'FLUTTER_ENABLED_FEATURE_FLAGS';
+
+// The Flutter framework feature flag works like this:
+// An enabled (experimental) feature gets added to the `FLUTTER_ENABLED_FEATURE_FLAGS`
+// dart define. Being in there means the feature is enabled, the feature is disabled
+// if it's not in there.
+// As a result, we also don't know the whole list of flags, but only the active ones.
+//
+// See https://github.com/flutter/flutter/pull/168437
+class FlutterFrameworkFeatureFlagIntegration
+    extends Integration<SentryOptions> {
+  final String flags;
+
+  FlutterFrameworkFeatureFlagIntegration({
+    @visibleForTesting this.flags = const String.fromEnvironment(_featureFlag),
+  });
+
+  @override
+  FutureOr<void> call(Hub hub, SentryOptions options) {
+    final enabledFeatureFlags = flags.split(',');
+
+    for (final featureFlag in enabledFeatureFlags) {
+      Sentry.addFeatureFlag(featureFlag, true);
+    }
+    options.sdk.addIntegration('FlutterFrameworkFeatureFlag');
+  }
+}
+
+extension FlutterFrameworkFeatureFlagIntegrationX
+    on List<Integration<SentryOptions>> {
+  /// For better tree-shake-ability we only add the integration if any feature flag is enabled.
+  void addFlutterFrameworkFeatureFlagIntegration() {
+    if (const bool.hasEnvironment(_featureFlag)) {
+      add(FlutterFrameworkFeatureFlagIntegration());
+    }
+  }
+}

flutter/lib/src/sentry_flutter.dart

@@ -18,6 +18,7 @@ import 'file_system_transport.dart';
 import 'flutter_exception_type_identifier.dart';
 import 'frame_callback_handler.dart';
 import 'integrations/connectivity/connectivity_integration.dart';
+import 'integrations/flutter_framework_feature_flag_integration.dart';
 import 'integrations/frames_tracking_integration.dart';
 import 'integrations/integrations.dart';
 import 'integrations/native_app_start_handler.dart';
@@ -172,6 +173,9 @@ mixin SentryFlutter {
     // This tracks Flutter application events, such as lifecycle events.
     integrations.add(WidgetsBindingIntegration());
 
+    // Adds Flutter framework feature flags.
+    integrations.addFlutterFrameworkFeatureFlagIntegration();
+
     // The ordering here matters, as we'd like to first start the native integration.
     // That allow us to send events to the network and then the Flutter integrations.
     final native = _native;

flutter/test/integrations/flutter_framework_feature_flag_integration_test.dart

@@ -0,0 +1,63 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:sentry/sentry.dart';
+import 'package:sentry_flutter/src/integrations/flutter_framework_feature_flag_integration.dart';
+
+void main() {
+  group(FlutterFrameworkFeatureFlagIntegration, () {
+    late Fixture fixture;
+
+    setUp(() async {
+      fixture = Fixture();
+
+      await Sentry.init((options) {
+        options.dsn = 'https://example.com/sentry-dsn';
+      });
+
+      // ignore: invalid_use_of_internal_member
+      fixture.hub = Sentry.currentHub;
+      // ignore: invalid_use_of_internal_member
+      fixture.options = fixture.hub.options;
+    });
+
+    tearDown(() {
+      Sentry.close();
+    });
+
+    test('adds sdk integration', () {
+      final sut = fixture.getSut('foo,bar,baz');
+      sut.call(fixture.hub, fixture.options);
+
+      expect(
+          fixture.options.sdk.integrations
+              .contains('FlutterFrameworkFeatureFlag'),
+          true);
+    });
+
+    test('adds feature flags', () {
+      final sut = fixture.getSut('foo,bar,baz');
+      sut.call(fixture.hub, fixture.options);
+
+      // ignore: invalid_use_of_internal_member
+      final featureFlags = fixture.hub.scope.contexts[SentryFeatureFlags.type]
+          as SentryFeatureFlags?;
+
+      expect(featureFlags, isNotNull);
+      expect(featureFlags?.values.length, 3);
+      expect(featureFlags?.values.first.flag, 'foo');
+      expect(featureFlags?.values.first.result, true);
+      expect(featureFlags?.values[1].flag, 'bar');
+      expect(featureFlags?.values[1].result, true);
+      expect(featureFlags?.values[2].flag, 'baz');
+      expect(featureFlags?.values[2].result, true);
+    });
+  });
+}
+
+class Fixture {
+  late Hub hub;
+  late SentryOptions options;
+
+  FlutterFrameworkFeatureFlagIntegration getSut(String features) {
+    return FlutterFrameworkFeatureFlagIntegration(flags: features);
+  }
+}