Errors that don't crash the app shouldn't be logged as fatal

[feinstein]

Problem Statement

Fatal usually means your app crashed (fatal == death), but FlutterErrorIntegration on line 64 logs all FlutterError as fatal instead of error, even though they are not crashing the app.

I have wrapped my app with runZonedGuarded and all errors are directed to Sentry so AFAIK the only way I can have a crash is from the native side.

Solution Brainstorm

The FlutterError level should be an option we can pass, so we can decide the severity it has.

Are you willing to submit a PR?

None

[buenaflor]

Thank you for the issue!

I don't see any reason why not. What's your take here @denrase

[ueman]

This conflicts with #456 and #1535

On the flutter side, it can also be changed via beforeSend or event processors.

In the end this change would also affect the release health to make it look better than it actually is.

Also relates to getsentry/rfcs#10

[buenaflor]

I see, thx for the context!

Then I'd also suggest using beforeSend or event processors to change if necessary.

[feinstein]

I thought the Sentry plugin would mark an exception as fatal, if it was detected on the native side that the last time the app was executed it crashed.

I don't think this makes the release looks better than it is, since having a crash is way worse than having an error.

If you crashed (thus fatal), than your user can't do anything else. If you had an exception that wasn't caugh, but didn't crash your app, there's a big chance your app is still able to run, and your user can still use the app and enjoy it (hence not fatal, but an error).

If I use beforeSend to change every event from fatal to error, than I would never have a fatal alert from the dart side, side I run the app inside a runZonedGuarded. But what happens if I have custom native code and it crashes the app? Does Sentry detect it on the native side and sends a fatal alarm on the native integration? Or does Sentry delegate to dart's next run and beforeSend would wrongly mark a crash that should have been fatal as an error?

[ueman]

I basically agree with your points. However, the nuance here is that the SDK doesn't actually know about fatal crashes. It just knows about handled or unhandled exceptions right now. (This is explained in more detail in the linked RFC)

On Sentry every unhandled exception is marked as fatal.

Because Flutter typically doesn't crash at all, the next worst exception the unhandled one, which is now marked as fatal, since Sentry can't yet differentiate between unhandled + crashing, unhandled + not crashing and handled.

But what happens if I have custom native code and it crashes the app? Does Sentry detect it on the native side and sends a fatal alarm on the native integration?

Yes, native crashes will still be marked as fatal if they crash the app, since they don't go through the beforeSend on the Dart side.