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 179 180 181 182 183 184
//! Logging scopes for slog-rs //! //! Logging scopes are convinience functionality for slog-rs to free user from manually passing //! `Logger` objects around. //! //! Set of macros is also provided as an alternative to original `slog` crate macros, for logging //! directly to `Logger` of the current logging scope. //! //! Note: Part of a `slog` logging philosophy is ability to freely express logging contexts //! according to logical structure, rather than code structure. By using logging scopes the logging //! context is tied to code flow again, which is less expressive. //! //! It is generally advised **NOT** to use `slog_scope` in libraries. Read more in //! [slog-rs FAQ](https://github.com/slog-rs/slog/wiki/FAQ#do-i-have-to-pass-logger-around) //! //! ``` //! #[macro_use(slog_o, slog_info, slog_log, slog_record, slog_record_static, slog_b, slog_kv)] //! extern crate slog; //! #[macro_use] //! extern crate slog_scope; //! extern crate slog_term; //! //! use slog::Drain; //! //! fn foo() { //! slog_info!(slog_scope::logger(), "foo"); //! info!("foo"); // Same as above, but more ergonomic. //! } //! //! fn main() { //! let plain = slog_term::PlainSyncDecorator::new(std::io::stdout()); //! let log = slog::Logger::root( //! slog_term::FullFormat::new(plain) //! .build().fuse(), slog_o!() //! ); //! //! // Make sure to save the guard, see documentation for more information //! let _guard = slog_scope::set_global_logger(log); //! slog_scope::scope(slog_scope::logger().new(slog_o!("scope" => "1")), //! || foo() //! ); //! } #![warn(missing_docs)] #[macro_use(o)] extern crate slog; #[macro_use] extern crate lazy_static; extern crate crossbeam; use slog::*; use std::sync::Arc; use std::cell::RefCell; use crossbeam::sync::ArcCell; /// Log a critical level message using current scope logger #[macro_export] macro_rules! crit( ($($args:tt)+) => { slog_crit![$crate::logger(), $($args)+]; };); /// Log a error level message using current scope logger #[macro_export] macro_rules! error( ($($args:tt)+) => { slog_error![$crate::logger(), $($args)+]; };); /// Log a warning level message using current scope logger #[macro_export] macro_rules! warn( ($($args:tt)+) => { slog_warn![$crate::logger(), $($args)+]; };); /// Log a info level message using current scope logger #[macro_export] macro_rules! info( ($($args:tt)+) => { slog_info![$crate::logger(), $($args)+]; };); /// Log a debug level message using current scope logger #[macro_export] macro_rules! debug( ($($args:tt)+) => { slog_debug![$crate::logger(), $($args)+]; };); /// Log a trace level message using current scope logger #[macro_export] macro_rules! trace( ($($args:tt)+) => { slog_trace![$crate::logger(), $($args)+]; };); thread_local! { static TL_SCOPES: RefCell<Vec<slog::Logger>> = RefCell::new(Vec::with_capacity(8)) } lazy_static! { static ref GLOBAL_LOGGER : ArcCell<slog::Logger> = ArcCell::new( Arc::new( slog::Logger::root(slog::Discard, o!()) ) ); } /// Guard resetting global logger /// /// On drop it will reset global logger to `slog::Discard`. /// This will `drop` any existing global logger. #[must_use] pub struct GlobalLoggerGuard { canceled : bool, } impl GlobalLoggerGuard { fn new() -> Self { GlobalLoggerGuard { canceled: false, } } /// Cancel resetting global logger pub fn cancel_reset(mut self) { self.canceled = true; } } impl Drop for GlobalLoggerGuard { fn drop(&mut self) { if !self.canceled { let _ = GLOBAL_LOGGER.set( Arc::new( slog::Logger::root(slog::Discard, o!()) ) ); } } } /// Set global `Logger` that is returned by calls like `logger()` outside of any logging scope. pub fn set_global_logger(l: slog::Logger) -> GlobalLoggerGuard { let _ = GLOBAL_LOGGER.set(Arc::new(l)); GlobalLoggerGuard::new() } struct ScopeGuard; impl ScopeGuard { fn new(logger: slog::Logger) -> Self { TL_SCOPES.with(|s| { s.borrow_mut().push(logger); }); ScopeGuard } } impl Drop for ScopeGuard { fn drop(&mut self) { TL_SCOPES.with(|s| { s.borrow_mut().pop().expect("TL_SCOPES should contain a logger"); }) } } /// Access the `Logger` for the current logging scope pub fn logger() -> Logger { TL_SCOPES.with(|s| { let s = s.borrow(); match s.last() { Some(logger) => logger.clone(), None => (*GLOBAL_LOGGER.get()).clone(), } }) } /// Execute code in a logging scope /// /// Logging scopes allow using a `slog::Logger` without explicitly /// passing it in the code. /// /// At any time current active `Logger` for a given thread can be retrived /// with `logger()` call. /// /// Logging scopes can be nested and are panic safe. /// /// `logger` is the `Logger` to use during the duration of `f`. /// `with_current_logger` can be used to build it as a child of currently active /// logger. /// /// `f` is a code to be executed in the logging scope. /// /// Note: Thread scopes are thread-local. Each newly spawned thread starts /// with a global logger, as a current logger. pub fn scope<SF, R>(logger: slog::Logger, f: SF) -> R where SF: FnOnce() -> R { let _guard = ScopeGuard::new(logger); f() }