forked from slog-rs/scope
-
Notifications
You must be signed in to change notification settings - Fork 0
/
lib.rs
291 lines (256 loc) · 7.91 KB
/
lib.rs
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
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
//! Logging scopes for slog-rs
//!
//! Logging scopes are convenience 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.
//!
//! # Set global logger upfront
//!
//! **Warning**: Since `slog-scope` version 4.0.0, `slog-scope` defaults to
//! panicking on logging if no scope or global logger was set. Because of it, it
//! is advised to always set a global logger upfront with `set_global_logger`.
//!
//! # Using `slog-scope` as a part of API is not advised
//!
//! Part of a `slog` logging philosophy is ability to freely express logging contexts
//! according to logical structure, rather than callstack 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)
//!
//! ```ignore
//! #[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 and a bit faster
//! // since it uses `with_logger`
//! }
//!
//! 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)]
pub extern crate slog;
#[macro_use]
extern crate lazy_static;
extern crate arc_swap;
use slog::{Logger, OwnedKVList, Record};
use arc_swap::ArcSwap;
use std::cell::RefCell;
use std::sync::Arc;
use std::result;
/// Log a message using current scope logger
#[macro_export]
macro_rules! log(($lvl:expr, $($args:tt)+) => {
if $lvl.as_usize() <= $crate::slog::__slog_static_max_level().as_usize() {
$crate::with_logger(|logger| $crate::slog::slog_log![logger, $lvl, $($args)+])
}
};);
/// Log a critical level message using current scope logger
#[macro_export]
macro_rules! crit {
(#$tag:expr, $($args:tt)+) => {
$crate::log!($crate::slog::Level::Critical, $tag, $($args)+)
};
($($args:tt)+) => {
$crate::log!($crate::slog::Level::Critical, "", $($args)+)
};
}
/// Log a error level message using current scope logger
#[macro_export]
macro_rules! error {
(#$tag:expr, $($args:tt)+) => {
$crate::log!($crate::slog::Level::Error, $tag, $($args)+)
};
($($args:tt)+) => {
$crate::log!($crate::slog::Level::Error, "", $($args)+)
};
}
/// Log a warning level message using current scope logger
#[macro_export]
macro_rules! warn {
(#$tag:expr, $($args:tt)+) => {
$crate::log!($crate::slog::Level::Warning, $tag, $($args)+)
};
($($args:tt)+) => {
$crate::log!($crate::slog::Level::Warning, "", $($args)+)
};
}
/// Log a info level message using current scope logger
#[macro_export]
macro_rules! info {
(#$tag:expr, $($args:tt)+) => {
$crate::log!($crate::slog::Level::Info, $tag, $($args)+)
};
($($args:tt)+) => {
$crate::log!($crate::slog::Level::Info, "", $($args)+)
};
}
/// Log a debug level message using current scope logger
#[macro_export]
macro_rules! debug {
(#$tag:expr, $($args:tt)+) => {
$crate::log!($crate::slog::Level::Debug, $tag, $($args)+)
};
($($args:tt)+) => {
$crate::log!($crate::slog::Level::Debug, "", $($args)+)
};
}
/// Log a trace level message using current scope logger
#[macro_export]
macro_rules! trace {
(#$tag:expr, $($args:tt)+) => {
$crate::log!($crate::slog::Level::Critical, $tag, $($args)+)
};
($($args:tt)+) => {
$crate::log!($crate::slog::Level::Trace, "", $($args)+)
};
}
thread_local! {
static TL_SCOPES: RefCell<Vec<*const slog::Logger>> = RefCell::new(Vec::with_capacity(8))
}
lazy_static! {
static ref GLOBAL_LOGGER : ArcSwap<slog::Logger> = ArcSwap::from(
Arc::new(
slog::Logger::root(slog::Discard, o!())
)
);
}
struct NoGlobalLoggerSet;
impl slog::Drain for NoGlobalLoggerSet {
type Ok = ();
type Err = slog::Never;
fn log(&self,
_record: &Record,
_values: &OwnedKVList)
-> result::Result<Self::Ok, Self::Err> {
panic!(
"slog-scope: No logger set. Use `slog_scope::set_global_logger` or `slog_scope::scope`."
)
}
}
/// 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 {
/// Getter for canceled to check status
pub fn is_canceled(&self) -> bool {
self.canceled
}
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 {
GLOBAL_LOGGER.store(
Arc::new(
slog::Logger::root(NoGlobalLoggerSet, 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 {
GLOBAL_LOGGER.store(Arc::new(l));
GlobalLoggerGuard::new()
}
struct ScopeGuard;
impl ScopeGuard {
fn new(logger: &slog::Logger) -> Self {
TL_SCOPES.with(|s| { s.borrow_mut().push(logger as *const 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
///
/// This function needs to clone an underlying scoped
/// `Logger`. If performance is of vital importance,
/// use `with_logger`.
pub fn logger() -> Logger {
TL_SCOPES.with(|s| {
let s = s.borrow();
match s.last() {
Some(logger) => (unsafe {&**logger}).clone(),
None => Logger::clone(&GLOBAL_LOGGER.load())
}
})
}
/// Access the `Logger` for the current logging scope
///
/// This function doesn't have to clone the Logger
/// so it might be a bit faster.
pub fn with_logger<F, R>(f : F) -> R
where F : FnOnce(&Logger) -> R {
TL_SCOPES.with(|s| {
let s = s.borrow();
match s.last() {
Some(logger) => f(unsafe {&**logger}),
None => f(&GLOBAL_LOGGER.load()),
}
})
}
/// 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()
}