fix: unsupported types with expando (#1690)

* Support string, int, double and bool as throwable for expando

* Rename the test file and move it to utils folder{

* Remvoe ffi import

* Update changelog

* Try other url for dio pubspec doc url

* Change doc url of logging pubspec

* Remove unnecessary code

* Update naming

* Rename

Author: buenaflor

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Fixes 
+
+- Unsupported types with Expando ([#1690](https://github.com/getsentry/sentry-dart/pull/1690))
+
 ### Features
 
 - Breadcrumbs for database operations ([#1656](https://github.com/getsentry/sentry-dart/pull/1656))

dart/lib/src/hub.dart

@@ -605,6 +605,8 @@ class _WeakMap {
 
   final SentryOptions _options;
 
+  final throwableHandler = UnsupportedThrowablesHandler();
+
   _WeakMap(this._options);
 
   void add(
@@ -615,6 +617,7 @@ class _WeakMap {
     if (throwable == null) {
       return;
     }
+    throwable = throwableHandler.wrapIfUnsupportedType(throwable);
     try {
       if (_expando[throwable] == null) {
         _expando[throwable] = MapEntry(span, transaction);
@@ -633,6 +636,7 @@ class _WeakMap {
     if (throwable == null) {
       return null;
     }
+    throwable = throwableHandler.wrapIfUnsupportedType(throwable);
     try {
       return _expando[throwable] as MapEntry<ISentrySpan, String>?;
     } catch (exception, stackTrace) {
@@ -646,3 +650,35 @@ class _WeakMap {
     return null;
   }
 }
+
+/// A handler for unsupported throwables used for Expando<Object>.
+@visibleForTesting
+class UnsupportedThrowablesHandler {
+  final _unsupportedTypes = {String, int, double, bool};
+  final _unsupportedThrowables = <Object>{};
+
+  dynamic wrapIfUnsupportedType(dynamic throwable) {
+    if (_unsupportedTypes.contains(throwable.runtimeType)) {
+      throwable = _UnsupportedExceptionWrapper(Exception(throwable));
+      _unsupportedThrowables.add(throwable);
+    }
+    return _unsupportedThrowables.lookup(throwable) ?? throwable;
+  }
+}
+
+class _UnsupportedExceptionWrapper {
+  _UnsupportedExceptionWrapper(this.exception);
+
+  final Exception exception;
+
+  @override
+  bool operator ==(Object other) {
+    if (other is _UnsupportedExceptionWrapper) {
+      return other.exception.toString() == exception.toString();
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode => exception.toString().hashCode;
+}

dart/test/hub_test.dart

@@ -150,8 +150,8 @@ void main() {
 
       final capturedEvent = fixture.client.captureEventCalls.first;
 
-      expect(capturedEvent.event.transaction, isNull);
-      expect(capturedEvent.event.contexts.trace, isNull);
+      expect(capturedEvent.event.transaction, 'test');
+      expect(capturedEvent.event.contexts.trace, isNotNull);
     });
   });
 

dart/test/unsupported_throwables_test.dart

@@ -0,0 +1,92 @@
+import 'package:sentry/src/hub.dart';
+import 'package:test/expect.dart';
+import 'package:test/scaffolding.dart';
+
+void main() {
+  late Fixture fixture;
+
+  setUp(() {
+    fixture = Fixture();
+  });
+
+  group('unsupported throwable types', () {
+    test('wrapped string throwable does not throw when expanding', () async {
+      final throwableHandler = fixture.sut;
+      final unsupportedThrowable = 'test throwable';
+      final wrappedThrowable =
+          throwableHandler.wrapIfUnsupportedType(unsupportedThrowable);
+
+      expect(() {
+        fixture.expando[wrappedThrowable];
+      }, returnsNormally);
+    });
+
+    test('wrapped int throwable does not throw when expanding', () async {
+      final throwableHandler = fixture.sut;
+      final unsupportedThrowable = 1;
+      final wrappedThrowable =
+          throwableHandler.wrapIfUnsupportedType(unsupportedThrowable);
+
+      expect(() {
+        fixture.expando[wrappedThrowable];
+      }, returnsNormally);
+    });
+
+    test('wrapped double throwable does not throw when expanding', () async {
+      final throwableHandler = fixture.sut;
+      final unsupportedThrowable = 1.0;
+      final wrappedThrowable =
+          throwableHandler.wrapIfUnsupportedType(unsupportedThrowable);
+
+      expect(() {
+        fixture.expando[wrappedThrowable];
+      }, returnsNormally);
+    });
+
+    test('wrapped bool throwable does not throw when expanding', () async {
+      final throwableHandler = fixture.sut;
+      final unsupportedThrowable = true;
+      final wrappedThrowable =
+          throwableHandler.wrapIfUnsupportedType(unsupportedThrowable);
+
+      expect(() {
+        fixture.expando[wrappedThrowable];
+      }, returnsNormally);
+    });
+
+    test(
+        'creating multiple instances of string wrapped exceptions accesses the same expando value',
+        () async {
+      final unsupportedThrowable = 'test throwable';
+      final throwableHandler = fixture.sut;
+
+      final first =
+          throwableHandler.wrapIfUnsupportedType(unsupportedThrowable);
+      fixture.expando[first] = 1;
+
+      final second =
+          throwableHandler.wrapIfUnsupportedType(unsupportedThrowable);
+      expect(fixture.expando[second], 1);
+      fixture.expando[second] = 2.0;
+
+      final third =
+          throwableHandler.wrapIfUnsupportedType(unsupportedThrowable);
+      expect(fixture.expando[third], 2.0);
+    });
+  });
+
+  group('supported throwable type', () {
+    test('does not wrap exception if it is a supported type', () async {
+      final supportedThrowable = Exception('test throwable');
+      final result = fixture.sut.wrapIfUnsupportedType(supportedThrowable);
+
+      expect(result, supportedThrowable);
+    });
+  });
+}
+
+class Fixture {
+  final expando = Expando();
+
+  UnsupportedThrowablesHandler get sut => UnsupportedThrowablesHandler();
+}