317 lines · 8.6 KB · Rust
RawDownload
//! # loggerpub use log as log_impl; mod env_config;pub mod filter;pub mod sink; pub use sink::{init_output_file, init_output_stdout}; pub const SCOPE_DEPTH_MAX: usize = 4; pub fn init() {    process_env();    log::set_logger(&ZLOG).expect("Logger should not be initialized twice");    log::set_max_level(log::LevelFilter::max());} pub fn process_env() {    let Ok(env_config) = std::env::var("ZED_LOG").or_else(|_| std::env::var("RUST_LOG")) else {        return;    };    match env_config::parse(&env_config) {        Ok(filter) => {            filter::init_env_filter(filter);            filter::refresh();        }        Err(err) => {            eprintln!("Failed to parse log filter: {}", err);        }    }} static ZLOG: Zlog = Zlog {}; pub struct Zlog {} impl log::Log for Zlog {    fn enabled(&self, metadata: &log::Metadata) -> bool {        filter::is_possibly_enabled_level(metadata.level())    }     fn log(&self, record: &log::Record) {        if !self.enabled(record.metadata()) {            return;        }        let scope = match record.module_path_static() {            Some(module_path) => {                // TODO: better module name -> scope translation                let crate_name = private::extract_crate_name_from_module_path(module_path);                private::scope_new(&[crate_name])            }            // TODO: when do we hit this            None => private::scope_new(&["*unknown*"]),        };        let level = record.metadata().level();        if !filter::is_scope_enabled(&scope, level) {            return;        }        sink::submit(sink::Record {            scope,            level,            message: record.args(),        });    }     fn flush(&self) {        // todo: necessary?        sink::flush();    }} #[macro_export]macro_rules! log {    ($logger:expr, $level:expr, $($arg:tt)+) => {        let level = $level;        let logger = $logger;        let enabled = $crate::filter::is_scope_enabled(&logger.scope, level);        if enabled {            $crate::sink::submit($crate::sink::Record {                scope: logger.scope,                level,                message: &format_args!($($arg)+),            });        }    }} #[macro_export]macro_rules! trace {    ($logger:expr => $($arg:tt)+) => {        $crate::log!($logger, $crate::log_impl::Level::Trace, $($arg)+);    };    ($($arg:tt)+) => {        $crate::log!($crate::default_logger!(), $crate::log_impl::Level::Trace, $($arg)+);    };} #[macro_export]macro_rules! debug {    ($logger:expr => $($arg:tt)+) => {        $crate::log!($logger, $crate::log_impl::Level::Debug, $($arg)+);    };    ($($arg:tt)+) => {        $crate::log!($crate::default_logger!(), $crate::log_impl::Level::Debug, $($arg)+);    };} #[macro_export]macro_rules! info {    ($logger:expr => $($arg:tt)+) => {        $crate::log!($logger, $crate::log_impl::Level::Info, $($arg)+);    };    ($($arg:tt)+) => {        $crate::log!($crate::default_logger!(), $crate::log_impl::Level::Info, $($arg)+);    };} #[macro_export]macro_rules! warn {    ($logger:expr => $($arg:tt)+) => {        $crate::log!($logger, $crate::log_impl::Level::Warn, $($arg)+);    };    ($($arg:tt)+) => {        $crate::log!($crate::default_logger!(), $crate::log_impl::Level::Warn, $($arg)+);    };} #[macro_export]macro_rules! error {    ($logger:expr => $($arg:tt)+) => {        $crate::log!($logger, $crate::log_impl::Level::Error, $($arg)+);    };    ($($arg:tt)+) => {        $crate::log!($crate::default_logger!(), $crate::log_impl::Level::Error, $($arg)+);    };} /// Creates a timer that logs the duration it was active for either when/// it is dropped, or when explicitly stopped using the `end` method./// Logs at the `trace` level./// Note that it will include time spent across await points/// (i.e. should not be used to measure the performance of async code)/// However, this is a feature not a bug, as it allows for a more accurate/// understanding of how long the action actually took to complete, including/// interruptions, which can help explain why something may have timed out,/// why it took longer to complete than it would had the await points resolved/// immediately, etc.#[macro_export]macro_rules! time {    ($logger:expr => $name:expr) => {        $crate::Timer::new($logger, $name)    };    ($name:expr) => {        time!($crate::default_logger!() => $name)    };} #[macro_export]macro_rules! scoped {    ($parent:expr => $name:expr) => {{        let parent = $parent;        let name = $name;        let mut scope = parent.scope;        let mut index = 1; // always have crate/module name        while index < scope.len() && !scope[index].is_empty() {            index += 1;        }        if index >= scope.len() {            #[cfg(debug_assertions)]            {                panic!("Scope overflow trying to add scope {}", name);            }            #[cfg(not(debug_assertions))]            {                $crate::warn!(                    parent =>                    "Scope overflow trying to add scope {}... ignoring scope",                    name                );            }        }        scope[index] = name;        $crate::Logger { scope }    }};    ($name:expr) => {        $crate::scoped!($crate::default_logger!() => $name)    };} #[macro_export]macro_rules! default_logger {    () => {        $crate::Logger {            scope: $crate::private::scope_new(&[$crate::crate_name!()]),        }    };} #[macro_export]macro_rules! crate_name {    () => {        $crate::private::extract_crate_name_from_module_path(module_path!())    };} /// functions that are used in macros, and therefore must be public,/// but should not be used directlypub mod private {    use super::*;     pub fn extract_crate_name_from_module_path(module_path: &'static str) -> &'static str {        return module_path            .split_once("::")            .map(|(crate_name, _)| crate_name)            .unwrap_or(module_path);    }     pub fn scope_new(scopes: &[&'static str]) -> Scope {        assert!(scopes.len() <= SCOPE_DEPTH_MAX);        let mut scope = [""; SCOPE_DEPTH_MAX];        scope[0..scopes.len()].copy_from_slice(scopes);        scope    }     pub fn scope_alloc_new(scopes: &[&str]) -> ScopeAlloc {        assert!(scopes.len() <= SCOPE_DEPTH_MAX);        let mut scope = [""; SCOPE_DEPTH_MAX];        scope[0..scopes.len()].copy_from_slice(scopes);        scope.map(|s| s.to_string())    }     pub fn scope_to_alloc(scope: &Scope) -> ScopeAlloc {        return scope.map(|s| s.to_string());    }} pub type Scope = [&'static str; SCOPE_DEPTH_MAX];pub type ScopeAlloc = [String; SCOPE_DEPTH_MAX];const SCOPE_STRING_SEP_STR: &'static str = ".";const SCOPE_STRING_SEP_CHAR: char = '.'; #[derive(Clone, Copy, Debug, PartialEq, Eq)]pub struct Logger {    pub scope: Scope,} pub struct Timer {    pub logger: Logger,    pub start_time: std::time::Instant,    pub name: &'static str,    pub warn_if_longer_than: Option<std::time::Duration>,    pub done: bool,} impl Drop for Timer {    fn drop(&mut self) {        self.finish();    }} impl Timer {    #[must_use = "Timer will stop when dropped, the result of this function should be saved in a variable prefixed with `_` if it should stop when dropped"]    pub fn new(logger: Logger, name: &'static str) -> Self {        return Self {            logger,            name,            start_time: std::time::Instant::now(),            warn_if_longer_than: None,            done: false,        };    }    pub fn warn_if_gt(mut self, warn_limit: std::time::Duration) -> Self {        self.warn_if_longer_than = Some(warn_limit);        return self;    }     pub fn end(mut self) {        self.finish();    }     fn finish(&mut self) {        if self.done {            return;        }        let elapsed = self.start_time.elapsed();        if let Some(warn_limit) = self.warn_if_longer_than {            if elapsed > warn_limit {                crate::warn!(                    self.logger =>                    "Timer '{}' took {:?}. Which was longer than the expected limit of {:?}",                    self.name,                    elapsed,                    warn_limit                );                self.done = true;                return;            }        }        crate::trace!(            self.logger =>            "Timer '{}' finished in {:?}",            self.name,            elapsed        );        self.done = true;    }} #[cfg(test)]mod tests {    use super::*;     #[test]    fn test_crate_name() {        assert_eq!(crate_name!(), "zlog");    }}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t