#![warn(missing_docs)]
#[macro_use]
extern crate slog;
extern crate slog_term;
extern crate log;
#[macro_use]
extern crate lazy_static;
extern crate crossbeam;
use slog::DrainExt;
use log::LogMetadata;
use std::sync::Arc;
use std::cell::RefCell;
use std::io;
use slog::Level;
use crossbeam::sync::ArcCell;
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!())
)
);
}
fn set_global_logger(l: slog::Logger) {
let _ = GLOBAL_LOGGER.set(Arc::new(l));
}
struct Logger;
fn log_to_slog_level(level: log::LogLevel) -> Level {
match level {
log::LogLevel::Trace => Level::Trace,
log::LogLevel::Debug => Level::Debug,
log::LogLevel::Info => Level::Info,
log::LogLevel::Warn => Level::Warning,
log::LogLevel::Error => Level::Error,
}
}
impl log::Log for Logger {
fn enabled(&self, _: &LogMetadata) -> bool {
true
}
fn log(&self, r: &log::LogRecord) {
let level = log_to_slog_level(r.metadata().level());
let args = r.args();
let target = r.target();
let module = r.location().__module_path;
let file = r.location().__file;
let line = r.location().line();
with_current_logger(|l| {
let s = slog::RecordStatic {
level: level,
file: file,
line: line,
column: 0,
function: "",
module: module,
target: target,
};
l.log(&slog::Record::new(&s, *args, &[]))
})
}
}
pub fn set_logger(logger: slog::Logger) -> Result<(), log::SetLoggerError> {
log::set_logger(|max_log_level| {
max_log_level.set(log::LogLevelFilter::max());
set_global_logger(logger);
Box::new(Logger)
})
}
pub fn set_logger_level(logger: slog::Logger,
log_level_filter: log::LogLevelFilter)
-> Result<(), log::SetLoggerError> {
log::set_logger(|max_log_level| {
max_log_level.set(log_level_filter);
set_global_logger(logger);
Box::new(Logger)
})
}
pub fn init() -> Result<(), log::SetLoggerError> {
let drain = slog::level_filter(Level::Info, slog_term::streamer().compact().build());
set_logger(slog::Logger::root(drain.fuse(), o!()))
}
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");
})
}
}
pub fn with_current_logger<F, R>(f: F) -> R
where F: FnOnce(&slog::Logger) -> R
{
TL_SCOPES.with(|s| {
let s = s.borrow();
if s.is_empty() {
f(&GLOBAL_LOGGER.get())
} else {
f(&s[s.len() - 1])
}
})
}
pub fn scope<SF, R>(logger: slog::Logger, f: SF) -> R
where SF: FnOnce() -> R
{
let _guard = ScopeGuard::new(logger);
f()
}
pub struct StdLog;
impl slog::Drain for StdLog {
type Error = io::Error;
fn log(&self, info: &slog::Record, _: &slog::OwnedKeyValueList) -> io::Result<()> {
let level = match info.level() {
slog::Level::Critical => log::LogLevel::Error,
slog::Level::Error => log::LogLevel::Error,
slog::Level::Warning => log::LogLevel::Warn,
slog::Level::Info => log::LogLevel::Info,
slog::Level::Debug => log::LogLevel::Debug,
slog::Level::Trace => log::LogLevel::Trace,
};
let target = info.target();
let location = log::LogLocation {
__module_path: info.module(),
__file: info.file(),
__line: info.line(),
};
log::__log(level, target, &location, format_args!("{}", info.msg()));
Ok(())
}
}