Sentry integration

[vincent-herlemont]

Related to #740 (comment)

Try to integrate sentry

# main.dart
await api.initSentry();

# api.rs
pub fn init_sentry() {
    let _guard = sentry::init(("<sentry endpoint>", sentry::ClientOptions {
        release: sentry::release_name!(),
        ..Default::default()
    }));
}

pub fn fail_function(db_path: String) {
    unreachable!("test sentry.")
}

When I call the fail_function from the dart side an error happens. It logged with a custom handler::ErrorHandler but nothing is sent to Sentry. There is something to particular to do to send errors to sentry with flutter_rust_bridge ?

• Log: flutter: log from rust: internal error: entered unreachable code: test sentry. ✔️
• Sentry: no errors watched ❌

Follow up

• Safe and production-ready to use in Android? · Issue #367 · getsentry/sentry-rust
• Safe and production-ready to use in iOS? · Issue #368 · getsentry/sentry-rust
• Log Backtrace / Stacktrace with a custom ErrorHandler · Discussion #740 · fzyzcjy/flutter_rust_bridge

[fzyzcjy]

You may need to report error to sentry in your own error handler.

[fzyzcjy]

Have you set up the CustomErrorHandler, you need FLUTTER_RUST_BRIDGE_HANDLER

http://cjycode.com/flutter_rust_bridge/feature/handler.html

[vincent-herlemont]

Sure FLUTTER_RUST_BRIDGE_HANDLER is set. Here is the complete custom implementation.

# api.rs
pub static FLUTTER_RUST_BRIDGE_HANDLER: Lazy<DefaultHandler> = Lazy::new(|| {
    DefaultHandler::new(CustomExecutor(handler::ThreadPoolExecutor::new(CustomErrorHandler(handler::ReportDartErrorHandler))),
                        CustomErrorHandler(handler::ReportDartErrorHandler))
});

pub struct CustomExecutor(handler::ThreadPoolExecutor<CustomErrorHandler>);

impl handler::Executor for CustomExecutor {
    fn execute<TaskFn, TaskRet>(&self, wrap_info: WrapInfo, task: TaskFn)
        where
            TaskFn: FnOnce(rust2dart::TaskCallback) -> anyhow::Result<TaskRet> + Send + UnwindSafe + 'static,
            TaskRet: support::IntoDart
    {
        self.0.execute(wrap_info, task)
    }

    fn execute_sync<SyncTaskFn, TaskRet>(&self, wrap_info: WrapInfo, sync_task: SyncTaskFn) -> anyhow::Result<SyncReturn<TaskRet>>
        where
            WireSyncReturnData: From<TaskRet>,
            SyncTaskFn: FnOnce() -> anyhow::Result<SyncReturn<TaskRet>> + UnwindSafe
    {
        self.0.execute_sync(wrap_info, sync_task)
    }
}

#[derive(Clone, Copy)]
pub struct CustomErrorHandler(pub handler::ReportDartErrorHandler);

impl handler::ErrorHandler for CustomErrorHandler {
    fn handle_error(&self, port: i64, error: handler::Error) {
        let message = error.message().to_owned();
        sentry::capture_message(&message, protocol::Level::Fatal);
        logs::info(&message);
    }

    fn handle_error_sync(&self, error: handler::Error) -> WireSyncReturnStruct {
       ...
    }
}

Noted the line logs::info(&message); return the message corrrectly in stdout:

flutter: log from rust: internal error: entered unreachable code: test sentry. 

[fzyzcjy]

So maybe ask sentry what is happening...

Btw IIRC the handler::Error has some rich information inside

[vincent-herlemont]

@fzyzcjy My bad, it's because I must avoid dropping sentry::ClientInitGuard like:

pub static SENTRY_CLIENT: Lazy<Mutex<Option<sentry::ClientInitGuard>>> = Lazy::new(|| {
    Mutex::new(None)
});

pub fn init_sentry() {
    let client: sentry::ClientInitGuard = sentry::init(("<sentry endpoint>", sentry::ClientOptions {
        release: sentry::release_name!(),
        attach_stacktrace: true,
        ..Default::default()
    }));

    let mut sentry_client = SENTRY_CLIENT.lock().unwrap();
    *sentry_client = Some(client);
}
...

Now all works perfectly!

[fzyzcjy]

Great!