Exception handling and logging in dart/Flutter - Talker

final result = service.makeLogic();
print(result);

String? result;
try {
  result = service.makeLogic();
} on Exception catch (e) {
  print(e);
}
result ??= 'Can`t get result';
print(result);
```
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/68pdxigf9o6iosf5575s.png)
In this case, the program will be able to continue execution and will terminate correctly 

## Exceptions Tracking
We've figured out how to catch bugs, but what to do with tracking and error analysis?

There is a [Crashlytics](https://firebase.google.com/products/crashlytics) service from firebase for Flutter applications.
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/07031x14um8cux7cvdoz.png)

It can track errors in your Flutter application.
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bb4k88s0rqc3q7fnsn3f.png)

Crashlytics, Sentry, AppsFlyer and many others. There are even projects that make their own analytical system.
In startups, these tools can change frequently. Are you want to **manually write something like this every time?**
```dart
  try {
    // your code...
  } on Exception catch (exception, stackTrace) {
    Crashlytics.instance
        .recordError(exception, stackTrace, reason: exception.message);
    Sentry.captureException(exception, stackTrace: stackTrace);
    YourOwnAnalytics.sendError(exception, stackTrace: stackTrace);
    ScaffoldMessenger.of(context)
        .showSnackBar(SnackBar(content: Text(exception.toString())));
    Logger.error('Something Service exception', exception, stackTrace);
  }
```

It looks terrible🤢
But **how we can fix this case?**

## Talker
![Image description](https://github.com/Frezyx/talker/raw/master/docs/assets/gifs/talker_big.gif?raw=true)
I present to you the stable release of my library [Talker](https://github.com/Frezyx/talker)

Talker is advanced exception handling and logging tool for dart/flutter applications.
It is a system for storing and distributing debugging information of your application.

### Get started 
You can get started at [Talker documentation site](https://frezyx.github.io/talker/guide/get-started.html)

But I'll tell you here too

For [Dart](https://dart.dev/) applications you need add **talker** dependency to your **pubspec.yaml**
```yaml
dependencies:
  talker: ^1.0.0
```

For [Flutter](https://flutter.dev/) applications you can add **talker_flutter** or **talker** dependency to your **pubspec.yaml**
```yaml
dependencies:
  talker_flutter: ^1.0.0
```

**What's difference ?**<br>
**talker_flutter** has advanced features that's convenient to use in the Flutter application
like [TalkerScreen](../guide/talker-flutter.html#TalkerScreen) or [TalkerRouteObserver](../guide/talker-flutter.html#TalkerRouteObserver)<br>
**talker** package working both for dart and flutter applications

## Easy to use
All you need for the first start is to import the dependency and create an instance of the Talker class
```dart
import 'package:talker/talker.dart';
void main(){
  final talker = Talker();
  talker.info('I`m alive 😄');
}

final talker = Talker();
// Handle exceptions and errors
try {
  // your code...
} on Exception catch (e, st) {
  talker.handle(e, st, 'Exception in ...');
}

// Make logs
talker.log('App is started'),
talker.error('App is started'),
talker.waring('App is started'),

void main() {
  final talker = Talker();
  runZonedGuarded(
    () => runApp(BaseEample(talker: talker)),
    (Object error, StackTrace stack) {
      talker.handle(error, stack, 'Uncaught app exception');
    },
  );
}

  try {
    // your code...
  } on Exception catch (exception, stackTrace) {
    Crashlytics.instance
        .recordError(exception, stackTrace, reason: exception.message);
    Sentry.captureException(exception, stackTrace: stackTrace);
    YourOwnAnalytics.sendError(exception, stackTrace: stackTrace);
    ScaffoldMessenger.of(context)
        .showSnackBar(SnackBar(content: Text(exception.toString())));
    Logger.error('Something Service exception', exception, stackTrace);
  }

try {
  // your code...
} on Exception catch (e, st) {
    talker.handle(e, st, 'Something Service exception');
}

class ExceptionsAnalyticsTalkerObserver extends TalkerObserver {
  ExceptionsAnalyticsTalkerObserver();

  @override
  Function(TalkerException e) get onException => (e) {
        Crashlytics.instance
            .recordError(e.exception, stack: e.stackTrace, reason: e.message);
        Sentry.captureException(e.exception, stackTrace: e.stackTrace);
        YourOwnAnalytics.sendError(e.exception, stackTrace: e.stackTrace);
      };
}

final talker = Talker(
    observers: [
        ExceptionsAnalyticsTalkerObserver(),
    ],
);