Add caching

Author: buenaflor

dart/lib/src/dart_exception_type_identifier.dart

@@ -1,23 +1,48 @@
+import 'dart:io';
+
+import 'package:http/http.dart';
+import 'dart:async';
+
 import '../sentry.dart';
 
 class DartExceptionTypeIdentifier implements ExceptionTypeIdentifier {
   @override
-  String? identifyType(dynamic error) {
-    if (error is ArgumentError) return 'ArgumentError';
-    if (error is AssertionError) return 'AssertionError';
-    if (error is ConcurrentModificationError)
+  String? identifyType(dynamic throwable) {
+    // dart:core
+    if (throwable is ArgumentError) return 'ArgumentError';
+    if (throwable is AssertionError) return 'AssertionError';
+    if (throwable is ConcurrentModificationError)
       return 'ConcurrentModificationError';
-    if (error is FormatException) return 'FormatException';
-    if (error is IndexError) return 'IndexError';
-    if (error is NoSuchMethodError) return 'NoSuchMethodError';
-    if (error is OutOfMemoryError) return 'OutOfMemoryError';
-    if (error is RangeError) return 'RangeError';
-    if (error is StackOverflowError) return 'StackOverflowError';
-    if (error is StateError) return 'StateError';
-    if (error is TypeError) return 'TypeError';
-    if (error is UnimplementedError) return 'UnimplementedError';
-    if (error is UnsupportedError) return 'UnsupportedError';
-    // we purposefully don't include Exception or Error since it's too generic
+    if (throwable is FormatException) return 'FormatException';
+    if (throwable is IndexError) return 'IndexError';
+    if (throwable is NoSuchMethodError) return 'NoSuchMethodError';
+    if (throwable is OutOfMemoryError) return 'OutOfMemoryError';
+    if (throwable is RangeError) return 'RangeError';
+    if (throwable is StackOverflowError) return 'StackOverflowError';
+    if (throwable is StateError) return 'StateError';
+    if (throwable is TypeError) return 'TypeError';
+    if (throwable is UnimplementedError) return 'UnimplementedError';
+    if (throwable is UnsupportedError) return 'UnsupportedError';
+    // not adding Exception or Error because it's too generic
+
+    // dart:async
+    if (throwable is TimeoutException) return 'TimeoutException';
+    if (throwable is AsyncError) return 'FutureTimeout';
+    if (throwable is DeferredLoadException) return 'DeferredLoadException';
+    // not adding ParallelWaitError because it's not supported in dart 2.17.0
+
+    // dart:io
+    if (throwable is FileSystemException) return 'FileSystemException';
+    if (throwable is HttpException) return 'HttpException';
+    if (throwable is SocketException) return 'SocketException';
+    if (throwable is HandshakeException) return 'HandshakeException';
+    if (throwable is CertificateException) return 'CertificateException';
+    if (throwable is TlsException) return 'TlsException';
+    // not adding IOException because it's too generic
+
+    // dart http package
+    if (throwable is ClientException) return 'ClientException';
+
     return null;
   }
 }

dart/lib/src/exception_type_identifier.dart

@@ -21,3 +21,30 @@
 abstract class ExceptionTypeIdentifier {
   String? identifyType(dynamic throwable);
 }
+
+extension CacheableExceptionIdentifier on ExceptionTypeIdentifier {
+  ExceptionTypeIdentifier withCache() => _CachingExceptionTypeIdentifier(this);
+}
+
+class _CachingExceptionTypeIdentifier implements ExceptionTypeIdentifier {
+  final ExceptionTypeIdentifier _identifier;
+  final Map<Type, String?> _knownExceptionTypes = {};
+
+  _CachingExceptionTypeIdentifier(this._identifier);
+
+  @override
+  String? identifyType(dynamic throwable) {
+    final runtimeType = throwable.runtimeType;
+    if (_knownExceptionTypes.containsKey(runtimeType)) {
+      return _knownExceptionTypes[runtimeType];
+    }
+
+    final identifiedType = _identifier.identifyType(throwable);
+
+    if (identifiedType != null) {
+      _knownExceptionTypes[runtimeType] = identifiedType;
+    }
+
+    return identifiedType;
+  }
+}

dart/lib/src/sentry.dart

@@ -2,6 +2,7 @@ import 'dart:async';
 
 import 'package:meta/meta.dart';
 
+import 'dart_exception_type_identifier.dart';
 import 'metrics/metrics_api.dart';
 import 'run_zoned_guarded_integration.dart';
 import 'event_processor/enricher/enricher_event_processor.dart';
@@ -85,6 +86,8 @@ class Sentry {
     options.addEventProcessor(EnricherEventProcessor(options));
     options.addEventProcessor(ExceptionEventProcessor(options));
     options.addEventProcessor(DeduplicationEventProcessor(options));
+
+    options.addExceptionTypeIdentifier(DartExceptionTypeIdentifier());
   }
 
   /// This method reads available environment variables and uses them

dart/lib/src/sentry_options.dart

@@ -437,16 +437,20 @@ class SentryOptions {
   /// Settings this to `false` will set the `level` to [SentryLevel.error].
   bool markAutomaticallyCollectedErrorsAsFatal = true;
 
-  final List<ExceptionTypeIdentifier> _exceptionTypeIdentifiers = [
-    DartExceptionTypeIdentifier(),
-  ];
+  final List<ExceptionTypeIdentifier> _exceptionTypeIdentifiers = [];
 
   List<ExceptionTypeIdentifier> get exceptionTypeIdentifiers =>
       _exceptionTypeIdentifiers;
 
+  void addExceptionTypeIdentifierByIndex(
+      int index, ExceptionTypeIdentifier exceptionTypeIdentifier) {
+    _exceptionTypeIdentifiers.insert(
+        index, exceptionTypeIdentifier.withCache());
+  }
+
   void addExceptionTypeIdentifier(
       ExceptionTypeIdentifier exceptionTypeIdentifier) {
-    _exceptionTypeIdentifiers.insert(0, exceptionTypeIdentifier);
+    _exceptionTypeIdentifiers.add(exceptionTypeIdentifier.withCache());
   }
 
   /// The Spotlight configuration.

flutter/lib/src/flutter_error_type_identifier.dart

@@ -0,0 +1,19 @@
+import 'package:flutter/cupertino.dart';
+import 'package:flutter/services.dart';
+
+import '../sentry_flutter.dart';
+
+class FlutterExceptionTypeIdentifier implements ExceptionTypeIdentifier {
+  @override
+  String? identifyType(dynamic throwable) {
+    // FlutterError check should run before AssertionError check because
+    // it's a subclass of AssertionError
+    if (throwable is FlutterError) return 'FlutterError';
+    if (throwable is PlatformException) return 'PlatformException';
+    if (throwable is MissingPluginException) return 'MissingPluginException';
+    if (throwable is NetworkImageLoadException)
+      return 'NetworkImageLoadException';
+    if (throwable is TickerCanceled) return 'TickerCanceled';
+    return null;
+  }
+}

flutter/lib/src/flutter_exception_type_identifier.dart

@@ -11,7 +11,7 @@ import 'event_processor/flutter_exception_event_processor.dart';
 import 'event_processor/platform_exception_event_processor.dart';
 import 'event_processor/widget_event_processor.dart';
 import 'file_system_transport.dart';
-import 'flutter_error_type_identifier.dart';
+import 'flutter_exception_type_identifier.dart';
 import 'frame_callback_handler.dart';
 import 'integrations/connectivity/connectivity_integration.dart';
 import 'integrations/integrations.dart';
@@ -137,7 +137,10 @@ mixin SentryFlutter {
 
     options.addPerformanceCollector(SpanFrameMetricsCollector(options));
 
-    options.addExceptionTypeIdentifier(FlutterExceptionTypeIdentifier());
+    // Insert it before the Dart Exceptions that are set in Sentry.init
+    // so we can identify Flutter exceptions first.
+    options.addExceptionTypeIdentifierByIndex(
+        0, FlutterExceptionTypeIdentifier());
 
     _setSdk(options);
   }