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,99 +12,101 @@ 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://[email protected]/5428562';
   const dsn =
-      'https://[email protected].io/5428562';
+      'https://[email protected].io/2';
 
   await Sentry.init(
-    (options) => options
-      ..dsn = dsn
-      ..debug = true
-      ..sendDefaultPii = true
-      ..addEventProcessor(TagEventProcessor()),
+    (options) {
+      options.dsn = dsn;
+      options.debug = true;
+      options.release = '[email protected]+1';
+      options.environment = 'prod';
+      options.experimental['featureFlagsEnabled'] = true;
+    },
     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: '[email protected]',
-      // 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',
+      ),
+    );
+    // await scope.setTag('isSentryDev', 'true');
   });
 
-  // 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'],
+  // accessToProfilingRollout
+  final accessToProfilingRollout = await Sentry.isFeatureFlagEnabled(
+    'accessToProfiling',
+    defaultValue: false,
+    context: (myContext) => {
+      myContext.tags['userSegment'] = 'slow',
+    },
   );
+  print(
+      'accessToProfilingRollout $accessToProfilingRollout'); // false for user 800
+
+  // accessToProfilingMatch
+  final accessToProfilingMatch = await Sentry.isFeatureFlagEnabled(
+    'accessToProfiling',
+    defaultValue: false,
+    context: (myContext) => {
+      myContext.tags['isSentryDev'] = 'true',
+    },
+  );
+  print('accessToProfilingMatch $accessToProfilingMatch'); // returns true
+
+  // profilingEnabledMatch
+  final profilingEnabledMatch = await Sentry.isFeatureFlagEnabled(
+    'profilingEnabled',
+    defaultValue: false,
+    context: (myContext) => {
+      myContext.tags['isSentryDev'] = 'true',
+    },
+  );
+  print('profilingEnabledMatch $profilingEnabledMatch'); // returns true
 
-  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');
-  }
+  // profilingEnabledRollout
+  final profilingEnabledRollout = await Sentry.isFeatureFlagEnabled(
+    'profilingEnabled',
+    defaultValue: false,
+  );
+  print(
+      'profilingEnabledRollout $profilingEnabledRollout'); // false for user 800
+
+  // loginBannerMatch
+  final loginBannerMatch = await Sentry.getFeatureFlagValueAsync<String>(
+    'loginBanner',
+    defaultValue: 'banner0',
+    context: (myContext) => {
+      myContext.tags['isSentryDev'] = 'true',
+    },
+  );
+  print('loginBannerMatch $loginBannerMatch'); // returns banner1
 
-  // capture unhandled error
-  await loadConfig();
-}
+  // loginBannerMatch2
+  final loginBannerMatch2 = await Sentry.getFeatureFlagValueAsync<String>(
+    'loginBanner',
+    defaultValue: 'banner0',
+  );
+  print('loginBannerMatch2 $loginBannerMatch2'); // returns banner2
 
-Future<void> loadConfig() async {
-  await parseConfig();
-}
+  // tracesSampleRate
+  final tracesSampleRate = await Sentry.getFeatureFlagValueAsync<double>(
+    'tracesSampleRate',
+    defaultValue: 0.0,
+  );
+  print('tracesSampleRate $tracesSampleRate'); // returns 0.25
 
-Future<void> parseConfig() async {
-  await decode();
-}
+  // final flag = await Sentry.getFeatureFlagInfo('loginBanner',
+  //     context: (myContext) => {
+  //           myContext.tags['myCustomTag'] = 'true',
+  //         });
 
-Future<void> decode() async {
-  throw StateError('This is a test error');
+  // print(flag?.payload?['internal_setting'] ?? 'whaat');
+  // print(flag?.payload ?? {});
 }
 
-class TagEventProcessor extends EventProcessor {
-  @override
-  FutureOr<SentryEvent?> apply(SentryEvent event, {hint}) {
-    return event..tags?.addAll({'page-locale': 'en-us'});
-  }
-}
+Future<void> runApp() async {}

dart/lib/sentry.dart

@@ -27,6 +27,14 @@ 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';
+export 'src/feature_flags/feature_flag_info.dart';

dart/lib/src/cryptography/digest.dart

@@ -0,0 +1,54 @@
+// Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:typed_data';
+import '../utils/hash_code.dart';
+
+/// A message digest as computed by a `Hash` or `HMAC` function.
+class Digest {
+  /// The message digest as an array of bytes.
+  final List<int> bytes;
+
+  Digest(this.bytes);
+
+  /// Returns whether this is equal to another digest.
+  ///
+  /// This should be used instead of manual comparisons to avoid leaking
+  /// information via timing.
+  @override
+  bool operator ==(Object other) {
+    if (other is Digest) {
+      final a = bytes;
+      final b = other.bytes;
+      final n = a.length;
+      if (n != b.length) {
+        return false;
+      }
+      var mismatch = 0;
+      for (var i = 0; i < n; i++) {
+        mismatch |= a[i] ^ b[i];
+      }
+      return mismatch == 0;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode => hashAll(bytes);
+
+  /// The message digest as a string of hexadecimal digits.
+  @override
+  String toString() => _hexEncode(bytes);
+}
+
+String _hexEncode(List<int> bytes) {
+  const hexDigits = '0123456789abcdef';
+  var charCodes = Uint8List(bytes.length * 2);
+  for (var i = 0, j = 0; i < bytes.length; i++) {
+    var byte = bytes[i];
+    charCodes[j++] = hexDigits.codeUnitAt((byte >> 4) & 0xF);
+    charCodes[j++] = hexDigits.codeUnitAt(byte & 0xF);
+  }
+  return String.fromCharCodes(charCodes);
+}

dart/lib/src/cryptography/digest_sink.dart

@@ -0,0 +1,29 @@
+// Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'digest.dart';
+
+/// A sink used to get a digest value out of `Hash.startChunkedConversion`.
+class DigestSink extends Sink<Digest> {
+  /// The value added to the sink.
+  ///
+  /// A value must have been added using [add] before reading the `value`.
+  Digest get value => _value!;
+
+  Digest? _value;
+
+  /// Adds [value] to the sink.
+  ///
+  /// Unlike most sinks, this may only be called once.
+  @override
+  void add(Digest value) {
+    if (_value != null) throw StateError('add may only be called once.');
+    _value = value;
+  }
+
+  @override
+  void close() {
+    if (_value == null) throw StateError('add must be called once.');
+  }
+}

dart/lib/src/cryptography/hash.dart

@@ -0,0 +1,35 @@
+// Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:convert';
+
+import 'digest.dart';
+import 'digest_sink.dart';
+
+/// An interface for cryptographic hash functions.
+///
+/// Every hash is a converter that takes a list of ints and returns a single
+/// digest. When used in chunked mode, it will only ever add one digest to the
+/// inner [Sink].
+abstract class Hash extends Converter<List<int>, Digest> {
+  /// The internal block size of the hash in bytes.
+  ///
+  /// This is exposed for use by the `Hmac` class,
+  /// which needs to know the block size for the [Hash] it uses.
+  int get blockSize;
+
+  const Hash();
+
+  @override
+  Digest convert(List<int> input) {
+    var innerSink = DigestSink();
+    var outerSink = startChunkedConversion(innerSink);
+    outerSink.add(input);
+    outerSink.close();
+    return innerSink.value;
+  }
+
+  @override
+  ByteConversionSink startChunkedConversion(Sink<Digest> sink);
+}