rename classes

Author: Denis Andrašec

dart/lib/src/client_reports/client_report_recorder.dart

@@ -4,7 +4,7 @@ import '../sentry_options.dart';
 import 'client_report.dart';
 import 'discarded_event.dart';
 import 'outcome.dart';
-import '../transport/rate_limit_category.dart';
+import '../transport/data_category.dart';
 
 @internal
 class ClientReportRecorder {
@@ -13,7 +13,8 @@ class ClientReportRecorder {
   final ClockProvider _clock;
   final Map<_QuantityKey, int> _quantities = {};
 
-  void recordLostEvent(final Outcome reason, final RateLimitCategory category) {
+  void recordLostEvent(
+      final DiscardReason reason, final DataCategory category) {
     final key = _QuantityKey(reason, category);
     var current = _quantities[key] ?? 0;
     _quantities[key] = current + 1;
@@ -38,8 +39,8 @@ class ClientReportRecorder {
 class _QuantityKey {
   _QuantityKey(this.reason, this.category);
 
-  final Outcome reason;
-  final RateLimitCategory category;
+  final DiscardReason reason;
+  final DataCategory category;
 
   @override
   int get hashCode => Object.hash(reason, category);

dart/lib/src/client_reports/discarded_event.dart

@@ -1,13 +1,13 @@
 import 'package:meta/meta.dart';
 
 import 'outcome.dart';
-import '../transport/rate_limit_category.dart';
+import '../transport/data_category.dart';
 
 @internal
 class DiscardedEvent {
   DiscardedEvent(this.reason, this.category, this.quantity);
 
-  final Outcome reason;
-  final RateLimitCategory category;
+  final DiscardReason reason;
+  final DataCategory category;
   final int quantity;
 }

dart/lib/src/client_reports/outcome.dart

@@ -1,14 +1,14 @@
 import 'package:meta/meta.dart';
 
 @internal
-enum Outcome { ratelimitBackoff, networkError }
+enum DiscardReason { ratelimitBackoff, networkError }
 
-extension OutcomeExtension on Outcome {
+extension OutcomeExtension on DiscardReason {
   String toStringValue() {
     switch (this) {
-      case Outcome.ratelimitBackoff:
+      case DiscardReason.ratelimitBackoff:
         return 'ratelimit_backoff';
-      case Outcome.networkError:
+      case DiscardReason.networkError:
         return 'network_error';
     }
   }

dart/lib/src/transport/data_category.dart

@@ -0,0 +1,54 @@
+/// Different category types of data sent to Sentry. Used for rate limiting and client reports.
+enum DataCategory {
+  all,
+  rate_limit_default, // default
+  error,
+  session,
+  transaction,
+  attachment,
+  security,
+  unknown
+}
+
+extension DataCategoryExtension on DataCategory {
+  static DataCategory fromStringValue(String stringValue) {
+    switch (stringValue) {
+      case '__all__':
+        return DataCategory.all;
+      case 'default':
+        return DataCategory.rate_limit_default;
+      case 'error':
+        return DataCategory.error;
+      case 'session':
+        return DataCategory.session;
+      case 'transaction':
+        return DataCategory.transaction;
+      case 'attachment':
+        return DataCategory.attachment;
+      case 'security':
+        return DataCategory.security;
+    }
+    return DataCategory.unknown;
+  }
+
+  String toStringValue() {
+    switch (this) {
+      case DataCategory.all:
+        return '__all__';
+      case DataCategory.rate_limit_default:
+        return 'default';
+      case DataCategory.error:
+        return 'error';
+      case DataCategory.session:
+        return 'session';
+      case DataCategory.transaction:
+        return 'transaction';
+      case DataCategory.attachment:
+        return 'attachment';
+      case DataCategory.security:
+        return 'security';
+      case DataCategory.unknown:
+        return 'unknown';
+    }
+  }
+}

dart/lib/src/transport/rate_limit.dart

@@ -1,9 +1,9 @@
-import 'rate_limit_category.dart';
+import 'data_category.dart';
 
-/// `RateLimit` containing limited `RateLimitCategory` and duration in milliseconds.
+/// `RateLimit` containing limited `DataCategory` and duration in milliseconds.
 class RateLimit {
   RateLimit(this.category, this.duration);
 
-  final RateLimitCategory category;
+  final DataCategory category;
   final Duration duration;
 }

dart/lib/src/transport/rate_limit_category.dart

@@ -1,4 +1,4 @@
-import 'rate_limit_category.dart';
+import 'data_category.dart';
 import 'rate_limit.dart';
 
 /// Parse rate limit categories and times from response header payloads.
@@ -29,23 +29,20 @@ class RateLimitParser {
       if (allCategories.isNotEmpty) {
         final categoryValues = allCategories.split(';');
         for (final categoryValue in categoryValues) {
-          final category =
-              RateLimitCategoryExtension.fromStringValue(categoryValue);
-          if (category != RateLimitCategory.unknown) {
+          final category = DataCategoryExtension.fromStringValue(categoryValue);
+          if (category != DataCategory.unknown) {
             rateLimits.add(RateLimit(category, duration));
           }
         }
       } else {
-        rateLimits.add(RateLimit(RateLimitCategory.all, duration));
+        rateLimits.add(RateLimit(DataCategory.all, duration));
       }
     }
     return rateLimits;
   }
 
   List<RateLimit> parseRetryAfterHeader() {
-    return [
-      RateLimit(RateLimitCategory.all, _parseRetryAfterOrDefault(_header))
-    ];
+    return [RateLimit(DataCategory.all, _parseRetryAfterOrDefault(_header))];
   }
 
   // Helper

dart/lib/src/transport/rate_limit_parser.dart

@@ -4,14 +4,14 @@ import '../sentry_options.dart';
 import '../sentry_envelope.dart';
 import '../sentry_envelope_item.dart';
 import 'rate_limit.dart';
-import 'rate_limit_category.dart';
+import 'data_category.dart';
 
 /// Controls retry limits on different category types sent to Sentry.
 class RateLimiter {
   RateLimiter(this._clockProvider);
 
   final ClockProvider _clockProvider;
-  final _rateLimitedUntil = <RateLimitCategory, DateTime>{};
+  final _rateLimitedUntil = <DataCategory, DateTime>{};
 
   /// Filter out envelopes that are rate limited.
   SentryEnvelope? filter(SentryEnvelope envelope) {
@@ -75,15 +75,15 @@ class RateLimiter {
         _clockProvider().millisecondsSinceEpoch);
 
     // check all categories
-    final dateAllCategories = _rateLimitedUntil[RateLimitCategory.all];
+    final dateAllCategories = _rateLimitedUntil[DataCategory.all];
     if (dateAllCategories != null) {
       if (!currentDate.isAfter(dateAllCategories)) {
         return true;
       }
     }
 
     // Unknown should not be rate limited
-    if (RateLimitCategory.unknown == dataCategory) {
+    if (DataCategory.unknown == dataCategory) {
       return false;
     }
 
@@ -96,28 +96,27 @@ class RateLimiter {
     return false;
   }
 
-  RateLimitCategory _categoryFromItemType(String itemType) {
+  DataCategory _categoryFromItemType(String itemType) {
     switch (itemType) {
       case 'event':
-        return RateLimitCategory.error;
+        return DataCategory.error;
       case 'session':
-        return RateLimitCategory.session;
+        return DataCategory.session;
       case 'attachment':
-        return RateLimitCategory.attachment;
+        return DataCategory.attachment;
       case 'transaction':
-        return RateLimitCategory.transaction;
+        return DataCategory.transaction;
       default:
-        return RateLimitCategory.unknown;
+        return DataCategory.unknown;
     }
   }
 
-  void _applyRetryAfterOnlyIfLonger(
-      RateLimitCategory rateLimitCategory, DateTime date) {
-    final oldDate = _rateLimitedUntil[rateLimitCategory];
+  void _applyRetryAfterOnlyIfLonger(DataCategory dataCategory, DateTime date) {
+    final oldDate = _rateLimitedUntil[dataCategory];
 
     // only overwrite its previous date if the limit is even longer
     if (oldDate == null || date.isAfter(oldDate)) {
-      _rateLimitedUntil[rateLimitCategory] = date;
+      _rateLimitedUntil[dataCategory] = date;
     }
   }
 }

dart/lib/src/transport/rate_limiter.dart

@@ -1,5 +1,5 @@
 import 'package:sentry/src/client_reports/outcome.dart';
-import 'package:sentry/src/transport/rate_limit_category.dart';
+import 'package:sentry/src/transport/data_category.dart';
 import 'package:test/test.dart';
 
 import 'package:sentry/src/client_reports/client_report_recorder.dart';
@@ -23,7 +23,7 @@ void main() {
     test('flush returns client report with current date', () {
       final sut = fixture.getSut();
 
-      sut.recordLostEvent(Outcome.ratelimitBackoff, RateLimitCategory.error);
+      sut.recordLostEvent(DiscardReason.ratelimitBackoff, DataCategory.error);
 
       final clientReport = sut.flush();
 
@@ -33,47 +33,47 @@ void main() {
     test('record lost event', () {
       final sut = fixture.getSut();
 
-      sut.recordLostEvent(Outcome.ratelimitBackoff, RateLimitCategory.error);
-      sut.recordLostEvent(Outcome.ratelimitBackoff, RateLimitCategory.error);
+      sut.recordLostEvent(DiscardReason.ratelimitBackoff, DataCategory.error);
+      sut.recordLostEvent(DiscardReason.ratelimitBackoff, DataCategory.error);
 
       final clientReport = sut.flush();
 
       final event = clientReport?.discardedEvents
-          .firstWhere((element) => element.category == RateLimitCategory.error);
+          .firstWhere((element) => element.category == DataCategory.error);
 
-      expect(event?.reason, Outcome.ratelimitBackoff);
-      expect(event?.category, RateLimitCategory.error);
+      expect(event?.reason, DiscardReason.ratelimitBackoff);
+      expect(event?.category, DataCategory.error);
       expect(event?.quantity, 2);
     });
 
     test('record outcomes with different categories recorded separately', () {
       final sut = fixture.getSut();
 
-      sut.recordLostEvent(Outcome.ratelimitBackoff, RateLimitCategory.error);
+      sut.recordLostEvent(DiscardReason.ratelimitBackoff, DataCategory.error);
       sut.recordLostEvent(
-          Outcome.ratelimitBackoff, RateLimitCategory.transaction);
+          DiscardReason.ratelimitBackoff, DataCategory.transaction);
 
       final clientReport = sut.flush();
 
       final first = clientReport?.discardedEvents
-          .firstWhere((event) => event.category == RateLimitCategory.error);
+          .firstWhere((event) => event.category == DataCategory.error);
 
-      final second = clientReport?.discardedEvents.firstWhere(
-          (event) => event.category == RateLimitCategory.transaction);
+      final second = clientReport?.discardedEvents
+          .firstWhere((event) => event.category == DataCategory.transaction);
 
-      expect(first?.reason, Outcome.ratelimitBackoff);
-      expect(first?.category, RateLimitCategory.error);
+      expect(first?.reason, DiscardReason.ratelimitBackoff);
+      expect(first?.category, DataCategory.error);
       expect(first?.quantity, 1);
 
-      expect(second?.reason, Outcome.ratelimitBackoff);
-      expect(second?.category, RateLimitCategory.transaction);
+      expect(second?.reason, DiscardReason.ratelimitBackoff);
+      expect(second?.category, DataCategory.transaction);
       expect(second?.quantity, 1);
     });
 
     test('calling flush multiple times returns null', () {
       final sut = fixture.getSut();
 
-      sut.recordLostEvent(Outcome.ratelimitBackoff, RateLimitCategory.error);
+      sut.recordLostEvent(DiscardReason.ratelimitBackoff, DataCategory.error);
 
       sut.flush();
       final clientReport = sut.flush();