HackWeek - Feature Flags Support

dart/example/bin/example.dart

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 import 'dart:async';
+import 'dart:collection';
 
 import 'package:sentry/sentry.dart';
 
@@ -11,84 +12,42 @@ import 'event_example.dart';
 /// Sends a test exception report to Sentry.io using this Dart client.
 Future<void> main() async {
   // ATTENTION: Change the DSN below with your own to see the events in Sentry. Get one at sentry.io
+  // const dsn =
+  //     'https://9934c532bf8446ef961450973c898537@o447951.ingest.sentry.io/5428562';
   const dsn =
-      'https://9934c532bf8446ef961450973c898537@o447951.ingest.sentry.io/5428562';
+      'https://60d3409215134fd1a60765f2400b6b38@ac75-72-74-53-151.ngrok.io/1';
 
   await Sentry.init(
     (options) => options
       ..dsn = dsn
       ..debug = true
-      ..sendDefaultPii = true
-      ..addEventProcessor(TagEventProcessor()),
+      ..release = 'myapp@1.0.0+1'
+      ..environment = 'prod',
     appRunner: runApp,
   );
-}
-
-Future<void> runApp() async {
-  print('\nReporting a complete event example: ');
-
-  Sentry.addBreadcrumb(
-    Breadcrumb(
-      message: 'Authenticated user',
-      category: 'auth',
-      type: 'debug',
-      data: {
-        'admin': true,
-        'permissions': [1, 2, 3]
-      },
-    ),
-  );
-
   await Sentry.configureScope((scope) async {
-    await scope.setUser(SentryUser(
-      id: '800',
-      username: 'first-user',
-      email: 'first@user.lan',
-      // ipAddress: '127.0.0.1', sendDefaultPii feature is enabled
-      extras: <String, String>{'first-sign-in': '2020-01-01'},
-    ));
-    scope
-      // ..fingerprint = ['example-dart'], fingerprint forces events to group together
-      ..transaction = '/example/app'
-      ..level = SentryLevel.warning;
-    await scope.setTag('build', '579');
-    await scope.setExtra('company-name', 'Dart Inc');
+    await scope.setUser(
+      SentryUser(
+        id: '800',
+      ),
+    );
   });
 
-  // Sends a full Sentry event payload to show the different parts of the UI.
-  final sentryId = await Sentry.captureEvent(event);
-
-  print('Capture event result : SentryId : $sentryId');
-
-  print('\nCapture message: ');
-
-  // Sends a full Sentry event payload to show the different parts of the UI.
-  final messageSentryId = await Sentry.captureMessage(
-    'Message 1',
-    level: SentryLevel.warning,
-    template: 'Message %s',
-    params: ['1'],
+  final enabled = await Sentry.isFeatureEnabled(
+    '@@accessToProfiling',
+    defaultValue: false,
+    context: (myContext) => {
+      myContext.tags['stickyId'] = 'myCustomStickyId',
+    },
   );
+  print(enabled);
 
-  print('Capture message result : SentryId : $messageSentryId');
-
-  try {
-    await loadConfig();
-  } catch (error, stackTrace) {
-    print('\nReporting the following stack trace: ');
-    print(stackTrace);
-    final sentryId = await Sentry.captureException(
-      error,
-      stackTrace: stackTrace,
-    );
-
-    print('Capture exception result : SentryId : $sentryId');
-  }
-
-  // capture unhandled error
-  await loadConfig();
+  // TODO: does it return the active EvaluationRule? do we create a new model for that?
+  final flag = await Sentry.getFeatureFlagInfo('test');
 }
 
+Future<void> runApp() async {}
+
 Future<void> loadConfig() async {
   await parseConfig();
 }

dart/lib/sentry.dart

@@ -27,6 +27,13 @@ export 'src/http_client/sentry_http_client.dart';
 export 'src/http_client/sentry_http_client_error.dart';
 export 'src/sentry_attachment/sentry_attachment.dart';
 export 'src/sentry_user_feedback.dart';
+export 'src/transport/rate_limiter.dart';
+export 'src/transport/http_transport.dart';
 // tracing
 export 'src/tracing.dart';
 export 'src/sentry_measurement.dart';
+// feature flags
+export 'src/feature_flags/feature_flag.dart';
+export 'src/feature_flags/evaluation_rule.dart';
+export 'src/feature_flags/evaluation_type.dart';
+export 'src/feature_flags/feature_flag_context.dart';

dart/lib/src/feature_flags/evaluation_rule.dart

@@ -0,0 +1,37 @@
+import 'package:meta/meta.dart';
+import 'evaluation_type.dart';
+
+@immutable
+class EvaluationRule {
+  final EvaluationType type;
+  final double? percentage;
+  final dynamic result;
+  final Map<String, dynamic> _tags;
+  final Map<String, dynamic>? _payload;
+
+  Map<String, dynamic> get tags => Map.unmodifiable(_tags);
+
+  Map<String, dynamic>? get payload =>
+      _payload != null ? Map.unmodifiable(_payload!) : null;
+
+  EvaluationRule(
+    this.type,
+    this.percentage,
+    this.result,
+    this._tags,
+    this._payload,
+  );
+
+  factory EvaluationRule.fromJson(Map<String, dynamic> json) {
+    final payload = json['payload'];
+    final tags = json['tags'];
+
+    return EvaluationRule(
+      (json['type'] as String).toEvaluationType(),
+      json['percentage'] as double?,
+      json['result'],
+      tags != null ? Map<String, dynamic>.from(tags) : {},
+      payload != null ? Map<String, dynamic>.from(payload) : null,
+    );
+  }
+}

dart/lib/src/feature_flags/evaluation_type.dart

@@ -0,0 +1,18 @@
+enum EvaluationType {
+  match,
+  rollout,
+  none,
+}
+
+extension EvaluationTypeEx on String {
+  EvaluationType toEvaluationType() {
+    switch (this) {
+      case 'match':
+        return EvaluationType.match;
+      case 'rollout':
+        return EvaluationType.rollout;
+      default:
+        return EvaluationType.none;
+    }
+  }
+}

dart/lib/src/feature_flags/feature_dump.dart

@@ -0,0 +1,24 @@
+import 'package:meta/meta.dart';
+
+import 'feature_flag.dart';
+
+@immutable
+class FeatureDump {
+  final Map<String, FeatureFlag> featureFlags;
+
+  FeatureDump(this.featureFlags);
+
+  factory FeatureDump.fromJson(Map<String, dynamic> json) {
+    final featureFlagsJson = json['feature_flags'] as Map?;
+    Map<String, FeatureFlag> featureFlags = {};
+
+    if (featureFlagsJson != null) {
+      for (final value in featureFlagsJson.entries) {
+        final featureFlag = FeatureFlag.fromJson(value.value);
+        featureFlags[value.key] = featureFlag;
+      }
+    }
+
+    return FeatureDump(featureFlags);
+  }
+}

dart/lib/src/feature_flags/feature_flag.dart

@@ -0,0 +1,29 @@
+import 'package:meta/meta.dart';
+
+import 'evaluation_rule.dart';
+
+@immutable
+class FeatureFlag {
+  // final Map<String, dynamic> _tags;
+  final List<EvaluationRule> _evaluations;
+  final String kind;
+
+  // Map<String, dynamic> get tags => Map.unmodifiable(_tags);
+
+  List<EvaluationRule> get evaluations => List.unmodifiable(_evaluations);
+
+  FeatureFlag(this.kind, this._evaluations);
+
+  factory FeatureFlag.fromJson(Map<String, dynamic> json) {
+    final kind = json['kind'];
+    final evaluationsList = json['evaluation'] as List<dynamic>? ?? [];
+    final evaluations = evaluationsList
+        .map((e) => EvaluationRule.fromJson(e))
+        .toList(growable: false);
+
+    return FeatureFlag(
+      kind,
+      evaluations,
+    );
+  }
+}

dart/lib/src/feature_flags/feature_flag_context.dart

@@ -0,0 +1,11 @@
+typedef FeatureFlagContextCallback = void Function(FeatureFlagContext context);
+
+class FeatureFlagContext {
+  // String stickyId;
+  // String userId;
+  // String deviceId;
+  Map<String, dynamic> tags = {};
+
+  // FeatureFlagContext(this.stickyId, this.userId, this.deviceId, this.tags);
+  FeatureFlagContext(this.tags);
+}

dart/lib/src/feature_flags/xor_shift_rand.dart

@@ -0,0 +1,47 @@
+import 'dart:convert';
+
+import 'package:crypto/crypto.dart';
+
+/// final rand = XorShiftRandom('wohoo');
+/// rand.next();
+class XorShiftRandom {
+  List<int> state = [0, 0, 0, 0];
+  static const mask = 0xffffffff;
+
+  XorShiftRandom(String seed) {
+    _seed(seed);
+  }
+
+  void _seed(String seed) {
+    final encoded = utf8.encode(seed);
+    final bytes = sha1.convert(encoded).bytes;
+    final slice = bytes.sublist(0, 16);
+
+    for (var i = 0; i < state.length; i++) {
+      final unpack = (slice[i * 4] << 24) |
+          (slice[i * 4 + 1] << 16) |
+          (slice[i * 4 + 2] << 8) |
+          (slice[i * 4 + 3]);
+      state[i] = unpack;
+    }
+  }
+
+  double next() {
+    return nextu32() / mask;
+  }
+
+  int nextu32() {
+    var t = state[3];
+    final s = state[0];
+
+    state[3] = state[2];
+    state[2] = state[1];
+    state[1] = s;
+
+    t = (t << 11) & mask;
+    t ^= t >> 8;
+    state[0] = (t ^ s ^ (s >> 19)) & mask;
+
+    return state[0];
+  }
+}

dart/lib/src/hub.dart

@@ -518,6 +518,63 @@ class Hub {
     }
     return event;
   }
+
+  Future<bool> isFeatureEnabled(
+    String key, {
+    bool defaultValue = false,
+    FeatureFlagContextCallback? context,
+  }) async {
+    if (!_isEnabled) {
+      _options.logger(
+        SentryLevel.warning,
+        "Instance is disabled and this 'isFeatureEnabled' call is a no-op.",
+      );
+      return defaultValue;
+    }
+
+    try {
+      final item = _peek();
+
+      return item.client.isFeatureEnabled(
+        key,
+        scope: item.scope,
+        defaultValue: defaultValue,
+        context: context,
+      );
+    } catch (exception, stacktrace) {
+      _options.logger(
+        SentryLevel.error,
+        'Error while fetching feature flags',
+        exception: exception,
+        stackTrace: stacktrace,
+      );
+    }
+    return defaultValue;
+  }
+
+  Future<FeatureFlag?> getFeatureFlagInfo(String key) async {
+    if (!_isEnabled) {
+      _options.logger(
+        SentryLevel.warning,
+        "Instance is disabled and this 'getFeatureFlagInfo' call is a no-op.",
+      );
+      return null;
+    }
+
+    try {
+      final item = _peek();
+
+      return item.client.getFeatureFlagInfo(key);
+    } catch (exception, stacktrace) {
+      _options.logger(
+        SentryLevel.error,
+        'Error while fetching feature flags',
+        exception: exception,
+        stackTrace: stacktrace,
+      );
+    }
+    return null;
+  }
 }
 
 class _StackItem {

dart/lib/src/hub_adapter.dart

@@ -2,6 +2,8 @@ import 'dart:async';
 
 import 'package:meta/meta.dart';
 
+import 'feature_flags/feature_flag.dart';
+import 'feature_flags/feature_flag_context.dart';
 import 'hub.dart';
 import 'protocol.dart';
 import 'sentry.dart';
@@ -158,4 +160,20 @@ class HubAdapter implements Hub {
     String transaction,
   ) =>
       Sentry.currentHub.setSpanContext(throwable, span, transaction);
+
+  @override
+  Future<bool> isFeatureEnabled(
+    String key, {
+    bool defaultValue = false,
+    FeatureFlagContextCallback? context,
+  }) =>
+      Sentry.isFeatureEnabled(
+        key,
+        defaultValue: defaultValue,
+        context: context,
+      );
+
+  @override
+  Future<FeatureFlag?> getFeatureFlagInfo(String key) =>
+      Sentry.getFeatureFlagInfo(key);
 }