diff options
Diffstat (limited to 'vendor/tracing-log/src')
| -rw-r--r-- | vendor/tracing-log/src/env_logger.rs | 49 | ||||
| -rw-r--r-- | vendor/tracing-log/src/interest_cache.rs | 16 | ||||
| -rw-r--r-- | vendor/tracing-log/src/lib.rs | 66 | ||||
| -rw-r--r-- | vendor/tracing-log/src/trace_logger.rs | 458 |
4 files changed, 25 insertions, 564 deletions
diff --git a/vendor/tracing-log/src/env_logger.rs b/vendor/tracing-log/src/env_logger.rs deleted file mode 100644 index 74922d1dc..000000000 --- a/vendor/tracing-log/src/env_logger.rs +++ /dev/null @@ -1,49 +0,0 @@ -//! Utilities for configuring the `env_logger` crate to emit `tracing` events. - -/// Extension trait to configure an `env_logger::Builder` to emit traces. -pub trait BuilderExt: crate::sealed::Sealed { - /// Configure the built `env_logger::Logger` to emit `tracing` events for - /// all consumed `log` records, rather than printing them to standard out. - /// - /// Note that this replaces any previously configured formatting. - fn emit_traces(&mut self) -> &mut Self; -} - -impl crate::sealed::Sealed for env_logger::Builder {} - -impl BuilderExt for env_logger::Builder { - fn emit_traces(&mut self) -> &mut Self { - self.format(|_, record| super::format_trace(record)) - } -} - -/// Attempts to initialize the global logger with an env logger configured to -/// emit `tracing` events. -/// -/// This should be called early in the execution of a Rust program. Any log -/// events that occur before initialization will be ignored. -/// -/// # Errors -/// -/// This function will fail if it is called more than once, or if another -/// library has already initialized a global logger. -pub fn try_init() -> Result<(), log::SetLoggerError> { - env_logger::Builder::from_default_env() - .emit_traces() - .try_init() -} - -/// Initializes the global logger with an env logger configured to -/// emit `tracing` events. -/// -/// This should be called early in the execution of a Rust program. Any log -/// events that occur before initialization will be ignored. -/// -/// # Panics -/// -/// This function will panic if it is called more than once, or if another -/// library has already initialized a global logger. -pub fn init() { - try_init() - .expect("tracing_log::env_logger::init should not be called after logger initialized"); -} diff --git a/vendor/tracing-log/src/interest_cache.rs b/vendor/tracing-log/src/interest_cache.rs index fb3da875e..aabf9ebaf 100644 --- a/vendor/tracing-log/src/interest_cache.rs +++ b/vendor/tracing-log/src/interest_cache.rs @@ -1,6 +1,7 @@ use ahash::AHasher; use log::{Level, Metadata}; use lru::LruCache; +use once_cell::sync::Lazy; use std::cell::RefCell; use std::hash::Hasher; use std::sync::atomic::{AtomicUsize, Ordering}; @@ -140,12 +141,10 @@ static SENTINEL_METADATA: tracing_core::Metadata<'static> = tracing_core::Metada tracing_core::metadata::Kind::EVENT, ); -lazy_static::lazy_static! { - static ref CONFIG: Mutex<InterestCacheConfig> = { - tracing_core::callsite::register(&SENTINEL_CALLSITE); - Mutex::new(InterestCacheConfig::disabled()) - }; -} +static CONFIG: Lazy<Mutex<InterestCacheConfig>> = Lazy::new(|| { + tracing_core::callsite::register(&SENTINEL_CALLSITE); + Mutex::new(InterestCacheConfig::disabled()) +}); thread_local! { static STATE: RefCell<State> = { @@ -236,10 +235,7 @@ mod tests { fn lock_for_test() -> impl Drop { // We need to make sure only one test runs at a time. - - lazy_static::lazy_static! { - static ref LOCK: Mutex<()> = Mutex::new(()); - } + static LOCK: Lazy<Mutex<()>> = Lazy::new(Mutex::new); match LOCK.lock() { Ok(guard) => guard, diff --git a/vendor/tracing-log/src/lib.rs b/vendor/tracing-log/src/lib.rs index 09e9114a4..bb162d9e1 100644 --- a/vendor/tracing-log/src/lib.rs +++ b/vendor/tracing-log/src/lib.rs @@ -13,10 +13,8 @@ //! - [`AsTrace`] and [`AsLog`] traits for converting between `tracing` and `log` types. //! - [`LogTracer`], a [`log::Log`] implementation that consumes [`log::Record`]s //! and outputs them as [`tracing::Event`]. -//! - An [`env_logger`] module, with helpers for using the [`env_logger` crate] -//! with `tracing` (optional, enabled by the `env-logger` feature). //! -//! *Compiler support: [requires `rustc` 1.49+][msrv]* +//! *Compiler support: [requires `rustc` 1.56+][msrv]* //! //! [msrv]: #supported-rust-versions //! @@ -57,50 +55,45 @@ //! //! ## Caution: Mixing both conversions //! -//! Note that logger implementations that convert log records to trace events +//! Note that `log::Logger` implementations that convert log records to trace events //! should not be used with `Subscriber`s that convert trace events _back_ into -//! log records (such as the `TraceLogger`), as doing so will result in the -//! event recursing between the subscriber and the logger forever (or, in real -//! life, probably overflowing the call stack). +//! `log` records, as doing so will result in the event recursing between the subscriber +//! and the logger forever (or, in real life, probably overflowing the call stack). //! //! If the logging of trace events generated from log records produced by the //! `log` crate is desired, either the `log` crate should not be used to //! implement this logging, or an additional layer of filtering will be //! required to avoid infinitely converting between `Event` and `log::Record`. //! -//! # Feature Flags -//! * `trace-logger`: enables an experimental `log` subscriber, deprecated since -//! version 0.1.1. +//! ## Feature Flags +//! +//! * `std`: enables features that require the Rust standard library (on by default) //! * `log-tracer`: enables the `LogTracer` type (on by default) -//! * `env_logger`: enables the `env_logger` module, with helpers for working -//! with the [`env_logger` crate]. //! * `interest-cache`: makes it possible to configure an interest cache for //! logs emitted through the `log` crate (see [`Builder::with_interest_cache`]); requires `std` //! //! ## Supported Rust Versions //! //! Tracing is built against the latest stable release. The minimum supported -//! version is 1.49. The current Tracing version is not guaranteed to build on +//! version is 1.56. The current Tracing version is not guaranteed to build on //! Rust versions earlier than the minimum supported version. //! //! Tracing follows the same compiler support policies as the rest of the Tokio //! project. The current stable Rust compiler and the three most recent minor //! versions before it will always be supported. For example, if the current -//! stable compiler version is 1.45, the minimum supported version will not be -//! increased past 1.42, three minor versions prior. Increasing the minimum +//! stable compiler version is 1.69, the minimum supported version will not be +//! increased past 1.66, three minor versions prior. Increasing the minimum //! supported compiler version is not considered a semver breaking change as //! long as doing so complies with this policy. //! //! [`init`]: LogTracer::init //! [`init_with_filter`]: LogTracer::init_with_filter //! [`tracing`]: https://crates.io/crates/tracing -//! [`env_logger` crate]: https://crates.io/crates/env-logger //! [`tracing::Subscriber`]: https://docs.rs/tracing/latest/tracing/trait.Subscriber.html //! [`Subscriber`]: https://docs.rs/tracing/latest/tracing/trait.Subscriber.html //! [`tracing::Event`]: https://docs.rs/tracing/latest/tracing/struct.Event.html //! [flags]: https://docs.rs/tracing/latest/tracing/#crate-feature-flags //! [`Builder::with_interest_cache`]: log_tracer::Builder::with_interest_cache -#![doc(html_root_url = "https://docs.rs/tracing-log/0.1.3")] #![doc( html_logo_url = "https://raw.githubusercontent.com/tokio-rs/tracing/master/assets/logo-type.png", issue_tracker_base_url = "https://github.com/tokio-rs/tracing/issues/" @@ -112,7 +105,6 @@ rust_2018_idioms, unreachable_pub, bad_style, - const_err, dead_code, improper_ctypes, non_shorthand_field_patterns, @@ -128,7 +120,7 @@ unused_parens, while_true )] -use lazy_static::lazy_static; +use once_cell::sync::Lazy; use std::{fmt, io}; @@ -145,29 +137,11 @@ use tracing_core::{ #[cfg_attr(docsrs, doc(cfg(feature = "log-tracer")))] pub mod log_tracer; -#[cfg(feature = "trace-logger")] -#[cfg_attr(docsrs, doc(cfg(feature = "trace-logger")))] -pub mod trace_logger; - #[cfg(feature = "log-tracer")] #[cfg_attr(docsrs, doc(cfg(feature = "log-tracer")))] #[doc(inline)] pub use self::log_tracer::LogTracer; -#[cfg(feature = "trace-logger")] -#[cfg_attr(docsrs, doc(cfg(feature = "trace-logger")))] -#[deprecated( - since = "0.1.1", - note = "use the `tracing` crate's \"log\" feature flag instead" -)] -#[allow(deprecated)] -#[doc(inline)] -pub use self::trace_logger::TraceLogger; - -#[cfg(feature = "env_logger")] -#[cfg_attr(docsrs, doc(cfg(feature = "env_logger")))] -pub mod env_logger; - pub use log; #[cfg(all(feature = "interest-cache", feature = "log-tracer", feature = "std"))] @@ -309,9 +283,9 @@ macro_rules! log_cs { "log event", "log", $level, - None, - None, - None, + ::core::option::Option::None, + ::core::option::Option::None, + ::core::option::Option::None, field::FieldSet::new(FIELD_NAMES, identify_callsite!(&$cs)), Kind::EVENT, ); @@ -346,13 +320,11 @@ log_cs!( ErrorCallsite ); -lazy_static! { - static ref TRACE_FIELDS: Fields = Fields::new(&TRACE_CS); - static ref DEBUG_FIELDS: Fields = Fields::new(&DEBUG_CS); - static ref INFO_FIELDS: Fields = Fields::new(&INFO_CS); - static ref WARN_FIELDS: Fields = Fields::new(&WARN_CS); - static ref ERROR_FIELDS: Fields = Fields::new(&ERROR_CS); -} +static TRACE_FIELDS: Lazy<Fields> = Lazy::new(|| Fields::new(&TRACE_CS)); +static DEBUG_FIELDS: Lazy<Fields> = Lazy::new(|| Fields::new(&DEBUG_CS)); +static INFO_FIELDS: Lazy<Fields> = Lazy::new(|| Fields::new(&INFO_CS)); +static WARN_FIELDS: Lazy<Fields> = Lazy::new(|| Fields::new(&WARN_CS)); +static ERROR_FIELDS: Lazy<Fields> = Lazy::new(|| Fields::new(&ERROR_CS)); fn level_to_cs(level: Level) -> (&'static dyn Callsite, &'static Fields) { match level { diff --git a/vendor/tracing-log/src/trace_logger.rs b/vendor/tracing-log/src/trace_logger.rs deleted file mode 100644 index 88a52f752..000000000 --- a/vendor/tracing-log/src/trace_logger.rs +++ /dev/null @@ -1,458 +0,0 @@ -//! A `tracing` [`Subscriber`] that uses the [`log`] crate as a backend for -//! formatting `tracing` spans and events. -//! -//! When a [`TraceLogger`] is set as the current subscriber, it will record -//! traces by emitting [`log::Record`]s that can be collected by a logger. -//! -//! **Note**: This API has been deprecated since version 0.1.1. In order to emit -//! `tracing` events as `log` records, the ["log" and "log-always" feature -//! flags][flags] on the `tracing` crate should be used instead. -//! -//! [`log`]: log -//! [`Subscriber`]: https://docs.rs/tracing/0.1.7/tracing/subscriber/trait.Subscriber.html -//! [`log::Record`]:log::Record -//! [flags]: https://docs.rs/tracing/latest/tracing/#crate-feature-flags -#![deprecated( - since = "0.1.1", - note = "use the `tracing` crate's \"log\" feature flag instead" -)] -use crate::AsLog; -use std::{ - cell::RefCell, - collections::HashMap, - fmt::{self, Write}, - sync::{ - atomic::{AtomicUsize, Ordering}, - Mutex, - }, -}; -use tracing_core::{ - field, - span::{self, Id}, - Event, Metadata, Subscriber, -}; - -/// A `tracing` [`Subscriber`] implementation that logs all recorded -/// trace events. -/// -/// **Note**: This API has been deprecated since version 0.1.1. In order to emit -/// `tracing` events as `log` records, the ["log" and "log-always" feature -/// flags][flags] on the `tracing` crate should be used instead. -/// -/// [`Subscriber`]: https://docs.rs/tracing/0.1.7/tracing/subscriber/trait.Subscriber.html -/// [flags]: https://docs.rs/tracing/latest/tracing/#crate-feature-flags -pub struct TraceLogger { - settings: Builder, - spans: Mutex<HashMap<Id, SpanLineBuilder>>, - next_id: AtomicUsize, -} - -thread_local! { - static CURRENT: RefCell<Vec<Id>> = RefCell::new(Vec::new()); -} -/// Configures and constructs a [`TraceLogger`]. -/// -#[derive(Debug)] -pub struct Builder { - log_span_closes: bool, - log_enters: bool, - log_exits: bool, - log_ids: bool, - parent_fields: bool, - log_parent: bool, -} - -// ===== impl TraceLogger ===== - -impl TraceLogger { - /// Returns a new `TraceLogger` with the default configuration. - pub fn new() -> Self { - Self::builder().finish() - } - - /// Returns a `Builder` for configuring a `TraceLogger`. - pub fn builder() -> Builder { - Default::default() - } - - fn from_builder(settings: Builder) -> Self { - Self { - settings, - ..Default::default() - } - } - - fn next_id(&self) -> Id { - Id::from_u64(self.next_id.fetch_add(1, Ordering::SeqCst) as u64) - } -} - -// ===== impl Builder ===== - -impl Builder { - /// Configures whether or not the [`TraceLogger`] being constructed will log - /// when a span closes. - /// - pub fn with_span_closes(self, log_span_closes: bool) -> Self { - Self { - log_span_closes, - ..self - } - } - - /// Configures whether or not the [`TraceLogger`] being constructed will - /// include the fields of parent spans when formatting events. - /// - pub fn with_parent_fields(self, parent_fields: bool) -> Self { - Self { - parent_fields, - ..self - } - } - - /// Configures whether or not the [`TraceLogger`] being constructed will log - /// when a span is entered. - /// - /// If this is set to false, fields from the current span will still be - /// recorded as context, but the actual entry will not create a log record. - /// - pub fn with_span_entry(self, log_enters: bool) -> Self { - Self { log_enters, ..self } - } - - /// Configures whether or not the [`TraceLogger`] being constructed will log - /// when a span is exited. - /// - pub fn with_span_exits(self, log_exits: bool) -> Self { - Self { log_exits, ..self } - } - - /// Configures whether or not the [`TraceLogger`] being constructed will - /// include span IDs when formatting log output. - /// - pub fn with_ids(self, log_ids: bool) -> Self { - Self { log_ids, ..self } - } - - /// Configures whether or not the [`TraceLogger`] being constructed will - /// include the names of parent spans as context when formatting events. - /// - pub fn with_parent_names(self, log_parent: bool) -> Self { - Self { log_parent, ..self } - } - - /// Complete the builder, returning a configured [`TraceLogger`]. - /// - pub fn finish(self) -> TraceLogger { - TraceLogger::from_builder(self) - } -} - -impl Default for Builder { - fn default() -> Self { - Builder { - log_span_closes: false, - parent_fields: true, - log_exits: false, - log_ids: false, - log_parent: true, - log_enters: false, - } - } -} - -impl Default for TraceLogger { - fn default() -> Self { - TraceLogger { - settings: Default::default(), - spans: Default::default(), - next_id: AtomicUsize::new(1), - } - } -} - -#[derive(Debug)] -struct SpanLineBuilder { - parent: Option<Id>, - ref_count: usize, - fields: String, - file: Option<String>, - line: Option<u32>, - module_path: Option<String>, - target: String, - level: log::Level, - name: &'static str, -} - -impl SpanLineBuilder { - fn new(parent: Option<Id>, meta: &Metadata<'_>, fields: String) -> Self { - Self { - parent, - ref_count: 1, - fields, - file: meta.file().map(String::from), - line: meta.line(), - module_path: meta.module_path().map(String::from), - target: String::from(meta.target()), - level: meta.level().as_log(), - name: meta.name(), - } - } - - fn log_meta(&self) -> log::Metadata<'_> { - log::MetadataBuilder::new() - .level(self.level) - .target(self.target.as_ref()) - .build() - } - - fn finish(self) { - let log_meta = self.log_meta(); - let logger = log::logger(); - if logger.enabled(&log_meta) { - logger.log( - &log::Record::builder() - .metadata(log_meta) - .target(self.target.as_ref()) - .module_path(self.module_path.as_ref().map(String::as_ref)) - .file(self.file.as_ref().map(String::as_ref)) - .line(self.line) - .args(format_args!("close {}; {}", self.name, self.fields)) - .build(), - ); - } - } -} - -impl field::Visit for SpanLineBuilder { - fn record_debug(&mut self, field: &field::Field, value: &dyn fmt::Debug) { - write!(self.fields, " {}={:?};", field.name(), value) - .expect("write to string should never fail") - } -} - -impl Subscriber for TraceLogger { - fn enabled(&self, metadata: &Metadata<'_>) -> bool { - log::logger().enabled(&metadata.as_log()) - } - - fn new_span(&self, attrs: &span::Attributes<'_>) -> Id { - let id = self.next_id(); - let mut spans = self.spans.lock().unwrap(); - let mut fields = String::new(); - let parent = self.current_id(); - if self.settings.parent_fields { - let mut next_parent = parent.as_ref(); - while let Some(parent) = next_parent.and_then(|p| spans.get(p)) { - write!(&mut fields, "{}", parent.fields).expect("write to string cannot fail"); - next_parent = parent.parent.as_ref(); - } - } - let mut span = SpanLineBuilder::new(parent, attrs.metadata(), fields); - attrs.record(&mut span); - spans.insert(id.clone(), span); - id - } - - fn record(&self, span: &Id, values: &span::Record<'_>) { - let mut spans = self.spans.lock().unwrap(); - if let Some(span) = spans.get_mut(span) { - values.record(span); - } - } - - fn record_follows_from(&self, span: &Id, follows: &Id) { - // TODO: this should eventually track the relationship? - log::logger().log( - &log::Record::builder() - .level(log::Level::Trace) - .args(format_args!("span {:?} follows_from={:?};", span, follows)) - .build(), - ); - } - - fn enter(&self, id: &Id) { - let _ = CURRENT.try_with(|current| { - let mut current = current.borrow_mut(); - if current.contains(id) { - // Ignore duplicate enters. - return; - } - current.push(id.clone()); - }); - let spans = self.spans.lock().unwrap(); - if self.settings.log_enters { - if let Some(span) = spans.get(id) { - let log_meta = span.log_meta(); - let logger = log::logger(); - if logger.enabled(&log_meta) { - let current_id = self.current_id(); - let current_fields = current_id - .as_ref() - .and_then(|id| spans.get(id)) - .map(|span| span.fields.as_ref()) - .unwrap_or(""); - if self.settings.log_ids { - logger.log( - &log::Record::builder() - .metadata(log_meta) - .target(span.target.as_ref()) - .module_path(span.module_path.as_ref().map(String::as_ref)) - .file(span.file.as_ref().map(String::as_ref)) - .line(span.line) - .args(format_args!( - "enter {}; in={:?}; {}", - span.name, current_id, current_fields - )) - .build(), - ); - } else { - logger.log( - &log::Record::builder() - .metadata(log_meta) - .target(span.target.as_ref()) - .module_path(span.module_path.as_ref().map(String::as_ref)) - .file(span.file.as_ref().map(String::as_ref)) - .line(span.line) - .args(format_args!("enter {}; {}", span.name, current_fields)) - .build(), - ); - } - } - } - } - } - - fn exit(&self, id: &Id) { - let _ = CURRENT.try_with(|current| { - let mut current = current.borrow_mut(); - if current.last() == Some(id) { - current.pop() - } else { - None - } - }); - if self.settings.log_exits { - let spans = self.spans.lock().unwrap(); - if let Some(span) = spans.get(id) { - let log_meta = span.log_meta(); - let logger = log::logger(); - if logger.enabled(&log_meta) { - logger.log( - &log::Record::builder() - .metadata(log_meta) - .target(span.target.as_ref()) - .module_path(span.module_path.as_ref().map(String::as_ref)) - .file(span.file.as_ref().map(String::as_ref)) - .line(span.line) - .args(format_args!("exit {}", span.name)) - .build(), - ); - } - } - } - } - - fn event(&self, event: &Event<'_>) { - let meta = event.metadata(); - let log_meta = meta.as_log(); - let logger = log::logger(); - if logger.enabled(&log_meta) { - let spans = self.spans.lock().unwrap(); - let current = self.current_id().and_then(|id| spans.get(&id)); - let (current_fields, parent) = current - .map(|span| { - let fields = span.fields.as_ref(); - let parent = if self.settings.log_parent { - Some(span.name) - } else { - None - }; - (fields, parent) - }) - .unwrap_or(("", None)); - logger.log( - &log::Record::builder() - .metadata(log_meta) - .target(meta.target()) - .module_path(meta.module_path().as_ref().cloned()) - .file(meta.file().as_ref().cloned()) - .line(meta.line()) - .args(format_args!( - "{}{}{}{}", - parent.unwrap_or(""), - if parent.is_some() { ": " } else { "" }, - LogEvent(event), - current_fields, - )) - .build(), - ); - } - } - - fn clone_span(&self, id: &Id) -> Id { - let mut spans = self.spans.lock().unwrap(); - if let Some(span) = spans.get_mut(id) { - span.ref_count += 1; - } - id.clone() - } - - fn try_close(&self, id: Id) -> bool { - let mut spans = self.spans.lock().unwrap(); - if spans.contains_key(&id) { - if spans.get(&id).unwrap().ref_count == 1 { - let span = spans.remove(&id).unwrap(); - if self.settings.log_span_closes { - span.finish(); - } - return true; - } else { - spans.get_mut(&id).unwrap().ref_count -= 1; - } - } - false - } -} - -impl TraceLogger { - #[inline] - fn current_id(&self) -> Option<Id> { - CURRENT - .try_with(|current| current.borrow().last().map(|span| self.clone_span(span))) - .ok()? - } -} - -struct LogEvent<'a>(&'a Event<'a>); - -impl<'a> fmt::Display for LogEvent<'a> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let mut has_logged = false; - let mut format_fields = |field: &field::Field, value: &dyn fmt::Debug| { - let name = field.name(); - let leading = if has_logged { " " } else { "" }; - // TODO: handle fmt error? - let _ = if name == "message" { - write!(f, "{}{:?};", leading, value) - } else { - write!(f, "{}{}={:?};", leading, name, value) - }; - has_logged = true; - }; - - self.0.record(&mut format_fields); - Ok(()) - } -} - -impl fmt::Debug for TraceLogger { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("TraceLogger") - .field("settings", &self.settings) - .field("spans", &self.spans) - .field("current", &self.current_id()) - .field("next_id", &self.next_id) - .finish() - } -} |