apply new approach in dio event processor

dio/lib/src/dio_error_extractor.dart

@@ -0,0 +1,16 @@
+import 'package:dio/dio.dart';
+import 'package:sentry/sentry.dart';
+
+/// Extracts the inner exception and stacktrace from [DioError]
+class DioErrorExtractor extends ExceptionCauseExtractor<DioError> {
+  @override
+  ExceptionCause? cause(DioError error) {
+    if (error.stackTrace == null) {
+      return null;
+    }
+    return ExceptionCause(
+      error.error ?? 'DioError inner stacktrace',
+      error.stackTrace,
+    );
+  }
+}

dio/lib/src/dio_event_processor.dart

@@ -2,25 +2,16 @@ import 'dart:async';
 
 import 'package:dio/dio.dart';
 import 'package:sentry/sentry.dart';
-// ignore: implementation_imports
-import 'package:sentry/src/sentry_exception_factory.dart';
 
 /// This is an [EventProcessor], which improves crash reports of [DioError]s.
 /// It adds information about [DioError.requestOptions] if present and also about
 /// the inner exceptions.
 class DioEventProcessor implements EventProcessor {
-  // Because of obfuscation, we need to dynamically get the name
-  static final _dioErrorType = (DioError).toString();
-
   /// This is an [EventProcessor], which improves crash reports of [DioError]s.
   DioEventProcessor(this._options);
 
   final SentryOptions _options;
 
-  SentryExceptionFactory get _sentryExceptionFactory =>
-      // ignore: invalid_use_of_internal_member
-      _options.exceptionFactory;
-
   @override
   FutureOr<SentryEvent?> apply(SentryEvent event, {Hint? hint}) {
     final dynamic dioError = event.throwable;
@@ -41,41 +32,20 @@ class DioEventProcessor implements EventProcessor {
       contexts: contexts,
     );
 
-    final innerDioStackTrace = dioError.stackTrace;
-    final innerDioErrorException = dioError.error as Object?;
-
     // If the inner errors stacktrace is null,
-    // there's nothing to create chained exception
-    if (innerDioStackTrace == null) {
+    // there is no chained exception
+    if (dioError.stackTrace == null) {
       return event;
     }
 
-    try {
-      final innerException = _sentryExceptionFactory.getSentryException(
-        innerDioErrorException ?? 'DioError inner stacktrace',
-        stackTrace: innerDioStackTrace,
-      );
-
-      final exceptions = _removeDioErrorStackTraceFromValue(
-        List<SentryException>.from(event.exceptions ?? <SentryException>[]),
-        dioError,
-      );
-
-      return event.copyWith(
-        exceptions: [
-          innerException,
-          ...exceptions,
-        ],
-      );
-    } catch (e, stackTrace) {
-      _options.logger(
-        SentryLevel.debug,
-        'Could not convert DioError to SentryException',
-        exception: e,
-        stackTrace: stackTrace,
-      );
-    }
-    return event;
+    final exceptions = _removeDioErrorStackTraceFromValue(
+      List<SentryException>.from(event.exceptions ?? <SentryException>[]),
+      dioError,
+    );
+
+    return event.copyWith(
+      exceptions: exceptions.reversed.toList(), // Inner before DioError
+    );
   }
 
   /// Remove the StackTrace from [dioError] so the message on Sentry looks
@@ -85,7 +55,7 @@ class DioEventProcessor implements EventProcessor {
     DioError dioError,
   ) {
     final dioSentryExceptions =
-        exceptions.where((element) => element.type == _dioErrorType);
+        exceptions.where((element) => element.throwable is DioError);
 
     if (dioSentryExceptions.isEmpty) {
       return exceptions;

dio/lib/src/sentry_dio_extension.dart

@@ -1,5 +1,6 @@
 import 'package:dio/dio.dart';
 import 'package:sentry/sentry.dart';
+import 'dio_error_extractor.dart';
 import 'dio_event_processor.dart';
 import 'failed_request_interceptor.dart';
 import 'sentry_transformer.dart';
@@ -19,6 +20,9 @@ extension SentryDioExtension on Dio {
     // ignore: invalid_use_of_internal_member
     final options = hub.options;
 
+    // Add to get inner exception & stacktrace
+    options.addExceptionCauseExtractor(DioErrorExtractor());
+
     // Add DioEventProcessor when it's not already present
     if (options.eventProcessors.whereType<DioEventProcessor>().isEmpty) {
       options.sdk.addIntegration('sentry_dio');

dio/test/dio_error_extractor_test.dart

@@ -0,0 +1,61 @@
+import 'package:dio/dio.dart';
+import 'package:sentry_dio/src/dio_error_extractor.dart';
+import 'package:test/test.dart';
+
+void main() {
+  late Fixture fixture;
+
+  setUp(() {
+    fixture = Fixture();
+  });
+
+  test('$DioErrorExtractor extracts error and stacktrace', () {
+    final sut = fixture.getSut();
+    final exception = Exception('foo bar');
+    final stacktrace = StackTrace.current;
+
+    final dioError = DioError(
+      error: exception,
+      requestOptions: RequestOptions(path: '/foo/bar'),
+    )..stackTrace = stacktrace;
+
+    final cause = sut.cause(dioError);
+
+    expect(cause?.exception, exception);
+    expect(cause?.stackTrace, stacktrace);
+  });
+
+  test('$DioErrorExtractor extracts stacktrace only', () {
+    final sut = fixture.getSut();
+    final stacktrace = StackTrace.current;
+
+    final dioError = DioError(
+      requestOptions: RequestOptions(path: '/foo/bar'),
+    )..stackTrace = stacktrace;
+
+    final cause = sut.cause(dioError);
+
+    expect(cause?.exception, 'DioError inner stacktrace');
+    expect(cause?.stackTrace, stacktrace);
+  });
+
+  test('$DioErrorExtractor extracts nothing with missing stacktrace', () {
+    final sut = fixture.getSut();
+    final exception = Exception('foo bar');
+
+    final dioError = DioError(
+      error: exception,
+      requestOptions: RequestOptions(path: '/foo/bar'),
+    );
+
+    final cause = sut.cause(dioError);
+
+    expect(cause, isNull);
+  });
+}
+
+class Fixture {
+  DioErrorExtractor getSut() {
+    return DioErrorExtractor();
+  }
+}

dio/test/dio_event_processor_test.dart

@@ -1,6 +1,7 @@
 import 'package:dio/dio.dart';
 import 'package:sentry/sentry.dart';
 import 'package:sentry_dio/sentry_dio.dart';
+import 'package:sentry_dio/src/dio_error_extractor.dart';
 import 'package:test/test.dart';
 import 'package:sentry/src/sentry_exception_factory.dart';
 
@@ -157,16 +158,25 @@ void main() {
   });
 
   test('$DioEventProcessor adds chained stacktraces', () {
+    fixture.options.addExceptionCauseExtractor(DioErrorExtractor());
+
     final sut = fixture.getSut(sendDefaultPii: false);
     final exception = Exception('foo bar');
     final dioError = DioError(
       error: exception,
       requestOptions: requestOptions,
     )..stackTrace = StackTrace.current;
 
+    final extracted =
+        fixture.exceptionFactory.extractor.flatten(dioError, null);
+    final exceptions = extracted.map((element) {
+      return fixture.exceptionFactory.getSentryException(element.exception,
+          stackTrace: element.stackTrace);
+    }).toList();
+
     final event = SentryEvent(
       throwable: dioError,
-      exceptions: [fixture.exceptionFactory.getSentryException(dioError)],
+      exceptions: exceptions,
     );
 
     final processedEvent = sut.apply(event) as SentryEvent;