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

//! Standard Rust log crate adapter to slog-rs
//!
//! This crate allows setting one of `slog` `Logger`s
//! as a global handler of Rust de facto standard logging statements
//! (eg ``info!(...)``) provided by `log` create.
//!
//! ```
//! #[macro_use]
//! extern crate slog;
//! #[macro_use]
//! extern crate log;
//! extern crate slog_stdlog;
//!
//! use slog::*;
//!
//! fn main() {
//!     let root = Logger::new_root(
//!         o!("build-id" => "8dfljdf"),
//!         slog::drain::discard(),
//!     );
//!     slog_stdlog::set_logger(root).unwrap();
//!     info!("standard logging redirected to slog");
//! }
//! ```
#![warn(missing_docs)]

#[macro_use]
extern crate slog;
extern crate log;

use log::LogMetadata;
use std::sync;

use slog::Level;

// TODO: Change this to use thread local copies
struct Logger(sync::Mutex<slog::Logger>);

impl Logger {
    fn new(logger: slog::Logger) -> Self {
        Logger(sync::Mutex::new(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();
        // TODO: What to do with it?
        let _target = r.target();
        let module = r.location().module_path();
        let file = r.location().file();
        let line = r.location().line();
        {
            let _ = self.0
                .lock()
                .map(|l| (*l).log(&slog::RecordInfo::new(level, args, file, line, module, &[])));
        }
    }
}

/// Set a `slog::Logger` as a global `log` create handler
///
/// This will forward all `log` records to `slog` logger.
pub fn set_logger(logger: slog::Logger) -> Result<(), log::SetLoggerError> {
    log::set_logger(|max_log_level| {
        max_log_level.set(log::LogLevelFilter::max());
        Box::new(Logger::new(logger))
    })
}

/// Set a `slog::Logger` as a global `log` create handler
///
/// This will forward `log` records that satisfy `log_level_filter` to `slog` 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);
        Box::new(Logger::new(logger))
    })
}