feat: sentry error logging

Author: CoderUni

lib/app/view/app.dart

@@ -19,6 +19,7 @@ class App extends StatelessWidget {
     required this.settingsBloc,
     super.key,
   });
+
   final FlutterSecureStorage secureStorage;
   final SettingsBloc settingsBloc;
 

lib/bootstrap.dart

@@ -22,44 +22,73 @@ class AppBlocObserver extends BlocObserver {
 
   @override
   void onError(BlocBase<dynamic> bloc, Object error, StackTrace stackTrace) {
+    Sentry.captureException(
+      error,
+      stackTrace: stackTrace,
+    );
+
     log('onError(${bloc.runtimeType}, $error, $stackTrace)');
     super.onError(bloc, error, stackTrace);
   }
 }
 
 Future<void> bootstrap(
+  ISentrySpan span,
   FutureOr<Widget> Function(
     FlutterSecureStorage secureStorage,
     SettingsBloc settingsBloc,
   ) builder,
 ) async {
-  SentryWidgetsFlutterBinding.ensureInitialized();
+  final widgetFlutterBindingSpan = span.startChild(
+    'initialize SentryWidgetsFlutterBinding',
+    description: 'calls SentryWidgetsFlutterBinding.ensureInitialized()',
+  );
+
+  // Ensure SentryWidgetsFlutterBinding is initialized
+  try {
+    SentryWidgetsFlutterBinding.ensureInitialized();
+  } catch (e) {
+    widgetFlutterBindingSpan
+      ..throwable = e
+      ..status = const SpanStatus.notFound();
+  } finally {
+    await widgetFlutterBindingSpan.finish();
+  }
+
   FlutterError.onError = (details) {
-    // TODO: Add Sentry error reporting
-    /*
     Sentry.captureException(
       details,
       stackTrace: details.stack,
     );
-    */
 
     log(details.exceptionAsString(), stackTrace: details.stack);
   };
 
   // Initialize local storage repository
   // final localStorage = LocalStorage(sharedPreferences);
 
+  final secureStorageBinding = span.startChild(
+    'retrieve secure storage values',
+    description: 'retrieve required startup values from secure storage',
+  );
   // Initialize secure storage
   const secureStorage = FlutterSecureStorage();
-
-  // Create a random salt if it doesn't exist.
-  final salt = await secureStorage.read(key: KeyNameConstants.md5Salt);
-  if (salt == null || salt.isEmpty) {
-    // Create a random salt and store it in secure storage
-    await secureStorage.write(
-      key: KeyNameConstants.md5Salt,
-      value: DateTime.now().millisecondsSinceEpoch.toString(),
-    );
+  try {
+    // Create a random salt if it doesn't exist.
+    final salt = await secureStorage.read(key: KeyNameConstants.md5Salt);
+    if (salt == null || salt.isEmpty) {
+      // Create a random salt and store it in secure storage
+      await secureStorage.write(
+        key: KeyNameConstants.md5Salt,
+        value: DateTime.now().millisecondsSinceEpoch.toString(),
+      );
+    }
+  } catch (e) {
+    secureStorageBinding
+      ..throwable = e
+      ..status = const SpanStatus.internalError();
+  } finally {
+    await secureStorageBinding.finish();
   }
 
   // Initialize settings bloc

lib/main_development.dart

@@ -14,18 +14,34 @@ Future<void> main() async {
       options
         ..environment = 'development'
         ..tracesSampleRate = 1.0
+        // Don't send request headers and user IP in development
+        ..sendDefaultPii = false
         ..dsn = dotenv.env['sentryLink'];
     },
     appRunner: () async {
-      await bootstrap((
-        FlutterSecureStorage secureStorage,
-        SettingsBloc settingsBloc,
-      ) async {
-        return App(
-          secureStorage: secureStorage,
-          settingsBloc: settingsBloc,
-        );
-      });
+      final transaction = Sentry.startTransaction(
+        'bootstrap()',
+        'initialization',
+        bindToScope: true,
+      );
+
+      try {
+        await bootstrap(transaction, (
+          FlutterSecureStorage secureStorage,
+          SettingsBloc settingsBloc,
+        ) async {
+          return App(
+            secureStorage: secureStorage,
+            settingsBloc: settingsBloc,
+          );
+        });
+      } catch (exception) {
+        transaction
+          ..throwable = exception
+          ..status = const SpanStatus.internalError();
+      } finally {
+        await transaction.finish();
+      }
     },
   );
 }

lib/main_production.dart

@@ -14,18 +14,33 @@ Future<void> main() async {
       options
         ..environment = 'production'
         ..tracesSampleRate = 1.0
+        ..sendDefaultPii = true
         ..dsn = dotenv.env['sentryLink'];
     },
     appRunner: () async {
-      await bootstrap((
-        FlutterSecureStorage secureStorage,
-        SettingsBloc settingsBloc,
-      ) async {
-        return App(
-          secureStorage: secureStorage,
-          settingsBloc: settingsBloc,
-        );
-      });
+      final transaction = Sentry.startTransaction(
+        'bootstrap()',
+        'initialization',
+        bindToScope: true,
+      );
+
+      try {
+        await bootstrap(transaction, (
+          FlutterSecureStorage secureStorage,
+          SettingsBloc settingsBloc,
+        ) async {
+          return App(
+            secureStorage: secureStorage,
+            settingsBloc: settingsBloc,
+          );
+        });
+      } catch (exception) {
+        transaction
+          ..throwable = exception
+          ..status = const SpanStatus.internalError();
+      } finally {
+        await transaction.finish();
+      }
     },
   );
 }

lib/main_staging.dart

@@ -14,18 +14,33 @@ Future<void> main() async {
       options
         ..environment = 'staging'
         ..tracesSampleRate = 1.0
+        ..sendDefaultPii = true
         ..dsn = dotenv.env['sentryLink'];
     },
     appRunner: () async {
-      await bootstrap((
-        FlutterSecureStorage secureStorage,
-        SettingsBloc settingsBloc,
-      ) async {
-        return App(
-          secureStorage: secureStorage,
-          settingsBloc: settingsBloc,
-        );
-      });
+      final transaction = Sentry.startTransaction(
+        'bootstrap()',
+        'initialization',
+        bindToScope: true,
+      );
+
+      try {
+        await bootstrap(transaction, (
+          FlutterSecureStorage secureStorage,
+          SettingsBloc settingsBloc,
+        ) async {
+          return App(
+            secureStorage: secureStorage,
+            settingsBloc: settingsBloc,
+          );
+        });
+      } catch (exception) {
+        transaction
+          ..throwable = exception
+          ..status = const SpanStatus.internalError();
+      } finally {
+        await transaction.finish();
+      }
     },
   );
 }