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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

//! Implementation details for [`Options::set_logger`].

#[cfg(doc)]
use crate::Options;
use crate::{ffi, Level};
use once_cell::sync::Lazy;
#[cfg(doc)]
use std::process::abort;
use std::{
    fmt::{Display, Formatter, Result as FmtResult},
    mem::ManuallyDrop,
    os::raw::{c_char, c_void},
    process,
    sync::Mutex,
};

/// How global [`Logger`] data is stored.
pub type Data = Box<Box<dyn Logger>>;

/// Store [`Options::set_logger`] data to properly deallocate later.
pub static LOGGER: Lazy<Mutex<Option<Data>>> = Lazy::new(|| Mutex::new(None));

/// Trait to help pass data to [`Options::set_logger`].
///
/// # Examples
/// ```
/// # use sentry_contrib_native::{Level, Logger, Message, Options};
/// # use std::sync::atomic::{AtomicUsize, Ordering};
/// # fn main() -> anyhow::Result<()> {
/// struct Log {
///     logged: AtomicUsize,
/// };
///
/// impl Logger for Log {
///     fn log(&self, level: Level, message: Message) {
///         self.logged.fetch_add(1, Ordering::SeqCst);
///         println!("[{}]: {}", level, message);
///     }
/// }
///
/// let mut options = Options::new();
/// options.set_logger(Log {
///     logged: AtomicUsize::new(0),
/// });
/// let _shutdown = options.init()?;
/// # Ok(()) }
/// ```
pub trait Logger: 'static + Send + Sync {
    /// Logger callback.
    ///
    /// # Notes
    /// The caller of this function will catch any unwinding panics and
    /// [`abort`] if any occured.
    ///
    /// # Examples
    /// ```
    /// # use sentry_contrib_native::{Level, Logger, Message};
    /// # use std::sync::atomic::{AtomicUsize, Ordering};
    /// struct Log {
    ///     logged: AtomicUsize,
    /// };
    ///
    /// impl Logger for Log {
    ///     fn log(&self, level: Level, message: Message) {
    ///         self.logged.fetch_add(1, Ordering::SeqCst);
    ///         println!("[{}]: {}", level, message);
    ///     }
    /// }
    /// ```
    fn log(&self, level: Level, message: Message);
}

impl<T: Fn(Level, Message) + 'static + Send + Sync> Logger for T {
    fn log(&self, level: Level, message: Message) {
        self(level, message);
    }
}

/// Message received for custom logger.
#[derive(Clone, Debug, Hash, Eq, Ord, PartialEq, PartialOrd)]
pub enum Message {
    /// Message could be parsed into a valid UTF-8 [`String`].
    Utf8(String),
    /// Message could not be parsed into a valid UTF-8 [`String`] and is
    /// stored as a `Vec<u8>`.
    Raw(Vec<u8>),
}

impl Display for Message {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        match self {
            Self::Utf8(text) => write!(f, "{}", text),
            Self::Raw(raw) => write!(f, "{}", String::from_utf8_lossy(raw)),
        }
    }
}

/// Function to pass to [`sys::options_set_logger`], which in turn calls the
/// user defined one.
///
/// This function will catch any unwinding panics and [`abort`] if any occured.
pub extern "C" fn logger(
    level: i32,
    message: *const c_char,
    args: *mut c_void,
    userdata: *mut c_void,
) {
    let logger = userdata.cast::<Box<dyn Logger>>();
    let logger = ManuallyDrop::new(unsafe { Box::from_raw(logger) });

    let level = ffi::catch(|| Level::from_raw(level));

    let message = if let Ok(message) = unsafe { vsprintf::vsprintf(message, args) } {
        Message::Utf8(message)
    } else {
        Message::Raw(
            unsafe { vsprintf::vsprintf_raw(message, args) }.unwrap_or_else(|_| process::abort()),
        )
    };

    ffi::catch(|| logger.log(level, message));
}

#[cfg(test)]
#[rusty_fork::fork_test(timeout_ms = 60000)]
#[allow(clippy::items_after_statements)]
fn logger_test() -> anyhow::Result<()> {
    use crate::{Level, Logger, Message, Options};
    use std::{
        cell::RefCell,
        sync::atomic::{AtomicBool, Ordering},
    };

    thread_local! {
        static LOGGED: RefCell<bool> = RefCell::new(false);
    }

    struct Log {
        logged: AtomicBool,
    }

    impl Logger for Log {
        fn log(&self, level: Level, message: Message) {
            self.logged.store(true, Ordering::SeqCst);
            println!("[{}]: {}", level, message);
        }
    }

    impl Drop for Log {
        fn drop(&mut self) {
            LOGGED.with(|logged| *logged.borrow_mut() = *self.logged.get_mut());
        }
    }

    let mut options = Options::new();
    options.set_debug(true);
    options.set_logger(|level, message| {
        LOGGED.with(|logged| *logged.borrow_mut() = true);
        println!("[{}]: {}", level, message);
    });
    options.init()?;

    Ok(())
}

#[cfg(test)]
#[rusty_fork::fork_test(timeout_ms = 60000)]
#[should_panic]
fn catch_panic() -> anyhow::Result<()> {
    use crate::Options;

    let mut options = Options::new();
    options.set_debug(true);
    options.set_logger(|_, _| panic!("this is a test"));
    options.init()?;

    Ok(())
}