Merge branch 'main' into feat/unknown-serialization

Author: denrase

.github/workflows/flutter_integration_test.yml

@@ -49,7 +49,7 @@ jobs:
         run: flutter pub get
 
       - name: Gradle cache
-        uses: gradle/gradle-build-action@66535aaf56f831b35e3a8481c9c99b665b84dd45 # pin@v3.4.2
+        uses: gradle/gradle-build-action@ac2d340dc04d9e1113182899e983b5400c17cda1 # pin@v3.5.0
 
       - name: AVD cache
         uses: actions/cache@v4

.github/workflows/flutter_test.yml

@@ -54,7 +54,7 @@ jobs:
         run: flutter pub get
 
       - name: Gradle cache
-        uses: gradle/gradle-build-action@66535aaf56f831b35e3a8481c9c99b665b84dd45 # [email protected]
+        uses: gradle/gradle-build-action@ac2d340dc04d9e1113182899e983b5400c17cda1 # [email protected]
 
       - name: AVD cache
         uses: actions/cache@v4

.github/workflows/testflight.yml

@@ -16,7 +16,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: subosito/flutter-action@44ac965b96f18d999802d4b807e3256d5a3f9fa1 # [email protected]
       - run: xcodes select 15.0.1
-      - uses: ruby/setup-ruby@3a77c29278ae80936b4cb030fefc7d21c96c786f # pin@v1.185.0
+      - uses: ruby/setup-ruby@50ba3386b050ad5b97a41fcb81240cbee1d1821f # pin@v1.188.0
         with:
           ruby-version: '2.7.5'
           bundler-cache: true

CHANGELOG.md

@@ -5,6 +5,77 @@
 ### Improvements
 
 - Deserialize and serialize unknown fields ([#2153](https://github.com/getsentry/sentry-dart/pull/2153))
+## Unreleased 
+
+### Improvements
+
+- Add error type identifier to improve obfuscated Flutter issue titles ([#2170](https://github.com/getsentry/sentry-dart/pull/2170))
+  - Example: transforms issue titles from `GA` to `FlutterError` or `minified:nE` to `FlutterError`
+  - This is enabled automatically and will change grouping if you already have issues with obfuscated titles
+  - If you want to disable this feature, set `enableExceptionTypeIdentification` to `false` in your Sentry options
+  - You can add your custom exception identifier if there are exceptions that we do not identify out of the box
+```dart
+// How to add your own custom exception identifier
+class MyCustomExceptionIdentifier implements ExceptionIdentifier {
+  @override
+  String? identifyType(Exception exception) {
+    if (exception is MyCustomException) {
+      return 'MyCustomException';
+    }
+    if (exception is MyOtherCustomException) {
+      return 'MyOtherCustomException';
+    }
+    return null;
+  }
+}
+
+SentryFlutter.init((options) =>
+  options..prependExceptionTypeIdentifier(MyCustomExceptionIdentifier()));
+```
+
+### Deprecated
+
+- Deprecate `enableTracing` ([#2199](https://github.com/getsentry/sentry-dart/pull/2199))
+  - The `enableTracing` option has been deprecated and will be removed in the next major version. We recommend removing it
+    in favor of the `tracesSampleRate` and `tracesSampler` options. If you want to enable performance monitoring, please set
+    the `tracesSampleRate` to a sample rate of your choice, or provide a sampling function as `tracesSampler` option
+    instead. If you want to disable performance monitoring, remove the `tracesSampler` and `tracesSampleRate` options.
+
+### Dependencies
+
+- Bump Android SDK from v7.12.0 to v7.12.1 ([#2198](https://github.com/getsentry/sentry-dart/pull/2198))
+  - [changelog](https://github.com/getsentry/sentry-java/blob/main/CHANGELOG.md#7121)
+  - [diff](https://github.com/getsentry/sentry-java/compare/7.12.0...7.12.1)
+
+## 8.5.0
+
+### Features
+
+- Add dart platform to sentry frames ([#2193](https://github.com/getsentry/sentry-dart/pull/2193))
+  - This allows viewing the correct dart formatted raw stacktrace in the Sentry UI
+- Support `ignoredExceptionsForType` ([#2150](https://github.com/getsentry/sentry-dart/pull/2150))
+  - Filter out exception types by calling `SentryOptions.addExceptionFilterForType(Type exceptionType)`
+  
+### Fixes
+
+- Disable sff & frame delay detection on web, linux and windows ([#2182](https://github.com/getsentry/sentry-dart/pull/2182))
+  - Display refresh rate is locked at 60 for these platforms which can lead to inaccurate metrics 
+
+### Improvements
+
+- Capture meaningful stack traces when unhandled errors have empty or missing stack traces ([#2152](https://github.com/getsentry/sentry-dart/pull/2152))
+  - This will affect grouping for unhandled errors that have empty or missing stack traces.
+
+### Dependencies
+
+- Bump Android SDK from v7.11.0 to v7.12.0 ([#2173](https://github.com/getsentry/sentry-dart/pull/2173))
+  - [changelog](https://github.com/getsentry/sentry-java/blob/main/CHANGELOG.md#7120)
+  - [diff](https://github.com/getsentry/sentry-java/compare/7.11.0...7.12.0)
+  - updates AGP to v7.4.2
+  - updates Kotlin to v1.8.0
+- Bump Cocoa SDK from v8.30.1 to v8.32.0 ([#2174](https://github.com/getsentry/sentry-dart/pull/2174), [#2195](https://github.com/getsentry/sentry-dart/pull/2195))
+  - [changelog](https://github.com/getsentry/sentry-cocoa/blob/main/CHANGELOG.md#8320)
+  - [diff](https://github.com/getsentry/sentry-cocoa/compare/8.30.1...8.32.0)
 
 ## 8.4.0
 

dart/lib/sentry.dart

@@ -40,6 +40,7 @@ export 'src/sentry_baggage.dart';
 export 'src/exception_cause_extractor.dart';
 export 'src/exception_cause.dart';
 export 'src/exception_stacktrace_extractor.dart';
+export 'src/exception_type_identifier.dart';
 // URL
 // ignore: invalid_export_of_internal_element
 export 'src/utils/http_sanitizer.dart';

dart/lib/src/dart_exception_type_identifier.dart

@@ -0,0 +1,41 @@
+import 'package:http/http.dart' show ClientException;
+import 'dart:async' show TimeoutException, AsyncError, DeferredLoadException;
+import '../sentry.dart';
+
+import 'dart_exception_type_identifier_io.dart'
+    if (dart.library.html) 'dart_exception_type_identifier_web.dart';
+
+class DartExceptionTypeIdentifier implements ExceptionTypeIdentifier {
+  @override
+  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 (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 http package
+    if (throwable is ClientException) return 'ClientException';
+
+    // platform specific exceptions
+    return identifyPlatformSpecificException(throwable);
+  }
+}

dart/lib/src/dart_exception_type_identifier_io.dart

@@ -0,0 +1,14 @@
+import 'dart:io';
+
+import 'package:meta/meta.dart';
+
+@internal
+String? identifyPlatformSpecificException(dynamic throwable) {
+  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';
+  return null;
+}

dart/lib/src/dart_exception_type_identifier_web.dart

@@ -0,0 +1,6 @@
+import 'package:meta/meta.dart';
+
+@internal
+String? identifyPlatformSpecificException(dynamic throwable) {
+  return null;
+}

dart/lib/src/event_processor/enricher/web_enricher_event_processor.dart

@@ -71,6 +71,7 @@ class WebEnricherEventProcessor implements EnricherEventProcessor {
 
   int? _getMemorySize() {
     // https://developer.mozilla.org/en-US/docs/Web/API/Navigator/deviceMemory
+    // ignore: invalid_null_aware_operator
     final size = _window.navigator.deviceMemory?.toDouble();
     final memoryByteSize = size != null ? size * 1024 * 1024 * 1024 : null;
     return memoryByteSize?.toInt();
@@ -102,5 +103,6 @@ class WebEnricherEventProcessor implements EnricherEventProcessor {
 }
 
 extension on web.Navigator {
+  // ignore: unused_element
   external double? get deviceMemory;
 }

dart/lib/src/exception_type_identifier.dart

@@ -0,0 +1,54 @@
+import 'package:meta/meta.dart';
+
+/// An abstract class for identifying the type of Dart errors and exceptions.
+///
+/// It's used in scenarios where error types need to be determined in obfuscated builds
+/// as [runtimeType] is not reliable in such cases.
+///
+/// Implement this class to create custom error type identifiers for errors or exceptions.
+/// that we do not support out of the box.
+///
+/// Example:
+/// ```dart
+/// class MyExceptionTypeIdentifier implements ExceptionTypeIdentifier {
+///   @override
+///   String? identifyType(dynamic throwable) {
+///     if (throwable is MyCustomError) return 'MyCustomError';
+///     return null;
+///   }
+/// }
+/// ```
+abstract class ExceptionTypeIdentifier {
+  String? identifyType(dynamic throwable);
+}
+
+extension CacheableExceptionIdentifier on ExceptionTypeIdentifier {
+  ExceptionTypeIdentifier withCache() => CachingExceptionTypeIdentifier(this);
+}
+
+@visibleForTesting
+class CachingExceptionTypeIdentifier implements ExceptionTypeIdentifier {
+  @visibleForTesting
+  ExceptionTypeIdentifier get identifier => _identifier;
+  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;
+  }
+}