From de2a06b19185ace3db56f83d5abae2a26e0412c1 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Sat, 12 Aug 2017 21:50:30 -0700 Subject: [PATCH 1/9] Shim 0.3.x into 0.4.x 0.3.x loggers turn into 0.4.x loggers, and all log records from 0.3.x and 0.4.x will route to the registered logger, whether it be an 0.3.x logger or 0.4.x logger. --- Cargo.toml | 29 +++++---- src/lib.rs | 181 ++++++++++++++++++++++++++++++++++------------------- 2 files changed, 134 insertions(+), 76 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 7f4645379..1adcfb8c4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -18,20 +18,23 @@ name = "filters" harness = false [features] -max_level_off = [] -max_level_error = [] -max_level_warn = [] -max_level_info = [] -max_level_debug = [] -max_level_trace = [] +max_level_off = ["log/max_level_off"] +max_level_error = ["log/max_level_error"] +max_level_warn = ["log/max_level_warn"] +max_level_info = ["log/max_level_info"] +max_level_debug = ["log/max_level_debug"] +max_level_trace = ["log/max_level_trace"] -release_max_level_off = [] -release_max_level_error = [] -release_max_level_warn = [] -release_max_level_info = [] -release_max_level_debug = [] -release_max_level_trace = [] +release_max_level_off = ["log/release_max_level_off"] +release_max_level_error = ["log/release_max_level_error"] +release_max_level_warn = ["log/release_max_level_warn"] +release_max_level_info = ["log/release_max_level_info"] +release_max_level_debug = ["log/release_max_level_debug"] +release_max_level_trace = ["log/release_max_level_trace"] nightly = [] -use_std = [] +use_std = ["log/use_std"] default = ["use_std"] + +[dependencies] +log = { git = "https://github.com/rust-lang-nursery/log", default_features = false } diff --git a/src/lib.rs b/src/lib.rs index 6c222baef..014cade20 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -199,6 +199,7 @@ #[cfg(not(feature = "use_std"))] extern crate core as std; +extern crate log; use std::cmp; #[cfg(feature = "use_std")] @@ -235,12 +236,9 @@ static mut LOGGER: *const Log = &NopLogger; static STATE: AtomicUsize = ATOMIC_USIZE_INIT; static REFCOUNT: AtomicUsize = ATOMIC_USIZE_INIT; -const UNINITIALIZED: usize = 0; const INITIALIZING: usize = 1; const INITIALIZED: usize = 2; -static MAX_LOG_LEVEL_FILTER: AtomicUsize = ATOMIC_USIZE_INIT; - static LOG_LEVEL_NAMES: [&'static str; 6] = ["OFF", "ERROR", "WARN", "INFO", "DEBUG", "TRACE"]; @@ -370,6 +368,26 @@ impl LogLevel { } } + fn from_new(level: log::Level) -> LogLevel { + match level { + log::Level::Error => LogLevel::Error, + log::Level::Warn => LogLevel::Warn, + log::Level::Info => LogLevel::Info, + log::Level::Debug => LogLevel::Debug, + log::Level::Trace => LogLevel::Trace, + } + } + + fn to_new(&self) -> log::Level { + match *self { + LogLevel::Error => log::Level::Error, + LogLevel::Warn => log::Level::Warn, + LogLevel::Info => log::Level::Info, + LogLevel::Debug => log::Level::Debug, + LogLevel::Trace => log::Level::Trace, + } + } + /// Returns the most verbose logging level. #[inline] pub fn max() -> LogLevel { @@ -475,6 +493,29 @@ impl LogLevelFilter { _ => None } } + + fn from_new(filter: log::LevelFilter) -> LogLevelFilter { + match filter { + log::LevelFilter::Off => LogLevelFilter::Off, + log::LevelFilter::Error => LogLevelFilter::Error, + log::LevelFilter::Warn => LogLevelFilter::Warn, + log::LevelFilter::Info => LogLevelFilter::Info, + log::LevelFilter::Debug => LogLevelFilter::Debug, + log::LevelFilter::Trace => LogLevelFilter::Trace, + } + } + + fn to_new(&self) -> log::LevelFilter { + match *self { + LogLevelFilter::Off => log::LevelFilter::Off, + LogLevelFilter::Error => log::LevelFilter::Error, + LogLevelFilter::Warn => log::LevelFilter::Warn, + LogLevelFilter::Info => log::LevelFilter::Info, + LogLevelFilter::Debug => log::LevelFilter::Debug, + LogLevelFilter::Trace => log::LevelFilter::Trace, + } + } + /// Returns the most verbose logging level filter. #[inline] pub fn max() -> LogLevelFilter { @@ -611,8 +652,7 @@ impl LogLocation { /// higher than the maximum log level filter will be ignored. A logger should /// make sure to keep the maximum log level filter in sync with its current /// configuration. -#[allow(missing_copy_implementations)] -pub struct MaxLogLevelFilter(()); +pub struct MaxLogLevelFilter(log::MaxLevelFilter); impl fmt::Debug for MaxLogLevelFilter { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { @@ -628,7 +668,7 @@ impl MaxLogLevelFilter { /// Sets the maximum log level. pub fn set(&self, level: LogLevelFilter) { - MAX_LOG_LEVEL_FILTER.store(level as usize, Ordering::SeqCst) + self.0.set(level.to_new()) } } @@ -639,7 +679,7 @@ impl MaxLogLevelFilter { /// log level is set by the `MaxLogLevel` token passed to loggers. #[inline(always)] pub fn max_log_level() -> LogLevelFilter { - unsafe { mem::transmute(MAX_LOG_LEVEL_FILTER.load(Ordering::Relaxed)) } + LogLevelFilter::from_new(log::max_level()) } /// Sets the global logger. @@ -687,14 +727,11 @@ pub fn set_logger(make_logger: M) -> Result<(), SetLoggerError> /// addition, `shutdown_logger` *must not* be called after this function. pub unsafe fn set_logger_raw(make_logger: M) -> Result<(), SetLoggerError> where M: FnOnce(MaxLogLevelFilter) -> *const Log { - if STATE.compare_and_swap(UNINITIALIZED, INITIALIZING, - Ordering::SeqCst) != UNINITIALIZED { - return Err(SetLoggerError(())); - } - - LOGGER = make_logger(MaxLogLevelFilter(())); - STATE.store(INITIALIZED, Ordering::SeqCst); - Ok(()) + log::set_logger_raw(|filter| { + LOGGER = make_logger(MaxLogLevelFilter(filter)); + STATE.store(INITIALIZED, Ordering::SeqCst); + &LoggerAdaptor + }).map_err(|_| SetLoggerError(())) } /// Shuts down the global logger. @@ -727,9 +764,6 @@ pub fn shutdown_logger() -> Result, ShutdownLoggerError> { /// success. At that point it is guaranteed that no other threads are /// concurrently accessing the logger object. pub fn shutdown_logger_raw() -> Result<*const Log, ShutdownLoggerError> { - // Set the global log level to stop other thread from logging - MAX_LOG_LEVEL_FILTER.store(0, Ordering::SeqCst); - // Set to INITIALIZING to prevent re-initialization after if STATE.compare_and_swap(INITIALIZED, INITIALIZING, Ordering::SeqCst) != INITIALIZED { @@ -848,16 +882,65 @@ fn logger() -> Option { } } +struct LoggerAdaptor; + +impl log::Log for LoggerAdaptor { + fn log(&self, record: &log::Record) { + let (file, module_path) = unsafe { + if log::__SUPER_SECRET_STRINGS_ARE_STATIC { + ( + &*(record.file() as *const str), + &*(record.module_path() as *const str), + ) + } else { + ("", "") + } + }; + if let Some(logger) = logger() { + let record = LogRecord { + metadata: LogMetadata { + level: LogLevel::from_new(record.level()), + target: record.target(), + }, + location: &LogLocation { + __file: file, + __line: record.line(), + __module_path: module_path, + }, + args: *record.args(), + }; + logger.log(&record); + } + } + + fn enabled(&self, metadata: &log::Metadata) -> bool { + match logger() { + Some(logger) => { + let metadata = LogMetadata { + level: LogLevel::from_new(metadata.level()), + target: metadata.target(), + }; + logger.enabled(&metadata) + } + None => false + } + } + + fn flush(&self) {} +} + // WARNING // This is not considered part of the crate's public API. It is subject to // change at any time. #[doc(hidden)] pub fn __enabled(level: LogLevel, target: &str) -> bool { - if let Some(logger) = logger() { - logger.enabled(&LogMetadata { level: level, target: target }) - } else { - false - } + log::Log::enabled( + log::logger(), + &log::Metadata::builder() + .level(level.to_new()) + .target(target) + .build() + ) } // WARNING @@ -866,17 +949,17 @@ pub fn __enabled(level: LogLevel, target: &str) -> bool { #[doc(hidden)] pub fn __log(level: LogLevel, target: &str, loc: &LogLocation, args: fmt::Arguments) { - if let Some(logger) = logger() { - let record = LogRecord { - metadata: LogMetadata { - level: level, - target: target, - }, - location: loc, - args: args - }; - logger.log(&record) - } + log::Log::log( + log::logger(), + &log::Record::builder() + .level(level.to_new()) + .target(target) + .file(loc.__file) + .line(loc.__line) + .module_path(loc.__module_path) + .args(args) + .build() + ) } // WARNING @@ -885,35 +968,7 @@ pub fn __log(level: LogLevel, target: &str, loc: &LogLocation, #[inline(always)] #[doc(hidden)] pub fn __static_max_level() -> LogLevelFilter { - if !cfg!(debug_assertions) { - // This is a release build. Check `release_max_level_*` first. - if cfg!(feature = "release_max_level_off") { - return LogLevelFilter::Off - } else if cfg!(feature = "release_max_level_error") { - return LogLevelFilter::Error - } else if cfg!(feature = "release_max_level_warn") { - return LogLevelFilter::Warn - } else if cfg!(feature = "release_max_level_info") { - return LogLevelFilter::Info - } else if cfg!(feature = "release_max_level_debug") { - return LogLevelFilter::Debug - } else if cfg!(feature = "release_max_level_trace") { - return LogLevelFilter::Trace - } - } - if cfg!(feature = "max_level_off") { - LogLevelFilter::Off - } else if cfg!(feature = "max_level_error") { - LogLevelFilter::Error - } else if cfg!(feature = "max_level_warn") { - LogLevelFilter::Warn - } else if cfg!(feature = "max_level_info") { - LogLevelFilter::Info - } else if cfg!(feature = "max_level_debug") { - LogLevelFilter::Debug - } else { - LogLevelFilter::Trace - } + LogLevelFilter::from_new(log::STATIC_MAX_LEVEL) } #[cfg(test)] From bcf03183445929011094d8cbd82889a79bd1f375 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Mon, 14 Aug 2017 20:57:11 -0700 Subject: [PATCH 2/9] Get tests working Split integration tests out to a separate crate, and disable doctests :( Since we depend on a library with the same name as us, tests get two copies of log linked in which fails to compile. --- .travis.yml | 1 + Cargo.toml | 5 ++--- log-test/Cargo.toml | 11 +++++++++++ log-test/src/lib.rs | 6 ++++++ {tests => log-test/tests}/filters.rs | 0 5 files changed, 20 insertions(+), 3 deletions(-) create mode 100644 log-test/Cargo.toml create mode 100644 log-test/src/lib.rs rename {tests => log-test/tests}/filters.rs (100%) diff --git a/.travis.yml b/.travis.yml index 1b82ecd3a..479981582 100644 --- a/.travis.yml +++ b/.travis.yml @@ -12,6 +12,7 @@ script: - ([ $TRAVIS_RUST_VERSION != nightly ] || cargo build --verbose --features nightly) - cargo test --verbose - ([ $TRAVIS_RUST_VERSION != nightly ] || cargo test --verbose --no-default-features) + - cargo test --verbose --manifest-path log-test/Cargo.toml - cargo test --verbose --manifest-path env/Cargo.toml - cargo test --verbose --manifest-path env/Cargo.toml --no-default-features - cargo run --verbose --manifest-path tests/max_level_features/Cargo.toml diff --git a/Cargo.toml b/Cargo.toml index 1adcfb8c4..2dfeab604 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,9 +13,8 @@ A lightweight logging facade for Rust """ categories = ["development-tools::debugging"] -[[test]] -name = "filters" -harness = false +[lib] +doctest = false [features] max_level_off = ["log/max_level_off"] diff --git a/log-test/Cargo.toml b/log-test/Cargo.toml new file mode 100644 index 000000000..82eaf1add --- /dev/null +++ b/log-test/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "log-test" +version = "0.1.0" +authors = ["Steven Fackler "] + +[dependencies] +log = { path = ".." } + +[[test]] +name = "filters" +harness = false diff --git a/log-test/src/lib.rs b/log-test/src/lib.rs new file mode 100644 index 000000000..cdfbe1aa5 --- /dev/null +++ b/log-test/src/lib.rs @@ -0,0 +1,6 @@ +#[cfg(test)] +mod tests { + #[test] + fn it_works() { + } +} diff --git a/tests/filters.rs b/log-test/tests/filters.rs similarity index 100% rename from tests/filters.rs rename to log-test/tests/filters.rs From e2e1904eae6dfcc6b83f3bcf88bdafac58696b52 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Mon, 25 Sep 2017 20:58:46 -0700 Subject: [PATCH 3/9] Update shim for 0.4 changes --- src/lib.rs | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 014cade20..1fe8f5150 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -727,7 +727,7 @@ pub fn set_logger(make_logger: M) -> Result<(), SetLoggerError> /// addition, `shutdown_logger` *must not* be called after this function. pub unsafe fn set_logger_raw(make_logger: M) -> Result<(), SetLoggerError> where M: FnOnce(MaxLogLevelFilter) -> *const Log { - log::set_logger_raw(|filter| { + log::try_set_logger_raw(|filter| { LOGGER = make_logger(MaxLogLevelFilter(filter)); STATE.store(INITIALIZED, Ordering::SeqCst); &LoggerAdaptor @@ -886,26 +886,17 @@ struct LoggerAdaptor; impl log::Log for LoggerAdaptor { fn log(&self, record: &log::Record) { - let (file, module_path) = unsafe { - if log::__SUPER_SECRET_STRINGS_ARE_STATIC { - ( - &*(record.file() as *const str), - &*(record.module_path() as *const str), - ) - } else { - ("", "") - } - }; if let Some(logger) = logger() { let record = LogRecord { metadata: LogMetadata { level: LogLevel::from_new(record.level()), target: record.target(), }, + // file and module path aren't static in 0.4 so we can't forward them. location: &LogLocation { - __file: file, + __file: "", __line: record.line(), - __module_path: module_path, + __module_path: "", }, args: *record.args(), }; From 09e80362e283747b198f5006d672582cbcae10bf Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Thu, 5 Oct 2017 20:06:32 -0700 Subject: [PATCH 4/9] Update for upstream changes --- src/lib.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 1fe8f5150..aa805f49d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -727,10 +727,11 @@ pub fn set_logger(make_logger: M) -> Result<(), SetLoggerError> /// addition, `shutdown_logger` *must not* be called after this function. pub unsafe fn set_logger_raw(make_logger: M) -> Result<(), SetLoggerError> where M: FnOnce(MaxLogLevelFilter) -> *const Log { - log::try_set_logger_raw(|filter| { + log::set_logger(|filter| { + static ADAPTOR: LoggerAdaptor = LoggerAdaptor; LOGGER = make_logger(MaxLogLevelFilter(filter)); STATE.store(INITIALIZED, Ordering::SeqCst); - &LoggerAdaptor + &ADAPTOR }).map_err(|_| SetLoggerError(())) } From 347c4d28259ef3ff6ff3b3033b8667760af09802 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Sat, 7 Oct 2017 15:02:22 -0700 Subject: [PATCH 5/9] Directly perform 0.3 -> 0.3 logging We otherwise loose the file and module info which is no good. --- src/lib.rs | 62 ++++++++++++++++++++++++++++++++++++++---------------- 1 file changed, 44 insertions(+), 18 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index aa805f49d..ae392a321 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -926,13 +926,24 @@ impl log::Log for LoggerAdaptor { // change at any time. #[doc(hidden)] pub fn __enabled(level: LogLevel, target: &str) -> bool { - log::Log::enabled( - log::logger(), - &log::Metadata::builder() - .level(level.to_new()) - .target(target) - .build() - ) + match logger() { + Some(logger) => { + let metadata = LogMetadata { + level: level, + target: target, + }; + logger.enabled(&metadata) + } + None => { + log::Log::enabled( + log::logger(), + &log::Metadata::builder() + .level(level.to_new()) + .target(target) + .build() + ) + } + } } // WARNING @@ -941,17 +952,32 @@ pub fn __enabled(level: LogLevel, target: &str) -> bool { #[doc(hidden)] pub fn __log(level: LogLevel, target: &str, loc: &LogLocation, args: fmt::Arguments) { - log::Log::log( - log::logger(), - &log::Record::builder() - .level(level.to_new()) - .target(target) - .file(loc.__file) - .line(loc.__line) - .module_path(loc.__module_path) - .args(args) - .build() - ) + match logger() { + Some(logger) => { + let record = LogRecord { + metadata: LogMetadata { + level: level, + target: target, + }, + location: loc, + args: args, + }; + logger.log(&record); + } + None => { + log::Log::log( + log::logger(), + &log::Record::builder() + .level(level.to_new()) + .target(target) + .file(loc.__file) + .line(loc.__line) + .module_path(loc.__module_path) + .args(args) + .build() + ) + } + } } // WARNING From 23012a96ed2d11967be7238999941c7899039f1a Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Thu, 12 Oct 2017 22:09:27 -0700 Subject: [PATCH 6/9] Fix feature --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 2dfeab604..2f89a8b3d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -32,7 +32,7 @@ release_max_level_debug = ["log/release_max_level_debug"] release_max_level_trace = ["log/release_max_level_trace"] nightly = [] -use_std = ["log/use_std"] +use_std = ["log/std"] default = ["use_std"] [dependencies] From c21bdff35f60e2112249eb9e782ec87a8138ff87 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Tue, 5 Dec 2017 22:28:07 -0800 Subject: [PATCH 7/9] Update 0.3.x for 0.4.x changes --- src/lib.rs | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index ae392a321..1abdf3157 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -652,7 +652,7 @@ impl LogLocation { /// higher than the maximum log level filter will be ignored. A logger should /// make sure to keep the maximum log level filter in sync with its current /// configuration. -pub struct MaxLogLevelFilter(log::MaxLevelFilter); +pub struct MaxLogLevelFilter(()); impl fmt::Debug for MaxLogLevelFilter { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { @@ -668,7 +668,7 @@ impl MaxLogLevelFilter { /// Sets the maximum log level. pub fn set(&self, level: LogLevelFilter) { - self.0.set(level.to_new()) + log::set_max_level(level.to_new()) } } @@ -727,12 +727,15 @@ pub fn set_logger(make_logger: M) -> Result<(), SetLoggerError> /// addition, `shutdown_logger` *must not* be called after this function. pub unsafe fn set_logger_raw(make_logger: M) -> Result<(), SetLoggerError> where M: FnOnce(MaxLogLevelFilter) -> *const Log { - log::set_logger(|filter| { - static ADAPTOR: LoggerAdaptor = LoggerAdaptor; - LOGGER = make_logger(MaxLogLevelFilter(filter)); - STATE.store(INITIALIZED, Ordering::SeqCst); - &ADAPTOR - }).map_err(|_| SetLoggerError(())) + static ADAPTOR: LoggerAdaptor = LoggerAdaptor; + match log::set_logger(&ADAPTOR) { + Ok(()) => { + LOGGER = make_logger(MaxLogLevelFilter(())); + STATE.store(INITIALIZED, Ordering::SeqCst); + Ok(()) + } + Err(_) => Err(SetLoggerError(())), + } } /// Shuts down the global logger. @@ -896,7 +899,7 @@ impl log::Log for LoggerAdaptor { // file and module path aren't static in 0.4 so we can't forward them. location: &LogLocation { __file: "", - __line: record.line(), + __line: record.line().unwrap_or(0), __module_path: "", }, args: *record.args(), @@ -970,9 +973,9 @@ pub fn __log(level: LogLevel, target: &str, loc: &LogLocation, &log::Record::builder() .level(level.to_new()) .target(target) - .file(loc.__file) - .line(loc.__line) - .module_path(loc.__module_path) + .file(Some(loc.__file)) + .line(Some(loc.__line)) + .module_path(Some(loc.__module_path)) .args(args) .build() ) From 13203e48086745e7512b5064e06dc54709932327 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Tue, 5 Dec 2017 23:06:32 -0800 Subject: [PATCH 8/9] Use the release candidate --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 2f89a8b3d..2030bdef7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -36,4 +36,4 @@ use_std = ["log/std"] default = ["use_std"] [dependencies] -log = { git = "https://github.com/rust-lang-nursery/log", default_features = false } +log = "0.4.0-rc.1" From c9463807805c6d3b48a82bdb627b8e1e329546dc Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Sun, 24 Dec 2017 14:50:18 -0700 Subject: [PATCH 9/9] Use log 0.4 --- Cargo.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 2030bdef7..77691be50 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "log" -version = "0.3.7" +version = "0.3.9" authors = ["The Rust Project Developers"] license = "MIT/Apache-2.0" readme = "README.md" @@ -36,4 +36,4 @@ use_std = ["log/std"] default = ["use_std"] [dependencies] -log = "0.4.0-rc.1" +log = "0.4"