Function install_enhanced_handler

src/ore/src/panic.rs:134–280

Overwrites the default panic handler with an enhanced panic handler. The enhanced panic handler: Always emits a backtrace, regardless of how `RUST_BACKTRACE` was configured. Writes to stderr as atomically as possible, to minimize interleaving with concurrent log messages. Reports panics to Sentry. Sentry installs its own panic hook by default that reports the panic and then forwards it to the

()

/// recover. Note that the `catch_unwind` function in the standard library is
/// **not** compatible with this improved panic handler.
pub fn install_enhanced_handler() {
    panic::set_hook(Box::new(move |panic_info| {
        // If we're catching an unwind, do nothing to let the unwind handler
        // run.
        let catching_unwind = CATCHING_UNWIND.with(|v| *v.borrow());
        #[cfg(feature = "async")]
        let catching_unwind_async = CATCHING_UNWIND_ASYNC.try_with(|v| *v).unwrap_or(false);
        #[cfg(not(feature = "async"))]
        let catching_unwind_async = false;
        if catching_unwind != 0 || catching_unwind_async {
            // We're letting the unwind proceed without printing or reporting the
            // panic. The location and backtrace would normally be lost here,
            // because `catch_unwind` only recovers the panic payload (the
            // message). If a caller has opted in via `catch_unwind_with_details`,
            // stash those details now so they can be attached to the resulting
            // error. We only pay the cost of capturing a backtrace when a panic
            // actually occurs, which is the exceptional case.
            let capture_details = CAPTURE_PANIC_DETAILS.with(|v| *v.borrow()) != 0;
            if capture_details {
                let location = panic_info.location().map(|loc| loc.to_string());
                let backtrace = Backtrace::force_capture().to_string();
                CAUGHT_PANIC_DETAILS.with(|details| {
                    *details.borrow_mut() = Some(PanicDetails {
                        location,
                        backtrace,
                    });
                });
            }
            return;
        }

        // Report the panic to Sentry.
        // Note that we can't use `sentry_panic::panic_handler` because that requires the panic
        // integration to be enabled.
        sentry::Hub::with_active(|hub| {
            let event = sentry_panic::PanicIntegration::new().event_from_panic_info(panic_info);
            hub.capture_event(event);
            if let Some(client) = hub.client() {
                client.flush(None);
            }
        });

        // can't use if cfg!() here because that will require chrono::Utc import
        #[cfg(feature = "chrono")]
        let timestamp = Utc::now().format("%Y-%m-%dT%H:%M:%S%.6fZ  ").to_string();
        #[cfg(not(feature = "chrono"))]
        let timestamp = String::new();

        let thread = thread::current();
        let thread_name = thread.name().unwrap_or("<unnamed>");

        let msg = match panic_info.payload().downcast_ref::<&'static str>() {
            Some(s) => *s,
            None => match panic_info.payload().downcast_ref::<String>() {
                Some(s) => &s[..],
                None => "Box<Any>",
            },
        };