1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//! Sentry supported panic handler.

#[cfg(doc)]
use crate::{shutdown, Shutdown};
use crate::{Event, Level, Value};
#[cfg(doc)]
use std::process::abort;
use std::{
    collections::BTreeMap,
    convert::TryFrom,
    panic::{self, PanicInfo},
};

/// Panic handler to send an [`Event`] with the current stacktrace to Sentry.
///
/// `before_send` is a callback that is able to modify the [`Event`] before it
/// is captures.
///
/// `hook` is a callback that is run after the [`Event`] is captured.
///
/// # Notes
/// This will not work properly if used with `panic = "abort"` because
/// [`Shutdown`] is never unwound. To fix this make sure you make the panic
/// handler itself call [`shutdown`].
///
/// Rust doesn't allow panics inside of a panicking thread and reacts with an
/// [`abort`]: if a custom transport or a before-send callback was registered
/// that can panic, it might lead to any [`panic!`] being an [`abort`] instead.
///
/// # Examples
/// ```should_panic
/// # use anyhow::Result;
/// # use sentry_contrib_native::{Options, set_hook};
/// fn main() -> Result<()> {
///     // pass original panic handler provided by rust to retain it's functionality
///     set_hook(None, Some(std::panic::take_hook()));
///     // it can also be removed
///     set_hook(None, None);
///     // the `Event` sent by a panic can also be modified
///     set_hook(
///         Some(Box::new(|mut event| {
///             // do something with the event and then return it
///             event
///         })),
///         None,
///     );
///
///     let _shutdown = Options::new().init()?;
///
///     panic!("application panicked")
/// }
/// ```
/// If you are using `panic = "abort"` make sure to call [`shutdown`] inside the
/// panic handler.
/// ```
/// # use sentry_contrib_native::{set_hook, shutdown};
/// set_hook(None, Some(Box::new(|_| shutdown())));
/// ```
pub fn set_hook(
    before_send: Option<Box<dyn Fn(Event) -> Event + 'static + Send + Sync>>,
    hook: Option<Box<dyn Fn(&PanicInfo) + 'static + Send + Sync>>,
) {
    panic::set_hook(Box::new(move |panic_info| {
        let mut event = Event::new_message(
            Level::Error,
            Some("rust panic".into()),
            panic_info.to_string(),
        );

        if let Some(location) = panic_info.location() {
            let mut extra = BTreeMap::new();
            extra.insert("file", Value::from(location.file()));

            if let Ok(line) = i32::try_from(location.line()) {
                extra.insert("line", line.into());
            }

            if let Ok(column) = i32::try_from(location.column()) {
                extra.insert("column", column.into());
            }

            event.insert("extra", extra);
        }

        event.add_stacktrace(0);

        if let Some(before_send) = &before_send {
            event = before_send(event);
        }

        event.capture();

        if let Some(hook) = &hook {
            hook(panic_info);
        }
    }));
}

#[cfg(test)]
#[rusty_fork::fork_test(timeout_ms = 60000)]
fn hook() {
    use std::{
        sync::atomic::{AtomicBool, Ordering},
        thread,
    };

    static BEFORE_SEND: AtomicBool = AtomicBool::new(false);
    static HOOK: AtomicBool = AtomicBool::new(false);

    set_hook(None, None);
    set_hook(
        Some(Box::new(|event| {
            BEFORE_SEND.store(true, Ordering::SeqCst);
            event
        })),
        Some(Box::new(|_| HOOK.store(true, Ordering::SeqCst))),
    );

    thread::spawn(|| panic!("this panic is a test"))
        .join()
        .unwrap_err();

    assert!(BEFORE_SEND.load(Ordering::SeqCst));
    assert!(HOOK.load(Ordering::SeqCst));
}