.. | ||
benches | ||
src | ||
.cargo-checksum.json | ||
Cargo.toml | ||
CHANGELOG.md | ||
LICENSE-APACHE | ||
LICENSE-MIT | ||
README.md | ||
triagebot.toml |
log
A Rust library providing a lightweight logging facade.
A logging facade provides a single logging API that abstracts over the actual logging implementation. Libraries can use the logging API provided by this crate, and the consumer of those libraries can choose the logging implementation that is most suitable for its use case.
Minimum supported rustc
1.60.0+
This version is explicitly tested in CI and may be bumped in any release as needed. Maintaining compatibility with older compilers is a priority though, so the bar for bumping the minimum supported version is set very high. Any changes to the supported minimum version will be called out in the release notes.
Usage
In libraries
Libraries should link only to the log
crate, and use the provided macros to
log whatever information will be useful to downstream consumers:
[dependencies]
log = "0.4"
use log::{info, trace, warn};
pub fn shave_the_yak(yak: &mut Yak) {
trace!("Commencing yak shaving");
loop {
match find_a_razor() {
Ok(razor) => {
info!("Razor located: {razor}");
yak.shave(razor);
break;
}
Err(err) => {
warn!("Unable to locate a razor: {err}, retrying");
}
}
}
}
In executables
In order to produce log output, executables have to use a logger implementation compatible with the facade. There are many available implementations to choose from, here are some options:
- Simple minimal loggers:
- Complex configurable frameworks:
- Adaptors for other facilities:
- For WebAssembly binaries:
- For dynamic libraries:
- You may need to construct an FFI-safe wrapper over
log
to initialize in your libraries.
- You may need to construct an FFI-safe wrapper over
- Utilities:
Executables should choose a logger implementation and initialize it early in the runtime of the program. Logger implementations will typically include a function to do this. Any log messages generated before the logger is initialized will be ignored.
The executable itself may use the log
crate to log as well.
Structured logging
If you enable the kv
feature, you can associate structured data with your log records:
use log::{info, trace, warn};
pub fn shave_the_yak(yak: &mut Yak) {
// `yak:serde` will capture `yak` using its `serde::Serialize` impl
//
// You could also use `:?` for `Debug`, or `:%` for `Display`. For a
// full list, see the `log` crate documentation
trace!(target = "yak_events", yak:serde; "Commencing yak shaving");
loop {
match find_a_razor() {
Ok(razor) => {
info!(razor; "Razor located");
yak.shave(razor);
break;
}
Err(e) => {
// `e:err` will capture `e` using its `std::error::Error` impl
warn!(e:err; "Unable to locate a razor, retrying");
}
}
}
}