From 743f2328859aa30cb2de6fe33d05562049f23db2 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Thu, 16 Nov 2023 15:25:43 -0800 Subject: [PATCH 01/23] parameterize registry --- .vscode/settings.json | 2 + Cargo.toml | 1 + rust-toolchain.toml | 3 +- trace4rs/Cargo.toml | 3 + trace4rs/src/handle/layers.rs | 99 +++++++++------- trace4rs/src/handle/loggers.rs | 158 ++++++++++++------------- trace4rs/src/handle/mod.rs | 106 ++++++++++++----- trace4rs/src/handle/shared_registry.rs | 95 +++++++++++++++ trace4rs/src/handle/span_broker.rs | 72 ----------- trace4rs/src/handle/trace_logger.rs | 49 ++++---- trace4rs/src/lib.rs | 12 +- 11 files changed, 334 insertions(+), 266 deletions(-) create mode 100644 trace4rs/src/handle/shared_registry.rs delete mode 100644 trace4rs/src/handle/span_broker.rs diff --git a/.vscode/settings.json b/.vscode/settings.json index 3f8288e..fdc8dae 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,5 +1,7 @@ { "cSpell.words": [ + "appender", + "appenders", "fmtorp", "messageonly" ] diff --git a/Cargo.toml b/Cargo.toml index 226f1eb..5ccc424 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,2 +1,3 @@ [workspace] +resolver = "1" members = ["trace4rs", "trace4rs-config", "trace4rs-fmtorp"] diff --git a/rust-toolchain.toml b/rust-toolchain.toml index e95a5e2..292fe49 100644 --- a/rust-toolchain.toml +++ b/rust-toolchain.toml @@ -1,3 +1,2 @@ [toolchain] -channel = "nightly-2022-06-25" -profile = "default" +channel = "stable" diff --git a/trace4rs/Cargo.toml b/trace4rs/Cargo.toml index 0b242bb..814949e 100644 --- a/trace4rs/Cargo.toml +++ b/trace4rs/Cargo.toml @@ -34,6 +34,9 @@ trace4rs-fmtorp = { version = "0.5.1", path = "../trace4rs-fmtorp" } utc-offset = "0.3.0" camino = "1.1.2" rustversion = "1.0.14" +tracing-tree = { version = "0.3.0", features = ["time"] } +ambassador = "0.3.5" +derive-where = "1.2.5" [dev-dependencies] criterion = "0.4.0" diff --git a/trace4rs/src/handle/layers.rs b/trace4rs/src/handle/layers.rs index fbe00f9..79cd10e 100644 --- a/trace4rs/src/handle/layers.rs +++ b/trace4rs/src/handle/layers.rs @@ -1,51 +1,57 @@ -use tracing::{ - metadata::LevelFilter, - Event, -}; +use std::sync::Arc; + +use tracing::{metadata::LevelFilter, Event, Subscriber}; use tracing_log::NormalizeEvent; -use tracing_subscriber::{ - layer::Context, - Layer, -}; +use tracing_subscriber::{fmt::format::DefaultFields, layer::Context, registry::LookupSpan, Layer}; -use super::{ - loggers::{ - EventFormatter, - Logger, - }, - span_broker::SpanBroker, -}; +use super::loggers::{EventFormatter, Logger}; use crate::{ - appenders::{ - Appender, - Appenders, - }, - config::{ - AppenderId, - Config, - }, + appenders::{Appender, Appenders}, + config::{AppenderId, Config}, error::Result, }; pub type PolyLayer = Box + Send + Sync + 'static>; -pub(crate) struct Layers { - enabled: bool, - default: PolyLayer, - loggers: Vec>, +pub struct Layers { + enabled: bool, + default: PolyLayer, + loggers: Vec>, appenders: Appenders, } - -impl Layers { +impl Clone for Layers +where + PolyLayer: Clone, +{ + fn clone(&self) -> Self { + Self { + enabled: self.enabled, + default: self.default.clone(), + loggers: self.loggers.clone(), + appenders: self.appenders.clone(), + } + } +} +impl Layers { /// If the files which are the target of appenders have been moved we /// abandon the moved files and remount at the correct path. pub fn correct_appender_paths(&self) -> Result<()> { self.appenders.correct_paths() } + pub fn appenders(&self) -> &Appenders { + &self.appenders + } +} + +impl Layers { /// The default `Layers` backed by `broker` (`INFO` and above goes to /// stdout). - pub fn default(broker: SpanBroker) -> Self { + pub fn default(broker: S) -> Layers + where + S: Subscriber + Send + Sync + for<'b> LookupSpan<'b>, + Logger: Layer, + { let stdout_appender = AppenderId("stdout".to_string()); let appenders = Appenders::new(literally::hmap! {stdout_appender.clone() => Appender::new_console()}); @@ -57,17 +63,17 @@ impl Layers { &appenders, EventFormatter::Normal, ); - Self::new(default, vec![], appenders) + Layers::::new(default, vec![], appenders) } /// Create a new `Layers` from a default layer and a pre-generated vec of /// sub-layers. - fn new( - default: PolyLayer, - loggers: Vec>, + fn new( + default: PolyLayer, + loggers: Vec>, appenders: Appenders, - ) -> Self { - Self { + ) -> Layers { + Layers { enabled: true, default, loggers, @@ -79,7 +85,11 @@ impl Layers { /// /// # Errors /// An error may occur while building the appenders. - pub fn from_config(broker: SpanBroker, config: &Config) -> Result { + pub fn from_config(broker: B, config: &Config) -> Result> + where + B: Clone + Subscriber + Send + Sync + for<'b> LookupSpan<'b>, + Logger: Layer, + { let appenders = (&config.appenders).try_into()?; let layers: Vec> = config .loggers @@ -105,15 +115,11 @@ impl Layers { config.default.format.clone().into(), ); - Ok(Layers::new(default, layers, appenders)) - } - - pub fn appenders(&self) -> &Appenders { - &self.appenders + Ok(Layers::::new(default, layers, appenders)) } } -impl Layers { +impl Layers { /// Disable this subscriber. pub fn disable(&mut self) { self.enabled = false; @@ -125,8 +131,11 @@ impl Layers { } } -impl Layer for Layers { - fn on_event(&self, event: &Event<'_>, ctx: Context<'_, SpanBroker>) { +impl Layer for Layers +where + S: Subscriber + Clone, +{ + fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) { if !self.enabled { return; } diff --git a/trace4rs/src/handle/loggers.rs b/trace4rs/src/handle/loggers.rs index 425829e..d9ee1ae 100644 --- a/trace4rs/src/handle/loggers.rs +++ b/trace4rs/src/handle/loggers.rs @@ -1,56 +1,28 @@ #![allow(clippy::single_char_lifetime_names)] use core::fmt; -use std::{ - borrow::Cow, - io, -}; +use std::{borrow::Cow, io}; use once_cell::sync::Lazy; -use tracing::{ - field::Visit, - metadata::LevelFilter, - Event, - Metadata, -}; +use trace4rs_fmtorp::FieldValueWriter; +use tracing::{field::Visit, metadata::LevelFilter, Event, Metadata, Subscriber}; use tracing_log::NormalizeEvent; use tracing_subscriber::{ fmt::{ - format::{ - self, - DefaultFields, - Format, - Full, - Writer, - }, + format::{self, DefaultFields, Format, Full, Writer}, time::FormatTime, - writer::{ - BoxMakeWriter, - MakeWriterExt, - }, - FmtContext, - FormatEvent, - FormatFields, - Layer as FmtLayer, - }, - layer::{ - Context, - Layered, + writer::{BoxMakeWriter, MakeWriterExt}, + FmtContext, FormatEvent, FormatFields, Layer as FmtLayer, }, + layer::{Context, Layered}, prelude::__tracing_subscriber_SubscriberExt, - Layer, + registry::LookupSpan, + Layer, Registry, }; -use super::{ - span_broker::SpanBroker, - PolyLayer, -}; +use super::PolyLayer; use crate::{ appenders::Appenders, - config::{ - AppenderId, - Format as ConfigFormat, - Target, - }, + config::{AppenderId, Format as ConfigFormat, Target}, }; const TIME_FORMAT: time::format_description::well_known::Rfc3339 = @@ -59,22 +31,37 @@ const TIME_FORMAT: time::format_description::well_known::Rfc3339 = static NORMAL_FMT: Lazy> = Lazy::new(|| Format::default().with_timer(UtcOffsetTime).with_ansi(false)); -pub struct Logger { - level: LevelFilter, +pub struct Logger { + level: LevelFilter, target: Option, - layer: Layered, SpanBroker>, + layer: Layered, Reg>, +} +impl Logger { + fn is_enabled(&self, meta: &Metadata<'_>) -> bool { + let match_level = meta.level() <= &self.level; + let match_target = self + .target + .as_ref() + .map_or(true, |t| meta.target().starts_with(t.as_str())); + + match_level && match_target + } } impl Logger { - pub fn new_erased<'a>( - r: SpanBroker, + pub fn new_erased<'a, B>( + b: B, level: LevelFilter, target: Option, ids: impl IntoIterator, appenders: &Appenders, format: EventFormatter, - ) -> PolyLayer { + ) -> PolyLayer + where + B: Subscriber + Send + Sync + for<'b> LookupSpan<'b>, + Logger: Layer, + { Box::new(Self::new( - r, + b, level, target, ids.into_iter(), @@ -83,16 +70,6 @@ impl Logger { )) } - fn is_enabled(&self, meta: &Metadata<'_>) -> bool { - let match_level = meta.level() <= &self.level; - let match_target = self - .target - .as_ref() - .map_or(true, |t| meta.target().starts_with(t.as_str())); - - match_level && match_target - } - fn mk_writer<'a>( ids: impl Iterator, appenders: &Appenders, @@ -110,35 +87,44 @@ impl Logger { accumulated_makewriter } - pub fn new<'a>( - r: SpanBroker, + pub fn new<'a, B>( + r: B, level: LevelFilter, target: Option, ids: impl Iterator, appenders: &Appenders, format: EventFormatter, - ) -> Self { + ) -> Logger + where + B: Subscriber + Send + Sync + for<'b> LookupSpan<'b>, + tracing_subscriber::fmt::Layer: Layer, + { let writer = Self::mk_writer(ids, appenders).unwrap_or_else(|| BoxMakeWriter::new(io::sink)); let fmt_layer = FmtLayer::default().event_format(format).with_ansi(false); let append_layer = fmt_layer.with_writer(writer); + // let layer = append_layer; let layer = r.with(append_layer); - Self { + Logger { level, target, layer, } } } -impl Layer for Logger { - fn enabled(&self, meta: &Metadata<'_>, _ctx: Context<'_, SpanBroker>) -> bool { +impl Layer for Logger +where + Sub: Subscriber, + FmtLayer: Layer, +{ + fn enabled(&self, meta: &Metadata<'_>, _ctx: Context<'_, Sub>) -> bool { Logger::is_enabled(self, meta) } - fn on_event(&self, event: &Event<'_>, ctx: Context<'_, SpanBroker>) { - self.layer.on_event(event, ctx); + fn on_event(&self, event: &Event<'_>, _ctx: Context<'_, Sub>) { + self.layer.event(event); } } @@ -177,11 +163,14 @@ impl From for EventFormatter { } } -impl FormatEvent for EventFormatter { +impl<'w, 'ctx, 'evt, S> FormatEvent for EventFormatter +where + S: Subscriber + for<'b> LookupSpan<'b>, +{ fn format_event( &self, - ctx: &tracing_subscriber::fmt::FmtContext<'_, SpanBroker, DefaultFields>, - writer: tracing_subscriber::fmt::format::Writer<'_>, + ctx: &FmtContext<'_, S, DefaultFields>, + writer: Writer<'_>, event: &Event<'_>, ) -> std::fmt::Result { match self { @@ -217,11 +206,11 @@ mod fields { }); } -struct CustomValueWriter<'ctx, 'evt> { - ctx: &'ctx FmtContext<'ctx, SpanBroker, DefaultFields>, +struct CustomValueWriter<'ctx, 'evt, Broker> { + ctx: &'ctx FmtContext<'ctx, Broker, DefaultFields>, event: &'evt Event<'evt>, } -impl<'ctx, 'evt> CustomValueWriter<'ctx, 'evt> { +impl<'ctx, 'evt, Broker> CustomValueWriter<'ctx, 'evt, Broker> { fn format_timestamp(mut writer: format::Writer<'_>) -> fmt::Result { use tracing_subscriber::fmt::time::OffsetTime; @@ -235,7 +224,11 @@ impl<'ctx, 'evt> CustomValueWriter<'ctx, 'evt> { t.format_time(&mut writer) } } -impl<'ctx, 'evt> trace4rs_fmtorp::FieldValueWriter for CustomValueWriter<'ctx, 'evt> { +impl<'ctx, 'evt, Broker> FieldValueWriter for CustomValueWriter<'ctx, 'evt, Broker> +where + Broker: 'static, + for<'writer> FmtContext<'ctx, Broker, DefaultFields>: FormatFields<'writer>, +{ fn write_value(&self, mut writer: format::Writer<'_>, field: &'static str) -> fmt::Result { let normalized_meta = self.event.normalized_metadata(); let meta = normalized_meta @@ -278,12 +271,15 @@ impl CustomFormatter { Ok(Self { fmtr }) } - fn format_event( + fn format_event<'ctx, 'evt, 'w, S>( &self, - ctx: &FmtContext<'_, SpanBroker, DefaultFields>, - writer: Writer<'_>, - event: &Event<'_>, - ) -> fmt::Result { + ctx: &FmtContext<'ctx, S, DefaultFields>, + writer: Writer<'w>, + event: &Event<'evt>, + ) -> fmt::Result + where + S: Subscriber + for<'b> LookupSpan<'b>, + { let value_writer = CustomValueWriter { ctx, event }; self.fmtr.write(writer, &value_writer) } @@ -292,16 +288,12 @@ impl CustomFormatter { const MESSAGE_FIELD_NAME: &str = "message"; struct SingleFieldVisitor<'w> { - newline: bool, - writer: tracing_subscriber::fmt::format::Writer<'w>, + newline: bool, + writer: Writer<'w>, field_name: Cow<'static, str>, } impl<'w> SingleFieldVisitor<'w> { - fn new( - newline: bool, - writer: tracing_subscriber::fmt::format::Writer<'w>, - field_name: impl Into>, - ) -> Self { + fn new(newline: bool, writer: Writer<'w>, field_name: impl Into>) -> Self { Self { newline, writer, diff --git a/trace4rs/src/handle/mod.rs b/trace4rs/src/handle/mod.rs index 74bb0d2..e75d3b7 100644 --- a/trace4rs/src/handle/mod.rs +++ b/trace4rs/src/handle/mod.rs @@ -1,34 +1,54 @@ -use std::convert::TryFrom; +use std::{convert::TryFrom, sync::Arc}; -use tracing_subscriber::reload; +use tracing::Subscriber; +use tracing_subscriber::{ + layer::{Layer, Layered}, + registry::LookupSpan, + reload, Registry, +}; +use tracing_tree::HierarchicalLayer; use crate::{ config::Config, - error::{ - Error, - Result, - }, + error::{Error, Result}, }; mod layers; mod loggers; -mod span_broker; +mod shared_registry; mod trace_logger; use layers::Layers; pub use layers::PolyLayer; -use span_broker::SpanBroker; +use shared_registry::SharedRegistry; pub use trace_logger::TraceLogger; +use self::loggers::Logger; + +type DynHandle = Handle>; +pub type StandardHandle = Handle; + /// The reloadable handle for a `TraceLogger`, with this we can modify the /// logging configuration at runtime. #[derive(Clone)] -pub struct Handle { - reload_handle: reload::Handle, SpanBroker>, - trace_logger: TraceLogger, - broker: SpanBroker, +pub struct Handle { + reload_handle: reload::Handle, Reg>, + trace_logger: TraceLogger, + root_subscriber: Reg, } +// impl Clone for Handle +// where +// Sub: Clone, +// { +// fn clone(&self) -> Self { +// Self { +// reload_handle: self.reload_handle.clone(), +// trace_logger: self.trace_logger.clone(), +// } +// } +// } + /// Initializes the default `trace4rs` handle as the `tracing` global default. /// /// # Errors @@ -38,11 +58,30 @@ pub fn init_console_logger() -> Result { tracing::subscriber::set_global_default(h.subscriber())?; Ok(h) } +pub type HierarchicalHandle = Handle>; + +impl Handle +where + Reg: Default + Subscriber + Send + Sync + Clone + for<'b> LookupSpan<'b>, + Logger: Layer, +{ + pub fn new() -> Handle { + let broker = Reg::default(); + let layers = Layers::::default(broker.clone()); + + Handle::::from_layers(broker, layers) + } + + // pub fn new_hierarchical(n: usize) -> HierarchicalHandle { + // let broker = SpanBroker::new_hierarchical(n); + // let layers = Layers::::default(broker.clone()); + + // Handle::::from_layers(broker, layers) + // } -impl Handle { /// Get the subscriber that backs this handle. #[must_use] - pub fn subscriber(&self) -> TraceLogger { + pub fn subscriber(&self) -> TraceLogger { self.trace_logger.clone() } @@ -97,7 +136,8 @@ impl Handle { /// - Building the appenders in the config, for example /// opening a file for write. pub fn update(&mut self, config: &Config) -> Result<()> { - let ls = Layers::from_config(self.broker.clone(), config)?; + let broke_clone = self.root_subscriber.clone(); + let ls = Layers::::from_config(broke_clone, config)?; Ok(self.reload_handle.reload(ls)?) } @@ -106,37 +146,43 @@ impl Handle { /// # Errors /// This could fail building the appenders in the config, for example /// opening a file for write. - pub fn from_config(broker: SpanBroker, config: &Config) -> Result { - let layers = Layers::from_config(broker.clone(), config)?; - Ok(Self::from_layers(broker, layers)) + pub fn from_config(reg: Reg, config: &Config) -> Result> + where + Reg: Subscriber + Send + Sync + Clone, + // Arc, Reg>>: Layer, + { + let layers = Layers::::from_config(reg.clone(), config)?; + Ok(Self::from_layers(reg, layers)) } - /// Builds `Self` from `Layers` and the backing `SpanBroker`. - fn from_layers(broker: SpanBroker, layers: Layers) -> Self { + /// Builds `Self` from `Layers` and the backing `Reg`. + fn from_layers(broker: Reg, layers: Layers) -> Handle + where + Reg: Subscriber + Send + Sync, + // Arc, Reg>>: Layer, + { let (reloadable, reload_handle) = reload::Layer::new(layers); - let trace_logger = TraceLogger::new(broker.clone(), reloadable); + let root_subscriber = broker.clone(); + let trace_logger = TraceLogger::new(root_subscriber.clone(), reloadable); - Self { + Handle { reload_handle, trace_logger, - broker, + root_subscriber, } } } impl Default for Handle { fn default() -> Self { - let broker = SpanBroker::new(); - let layers = Layers::default(broker.clone()); - - Self::from_layers(broker, layers) + Self::new() } } impl TryFrom for Handle { type Error = Error; - fn try_from(c: Config) -> Result { + fn try_from(c: Config) -> Result { Self::try_from(&c) } } @@ -145,7 +191,7 @@ impl TryFrom<&Config> for Handle { type Error = Error; fn try_from(c: &Config) -> Result { - let broker = SpanBroker::new(); - Self::from_config(broker, c) + let reg = SharedRegistry::default(); + Handle::from_config(reg, c) } } diff --git a/trace4rs/src/handle/shared_registry.rs b/trace4rs/src/handle/shared_registry.rs new file mode 100644 index 0000000..d4a2edb --- /dev/null +++ b/trace4rs/src/handle/shared_registry.rs @@ -0,0 +1,95 @@ +#![allow(clippy::single_char_lifetime_names)] + +use std::sync::Arc; + +use derive_where::derive_where; +use tracing::{span, Event, Subscriber}; +use tracing_subscriber::{ + registry::{self, LookupSpan}, + Registry, +}; + +type DynRegistry = SharedRegistry>; + +/// SharedRegistry exists because we need to be able to override the layer functionality. +/// Also we would otherwise need to wrap a registry in an arc to share it as much as we do. +/// +#[derive(Debug)] +#[derive_where(Clone)] +#[derive_where(Default; Reg: Default)] +pub struct SharedRegistry { + inner: Arc, +} + +impl SharedRegistry { + pub fn new() -> Self { + SharedRegistry { + inner: Arc::new(tracing_subscriber::registry()), + } + } + + // pub fn new_hierarchical(n: usize) -> HierarchicalBroker { + // use tracing_subscriber::layer::SubscriberExt; + + // let hier = HierarchicalLayer::new(n).with_writer(Self::open_metrics()); + // let reg = tracing_subscriber::registry().with(hier); + // SpanBroker { + // inner: Arc::new(reg), + // } + // } +} +// pub type HierarchicalBroker = +// SharedRegistry>, Registry>>; +// impl Default for HierarchicalBroker { +// fn default() -> Self { +// SharedRegistry::new_hierarchical(2) +// } +// } + +impl tracing_subscriber::Layer for SharedRegistry {} + +// ########## DELEGATION BELOW ########### + +impl<'a, R> LookupSpan<'a> for SharedRegistry +where + R: LookupSpan<'a, Data = registry::Data<'a>>, +{ + type Data = registry::Data<'a>; + + fn span_data(&'a self, id: &tracing::Id) -> Option { + self.inner.span_data(id) + } +} + +impl Subscriber for SharedRegistry +where + R: Subscriber, +{ + fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool { + self.inner.enabled(metadata) + } + + fn new_span(&self, span: &span::Attributes<'_>) -> span::Id { + self.inner.new_span(span) + } + + fn record(&self, span: &span::Id, values: &span::Record<'_>) { + self.inner.record(span, values); + } + + fn record_follows_from(&self, span: &span::Id, follows: &span::Id) { + self.inner.record_follows_from(span, follows); + } + + fn event(&self, event: &Event<'_>) { + self.inner.event(event); + } + + fn enter(&self, span: &span::Id) { + self.inner.enter(span); + } + + fn exit(&self, span: &span::Id) { + self.inner.exit(span); + } +} diff --git a/trace4rs/src/handle/span_broker.rs b/trace4rs/src/handle/span_broker.rs deleted file mode 100644 index 77869ab..0000000 --- a/trace4rs/src/handle/span_broker.rs +++ /dev/null @@ -1,72 +0,0 @@ -#![allow(clippy::single_char_lifetime_names)] -use std::sync::Arc; - -use tracing::{ - span, - Event, - Subscriber, -}; -use tracing_subscriber::{ - registry::{ - self, - LookupSpan, - }, - Registry, -}; - -#[derive(Debug, Clone)] -pub struct SpanBroker { - inner: Arc, -} - -impl SpanBroker { - pub fn new() -> Self { - Self::default() - } -} -impl Default for SpanBroker { - fn default() -> Self { - SpanBroker { - inner: Arc::new(tracing_subscriber::registry()), - } - } -} -impl<'a> LookupSpan<'a> for SpanBroker { - type Data = registry::Data<'a>; - - fn span_data(&'a self, id: &tracing::Id) -> Option { - self.inner.span_data(id) - } -} - -impl Subscriber for SpanBroker { - fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool { - self.inner.enabled(metadata) - } - - fn new_span(&self, span: &span::Attributes<'_>) -> span::Id { - self.inner.new_span(span) - } - - fn record(&self, span: &span::Id, values: &span::Record<'_>) { - self.inner.record(span, values); - } - - fn record_follows_from(&self, span: &span::Id, follows: &span::Id) { - self.inner.record_follows_from(span, follows); - } - - fn event(&self, event: &Event<'_>) { - self.inner.event(event); - } - - fn enter(&self, span: &span::Id) { - self.inner.enter(span); - } - - fn exit(&self, span: &span::Id) { - self.inner.exit(span); - } -} - -impl tracing_subscriber::Layer for SpanBroker {} diff --git a/trace4rs/src/handle/trace_logger.rs b/trace4rs/src/handle/trace_logger.rs index 18eb324..68cb353 100644 --- a/trace4rs/src/handle/trace_logger.rs +++ b/trace4rs/src/handle/trace_logger.rs @@ -1,58 +1,59 @@ use std::sync::Arc; -use tracing::{ - span, - Event, - Subscriber, -}; -use tracing_subscriber::{ - layer::Layered, - prelude::*, - reload, -}; - -use super::span_broker::SpanBroker; +use tracing::{span, Event, Subscriber}; +use tracing_subscriber::{layer::Layered, prelude::*, reload, Registry}; + use crate::handle::Layers; /// The `tracing::Subscriber` that this crate implements. #[derive(Clone)] -pub struct TraceLogger { - inner: Arc, SpanBroker>, SpanBroker>>, +pub struct TraceLogger { + inner: Arc, Reg>, Reg>>, } impl TraceLogger { - pub(crate) fn new(broker: SpanBroker, layers: reload::Layer) -> Self { + pub(crate) fn new(broker: Reg, layers: reload::Layer, Reg>) -> TraceLogger + where + Reg: Subscriber + Clone, + // Arc, Reg>>: tracing_subscriber::layer::Layer, + { let inner = Arc::new(broker.with(layers)); - Self { inner } + TraceLogger { inner } } } -impl Subscriber for TraceLogger { +// ########## DELEGATION BELOW ########### + +impl Subscriber for TraceLogger +where + Reg: Subscriber + Clone, + // reload::Layer, Reg>: tracing_subscriber::Layer, +{ fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool { - Subscriber::enabled(self.inner.as_ref(), metadata) + Subscriber::enabled(&self.inner, metadata) } fn new_span(&self, span: &span::Attributes<'_>) -> span::Id { - Subscriber::new_span(self.inner.as_ref(), span) + Subscriber::new_span(&self.inner, span) } fn record(&self, span: &span::Id, values: &span::Record<'_>) { - Subscriber::record(self.inner.as_ref(), span, values); + Subscriber::record(&self.inner, span, values); } fn record_follows_from(&self, span: &span::Id, follows: &span::Id) { - Subscriber::record_follows_from(self.inner.as_ref(), span, follows); + Subscriber::record_follows_from(&self.inner, span, follows); } fn event(&self, event: &Event<'_>) { - Subscriber::event(self.inner.as_ref(), event); + Subscriber::event(&self.inner, event); } fn enter(&self, span: &span::Id) { - Subscriber::enter(self.inner.as_ref(), span); + Subscriber::enter(&self.inner, span); } fn exit(&self, span: &span::Id) { - Subscriber::exit(self.inner.as_ref(), span); + Subscriber::exit(&self.inner, span); } } diff --git a/trace4rs/src/lib.rs b/trace4rs/src/lib.rs index 3b3908e..583c56e 100644 --- a/trace4rs/src/lib.rs +++ b/trace4rs/src/lib.rs @@ -22,13 +22,5 @@ pub mod error; mod test; pub use appenders::Appender; -pub use handle::{ - init_console_logger, - Handle, - TraceLogger, -}; -pub use trace4rs_config::{ - config, - config::Config, - error::Error as ConfigError, -}; +pub use handle::{init_console_logger, Handle, HierarchicalHandle, StandardHandle, TraceLogger}; +pub use trace4rs_config::{config, config::Config, error::Error as ConfigError}; From a58e958d49ca095fd237587a16da80fd56eb6557 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Thu, 16 Nov 2023 16:28:39 -0800 Subject: [PATCH 02/23] unerase some types --- trace4rs/src/handle/layers.rs | 78 ++++++++++++++++------------- trace4rs/src/handle/loggers.rs | 76 +++++++++++----------------- trace4rs/src/handle/mod.rs | 51 +++++++------------ trace4rs/src/handle/trace_logger.rs | 21 ++++---- 4 files changed, 100 insertions(+), 126 deletions(-) diff --git a/trace4rs/src/handle/layers.rs b/trace4rs/src/handle/layers.rs index 79cd10e..beb907f 100644 --- a/trace4rs/src/handle/layers.rs +++ b/trace4rs/src/handle/layers.rs @@ -1,27 +1,32 @@ -use std::sync::Arc; - use tracing::{metadata::LevelFilter, Event, Subscriber}; use tracing_log::NormalizeEvent; -use tracing_subscriber::{fmt::format::DefaultFields, layer::Context, registry::LookupSpan, Layer}; +use tracing_subscriber::{ + fmt::{format::DefaultFields, writer::BoxMakeWriter, Layer as FmtLayer}, + layer::Context, + registry::LookupSpan, + Layer, +}; -use super::loggers::{EventFormatter, Logger}; +use super::{ + loggers::{EventFormatter, Logger}, + shared_registry::SharedRegistry, +}; use crate::{ appenders::{Appender, Appenders}, config::{AppenderId, Config}, error::Result, }; -pub type PolyLayer = Box + Send + Sync + 'static>; - -pub struct Layers { +pub struct Trace4Layers { enabled: bool, - default: PolyLayer, - loggers: Vec>, + default: Logger, + loggers: Vec>, appenders: Appenders, } -impl Clone for Layers + +impl Clone for Trace4Layers where - PolyLayer: Clone, + Logger: Clone, { fn clone(&self) -> Self { Self { @@ -32,7 +37,7 @@ where } } } -impl Layers { +impl Trace4Layers { /// If the files which are the target of appenders have been moved we /// abandon the moved files and remount at the correct path. pub fn correct_appender_paths(&self) -> Result<()> { @@ -44,36 +49,36 @@ impl Layers { } } -impl Layers { +impl Trace4Layers { /// The default `Layers` backed by `broker` (`INFO` and above goes to /// stdout). - pub fn default(broker: S) -> Layers + pub fn default(registry: Reg) -> Trace4Layers where - S: Subscriber + Send + Sync + for<'b> LookupSpan<'b>, - Logger: Layer, + Reg: Subscriber + Send + Sync + for<'b> LookupSpan<'b>, + Logger: Layer, { let stdout_appender = AppenderId("stdout".to_string()); let appenders = Appenders::new(literally::hmap! {stdout_appender.clone() => Appender::new_console()}); - let default = Logger::new_erased( - broker, + let default = Logger::new( + registry, LevelFilter::INFO, None, - &[stdout_appender], + (&[stdout_appender]).into_iter(), &appenders, EventFormatter::Normal, ); - Layers::::new(default, vec![], appenders) + Trace4Layers::new(default, vec![], appenders) } /// Create a new `Layers` from a default layer and a pre-generated vec of /// sub-layers. - fn new( - default: PolyLayer, - loggers: Vec>, + fn new( + default: Logger, + loggers: Vec>, appenders: Appenders, - ) -> Layers { - Layers { + ) -> Trace4Layers { + Trace4Layers { enabled: true, default, loggers, @@ -85,18 +90,18 @@ impl Layers { /// /// # Errors /// An error may occur while building the appenders. - pub fn from_config(broker: B, config: &Config) -> Result> + pub fn from_config(registry: Reg, config: &Config) -> Result> where - B: Clone + Subscriber + Send + Sync + for<'b> LookupSpan<'b>, - Logger: Layer, + Reg: Clone + Subscriber + Send + Sync + for<'b> LookupSpan<'b>, + Logger: Layer, { let appenders = (&config.appenders).try_into()?; - let layers: Vec> = config + let layers: Vec> = config .loggers .iter() .map(|(targ, lg)| { - Logger::new_erased( - broker.clone(), + Logger::new( + registry.clone(), lg.level.into(), Some(targ.clone()), lg.appenders.iter(), @@ -106,8 +111,8 @@ impl Layers { }) .collect(); - let default = Logger::new_erased( - broker, + let default = Logger::new( + registry, config.default.level.into(), None, config.default.appenders.iter(), @@ -115,11 +120,11 @@ impl Layers { config.default.format.clone().into(), ); - Ok(Layers::::new(default, layers, appenders)) + Ok(Trace4Layers::new(default, layers, appenders)) } } -impl Layers { +impl Trace4Layers { /// Disable this subscriber. pub fn disable(&mut self) { self.enabled = false; @@ -131,9 +136,10 @@ impl Layers { } } -impl Layer for Layers +impl Layer for Trace4Layers where S: Subscriber + Clone, + FmtLayer: Layer, { fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) { if !self.enabled { diff --git a/trace4rs/src/handle/loggers.rs b/trace4rs/src/handle/loggers.rs index d9ee1ae..c1a7fed 100644 --- a/trace4rs/src/handle/loggers.rs +++ b/trace4rs/src/handle/loggers.rs @@ -19,55 +19,50 @@ use tracing_subscriber::{ Layer, Registry, }; -use super::PolyLayer; use crate::{ appenders::Appenders, config::{AppenderId, Format as ConfigFormat, Target}, }; +use super::shared_registry::SharedRegistry; + const TIME_FORMAT: time::format_description::well_known::Rfc3339 = time::format_description::well_known::Rfc3339; static NORMAL_FMT: Lazy> = Lazy::new(|| Format::default().with_timer(UtcOffsetTime).with_ansi(false)); -pub struct Logger { +pub struct Logger { level: LevelFilter, target: Option, layer: Layered, Reg>, } -impl Logger { - fn is_enabled(&self, meta: &Metadata<'_>) -> bool { - let match_level = meta.level() <= &self.level; - let match_target = self - .target - .as_ref() - .map_or(true, |t| meta.target().starts_with(t.as_str())); - match_level && match_target - } -} impl Logger { - pub fn new_erased<'a, B>( - b: B, + pub fn new<'a, Reg>( + r: Reg, level: LevelFilter, target: Option, - ids: impl IntoIterator, + ids: impl Iterator, appenders: &Appenders, format: EventFormatter, - ) -> PolyLayer + ) -> Logger where - B: Subscriber + Send + Sync + for<'b> LookupSpan<'b>, - Logger: Layer, + Reg: Subscriber + Send + Sync + for<'b> LookupSpan<'b>, + FmtLayer: Layer, { - Box::new(Self::new( - b, + let writer = + Self::mk_writer(ids, appenders).unwrap_or_else(|| BoxMakeWriter::new(io::sink)); + + let fmt_layer = FmtLayer::default().event_format(format).with_ansi(false); + let append_layer = fmt_layer.with_writer(writer); + let layer = r.with(append_layer); + + Logger { level, target, - ids.into_iter(), - appenders, - format, - )) + layer, + } } fn mk_writer<'a>( @@ -86,32 +81,17 @@ impl Logger { } accumulated_makewriter } +} - pub fn new<'a, B>( - r: B, - level: LevelFilter, - target: Option, - ids: impl Iterator, - appenders: &Appenders, - format: EventFormatter, - ) -> Logger - where - B: Subscriber + Send + Sync + for<'b> LookupSpan<'b>, - tracing_subscriber::fmt::Layer: Layer, - { - let writer = - Self::mk_writer(ids, appenders).unwrap_or_else(|| BoxMakeWriter::new(io::sink)); - - let fmt_layer = FmtLayer::default().event_format(format).with_ansi(false); - let append_layer = fmt_layer.with_writer(writer); - // let layer = append_layer; - let layer = r.with(append_layer); +impl Logger { + fn is_enabled(&self, meta: &Metadata<'_>) -> bool { + let match_level = meta.level() <= &self.level; + let match_target = self + .target + .as_ref() + .map_or(true, |t| meta.target().starts_with(t.as_str())); - Logger { - level, - target, - layer, - } + match_level && match_target } } impl Layer for Logger diff --git a/trace4rs/src/handle/mod.rs b/trace4rs/src/handle/mod.rs index e75d3b7..4988bde 100644 --- a/trace4rs/src/handle/mod.rs +++ b/trace4rs/src/handle/mod.rs @@ -1,10 +1,10 @@ -use std::{convert::TryFrom, sync::Arc}; +use std::convert::TryFrom; use tracing::Subscriber; use tracing_subscriber::{ layer::{Layer, Layered}, registry::LookupSpan, - reload, Registry, + reload, }; use tracing_tree::HierarchicalLayer; @@ -18,8 +18,7 @@ mod loggers; mod shared_registry; mod trace_logger; -use layers::Layers; -pub use layers::PolyLayer; +use layers::Trace4Layers; use shared_registry::SharedRegistry; pub use trace_logger::TraceLogger; @@ -32,23 +31,11 @@ pub type StandardHandle = Handle; /// logging configuration at runtime. #[derive(Clone)] pub struct Handle { - reload_handle: reload::Handle, Reg>, + reload_handle: reload::Handle, Reg>, trace_logger: TraceLogger, root_subscriber: Reg, } -// impl Clone for Handle -// where -// Sub: Clone, -// { -// fn clone(&self) -> Self { -// Self { -// reload_handle: self.reload_handle.clone(), -// trace_logger: self.trace_logger.clone(), -// } -// } -// } - /// Initializes the default `trace4rs` handle as the `tracing` global default. /// /// # Errors @@ -66,17 +53,17 @@ where Logger: Layer, { pub fn new() -> Handle { - let broker = Reg::default(); - let layers = Layers::::default(broker.clone()); + let registry = Reg::default(); + let layers = Trace4Layers::default(registry.clone()); - Handle::::from_layers(broker, layers) + Handle::::from_layers(registry, layers) } // pub fn new_hierarchical(n: usize) -> HierarchicalHandle { - // let broker = SpanBroker::new_hierarchical(n); - // let layers = Layers::::default(broker.clone()); + // let registry = Spanregistry::new_hierarchical(n); + // let layers = Layers::::default(registry.clone()); - // Handle::::from_layers(broker, layers) + // Handle::::from_layers(registry, layers) // } /// Get the subscriber that backs this handle. @@ -92,7 +79,7 @@ where /// - We were unable to update the subscriber. pub fn disable(&self) -> Result<()> { self.reload_handle - .modify(Layers::disable) + .modify(Trace4Layers::disable) .map_err(Into::into) } @@ -103,7 +90,7 @@ where /// - We were unable to update the subscriber. pub fn enable(&self) -> Result<()> { self.reload_handle - .modify(Layers::enable) + .modify(Trace4Layers::enable) .map_err(Into::into) } @@ -125,7 +112,7 @@ where /// - Re-mounting a file has failed. pub fn correct_appender_paths(&self) -> Result<()> { self.reload_handle - .with_current(Layers::correct_appender_paths)??; + .with_current(Trace4Layers::correct_appender_paths)??; Ok(()) } @@ -137,11 +124,11 @@ where /// opening a file for write. pub fn update(&mut self, config: &Config) -> Result<()> { let broke_clone = self.root_subscriber.clone(); - let ls = Layers::::from_config(broke_clone, config)?; + let ls = Trace4Layers::from_config(broke_clone, config)?; Ok(self.reload_handle.reload(ls)?) } - /// Using the given `SpanBroker` we configure and initialize our `Self`. + /// Using the given `SharedRegistry` we configure and initialize our `Self`. /// /// # Errors /// This could fail building the appenders in the config, for example @@ -149,20 +136,18 @@ where pub fn from_config(reg: Reg, config: &Config) -> Result> where Reg: Subscriber + Send + Sync + Clone, - // Arc, Reg>>: Layer, { - let layers = Layers::::from_config(reg.clone(), config)?; + let layers: Trace4Layers = Trace4Layers::from_config(reg.clone(), config)?; Ok(Self::from_layers(reg, layers)) } /// Builds `Self` from `Layers` and the backing `Reg`. - fn from_layers(broker: Reg, layers: Layers) -> Handle + fn from_layers(registry: Reg, layers: Trace4Layers) -> Handle where Reg: Subscriber + Send + Sync, - // Arc, Reg>>: Layer, { let (reloadable, reload_handle) = reload::Layer::new(layers); - let root_subscriber = broker.clone(); + let root_subscriber = registry.clone(); let trace_logger = TraceLogger::new(root_subscriber.clone(), reloadable); Handle { diff --git a/trace4rs/src/handle/trace_logger.rs b/trace4rs/src/handle/trace_logger.rs index 68cb353..4b6ab91 100644 --- a/trace4rs/src/handle/trace_logger.rs +++ b/trace4rs/src/handle/trace_logger.rs @@ -1,21 +1,25 @@ use std::sync::Arc; use tracing::{span, Event, Subscriber}; -use tracing_subscriber::{layer::Layered, prelude::*, reload, Registry}; +use tracing_subscriber::{layer::Layered, prelude::*, registry::LookupSpan, reload, Registry}; -use crate::handle::Layers; +use crate::handle::Trace4Layers; + +use super::shared_registry::SharedRegistry; /// The `tracing::Subscriber` that this crate implements. #[derive(Clone)] -pub struct TraceLogger { - inner: Arc, Reg>, Reg>>, +pub struct TraceLogger { + inner: Arc, Reg>, Reg>>, } impl TraceLogger { - pub(crate) fn new(broker: Reg, layers: reload::Layer, Reg>) -> TraceLogger + pub(crate) fn new( + broker: Reg, + layers: reload::Layer, Reg>, + ) -> TraceLogger where - Reg: Subscriber + Clone, - // Arc, Reg>>: tracing_subscriber::layer::Layer, + Reg: Subscriber + Clone + for<'a> LookupSpan<'a>, { let inner = Arc::new(broker.with(layers)); TraceLogger { inner } @@ -26,8 +30,7 @@ impl TraceLogger { impl Subscriber for TraceLogger where - Reg: Subscriber + Clone, - // reload::Layer, Reg>: tracing_subscriber::Layer, + Reg: Subscriber + Clone + for<'a> LookupSpan<'a>, { fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool { Subscriber::enabled(&self.inner, metadata) From 776c913fce8412da446ad7c5e090afd5847bc6fd Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Fri, 17 Nov 2023 12:01:20 -0800 Subject: [PATCH 03/23] clippy --- .cargo/config.toml | 29 --------- Cargo.toml | 59 +++++++++++++++++ README.md => readme.md | 6 ++ trace4rs-config/Cargo.toml | 16 +++-- trace4rs-config/src/config.rs | 83 +++++++++--------------- trace4rs-config/src/error.rs | 3 +- trace4rs-fmtorp/Cargo.toml | 14 +++- trace4rs-fmtorp/src/lib.rs | 22 +++---- trace4rs/Cargo.toml | 16 +++-- trace4rs/src/appenders/rolling.rs | 52 +++++---------- trace4rs/src/handle/layers.rs | 69 +++++++++++++------- trace4rs/src/handle/loggers.rs | 16 ++--- trace4rs/src/handle/mod.rs | 90 ++++++++------------------ trace4rs/src/handle/shared_registry.rs | 29 ++------- trace4rs/src/handle/trace_logger.rs | 14 ++-- 15 files changed, 246 insertions(+), 272 deletions(-) rename README.md => readme.md (67%) diff --git a/.cargo/config.toml b/.cargo/config.toml index 0212178..c91c3f3 100644 --- a/.cargo/config.toml +++ b/.cargo/config.toml @@ -1,31 +1,2 @@ [net] git-fetch-with-cli = true - -[target.'cfg(all())'] -rustflags = [ - "-Wclippy::all", # correctness, sus, style, complexity, perf - "-Wclippy::pedantic", - "-Wclippy::cargo", - "-Wclippy::restriction", - "-Aclippy::missing_docs_in_private_items", # pub docs should be fine - "-Aclippy::as_conversions", # not-recommended, covered by other lints - "-Aclippy::missing_inline_in_public_items", # we're using lto, so obviated - "-Aclippy::cargo_common_metadata", # these are internal crates - "-Aclippy::exhaustive_structs", # .. - "-Aclippy::exhaustive_enums", # .. - "-Aclippy::implicit_return", # non-std style - "-Aclippy::else-if-without-else", # .. - "-Aclippy::self-named-module-files", # .. - "-Aclippy::default_trait_access", # .. - "-Aclippy::pattern_type_mismatch", # .. - "-Aclippy::mod_module_files", # .. - "-Aclippy::if_then_some_else_none", # .. - "-Aclippy::str_to_string", # rustc suggests `.to_string()`, so non-std style - "-Aclippy::shadow_reuse", # I feel this can actually be great - "-Aclippy::multiple_crate_versions", # This isnt something we have much control over - "-Aclippy::must_use_candidate", # really noisy - "-Aclippy::default_numeric_fallback", # should be allowed with '0'. - "-Aclippy::module_name_repetitions", # I found this impractical - "-Aclippy::implicit_hasher", # Adds a lot of complication only a bit of generalization - "-Aclippy::pub_use", -] diff --git a/Cargo.toml b/Cargo.toml index 5ccc424..f455a14 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,3 +1,62 @@ [workspace] resolver = "1" members = ["trace4rs", "trace4rs-config", "trace4rs-fmtorp"] + +[workspace.package] +version = "0.5.1" +authors = [ + "Evan Simmons ", + "Everett Pompeii ", + "Richard Meester ", +] +edition = "2021" +license = "MIT" +keywords = ["tracing", "logging", "log4rs"] +repository = "https://github.com/imperva/trace4rs" +readme = "readme.md" +categories = ["development-tools"] + +[workspace.lints.clippy] +all = "warn" # correctness, sus, style, complexity, perf +pedantic = "warn" +cargo = "warn" +absolute_paths = "warn" +assertions_on_result_states = "warn" +arithmetic_side_effects = "warn" +create_dir = "warn" +deref_by_slicing = "warn" +empty_drop = "warn" +empty_structs_with_brackets = "warn" +filetype_is_file = "warn" +format_push_string = "warn" +indexing_slicing = "warn" +lossy_float_literal = "warn" +mem_forget = "warn" # Use ManuallyDrop +missing_assert_message = "warn" +missing_asserts_for_indexing = "warn" +multiple_inherent_impl = "warn" +mutex_atomic = "warn" +needless_raw_strings = "warn" +panic_in_result_fn = "warn" +partial_pub_fields = "warn" +pub_without_shorthand = "warn" +rc_buffer = "warn" +rc_mutex = "warn" +redundant_type_annotations = "warn" +self_named_module_files = "warn" +semicolon_outside_block = "warn" +shadow_unrelated = "warn" +string_lit_chars_any = "warn" +string_slice = "warn" +tests_outside_test_module = "warn" +undocumented_unsafe_blocks = "warn" +unnecessary_self_imports = "warn" +unneeded_field_pattern = "warn" +unseparated_literal_suffix = "warn" +unwrap_in_result = "warn" +unwrap_used = "warn" +verbose_file_reads = "warn" + +# Enable when stabilized +# allow_attributes = "warn" +# allow_attributes_without_reason = "warn" diff --git a/README.md b/readme.md similarity index 67% rename from README.md rename to readme.md index 619a4c2..2b9ff93 100644 --- a/README.md +++ b/readme.md @@ -14,3 +14,9 @@ The takeaway is that the actual appenders are roughly equivalent in performance. However, when using the `tracing` macros vs the `log` macros the appender performance is roughly 2 orders of magnitude larger. See for yourself with `cargo bench --features tracing-macros` + + +## Todo + +- [ ] Allow for generic "Layers" which can be plugged from tracing ecosystem + - The reason for this is that we have parts of the ecosystem that don't use FormatEvent, we will therefore need to come up with a mechanism to use them which is outside that. diff --git a/trace4rs-config/Cargo.toml b/trace4rs-config/Cargo.toml index 1083036..d11aa1d 100644 --- a/trace4rs-config/Cargo.toml +++ b/trace4rs-config/Cargo.toml @@ -1,11 +1,17 @@ [package] name = "trace4rs-config" -version = "0.5.1" -edition = "2021" description = "trace4rs configuration" -keywords = ["tracing", "logging", "log4rs"] -authors = ["Evan Simmons", "Everett Pompeii", "Richard Meester"] -license = "MIT" +version.workspace = true +edition.workspace = true +license.workspace = true +authors.workspace = true +keywords.workspace = true +repository.workspace = true +readme.workspace = true +categories.workspace = true + +[lints] +workspace = true [features] in-order-serialization = ["serde"] diff --git a/trace4rs-config/src/config.rs b/trace4rs-config/src/config.rs index 8886cd6..4c5ac1a 100644 --- a/trace4rs-config/src/config.rs +++ b/trace4rs-config/src/config.rs @@ -2,10 +2,7 @@ use std::{ borrow::Cow, - collections::{ - HashMap, - HashSet, - }, + collections::{HashMap, HashSet}, result, str::FromStr, }; @@ -13,18 +10,11 @@ use std::{ #[cfg(feature = "schemars")] use schemars::JsonSchema; #[cfg(feature = "serde")] -use serde::{ - Deserialize, - Deserializer, - Serialize, - Serializer, -}; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; use smart_default::SmartDefault; +use tracing::level_filters; -use crate::error::{ - Error, - Result, -}; +use crate::error::{Error, Result}; /// The root configuration object containing everything necessary to build a /// `trace4rs::Handle`. @@ -34,7 +24,7 @@ use crate::error::{ pub struct Config { /// The default logger, which must be configured. #[cfg_attr(feature = "serde", serde(rename = "root", alias = "default"))] - pub default: Logger, + pub default: Logger, /// Appenders are assigned an id of your choice and configure actual log /// message output. #[cfg_attr( @@ -48,7 +38,7 @@ pub struct Config { feature = "in-order-serialization", serde(serialize_with = "ordered_map") )] - pub loggers: HashMap, + pub loggers: HashMap, } /// # Errors @@ -88,18 +78,15 @@ impl Default for Config { impl Config { /// A configuration for `INFO` and above to be logged to stdout. fn console_config() -> Config { - use literally::{ - hmap, - hset, - }; + use literally::{hmap, hset}; Config { - default: Logger { - level: LevelFilter::INFO, + default: Logger { + level: LevelFilter::INFO, appenders: hset! { "stdout" }, - format: Format::default(), + format: Format::default(), }, - loggers: hmap! {}, + loggers: hmap! {}, appenders: hmap! { "stdout" => Appender::Console }, @@ -146,12 +133,12 @@ pub struct Logger { serde(serialize_with = "ordered_set") )] pub appenders: HashSet, - pub level: LevelFilter, + pub level: LevelFilter, #[cfg_attr( feature = "serde", serde(default = "Format::default", skip_serializing_if = "Format::is_normal") )] - pub format: Format, + pub format: Format, } #[cfg(feature = "serde")] @@ -261,10 +248,9 @@ impl Format { #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] #[cfg_attr(feature = "schemars", derive(JsonSchema), schemars(transparent))] pub struct LevelFilter( - #[cfg_attr(feature = "schemars", schemars(with = "String"))] - tracing::level_filters::LevelFilter, + #[cfg_attr(feature = "schemars", schemars(with = "String"))] level_filters::LevelFilter, ); -impl From for tracing::level_filters::LevelFilter { +impl From for level_filters::LevelFilter { fn from(l: LevelFilter) -> Self { l.0 } @@ -272,12 +258,12 @@ impl From for tracing::level_filters::LevelFilter { #[rustfmt::skip] // eas: retain order impl LevelFilter { - pub const TRACE: Self = LevelFilter(tracing::level_filters::LevelFilter::TRACE); - pub const DEBUG: Self = LevelFilter(tracing::level_filters::LevelFilter::DEBUG); - pub const INFO: Self = LevelFilter(tracing::level_filters::LevelFilter::INFO); - pub const WARN: Self = LevelFilter(tracing::level_filters::LevelFilter::WARN); - pub const ERROR: Self = LevelFilter(tracing::level_filters::LevelFilter::ERROR); - pub const OFF: Self = LevelFilter(tracing::level_filters::LevelFilter::OFF); + pub const TRACE: Self = LevelFilter(level_filters::LevelFilter::TRACE); + pub const DEBUG: Self = LevelFilter(level_filters::LevelFilter::DEBUG); + pub const INFO: Self = LevelFilter(level_filters::LevelFilter::INFO); + pub const WARN: Self = LevelFilter(level_filters::LevelFilter::WARN); + pub const ERROR: Self = LevelFilter(level_filters::LevelFilter::ERROR); + pub const OFF: Self = LevelFilter(level_filters::LevelFilter::OFF); #[must_use] pub const fn maximum() -> Self { Self::TRACE } @@ -305,7 +291,7 @@ impl<'de> Deserialize<'de> for LevelFilter { } } impl FromStr for LevelFilter { - type Err = ::Err; + type Err = ::Err; fn from_str(s: &str) -> result::Result { Ok(Self(FromStr::from_str(s)?)) @@ -327,7 +313,7 @@ pub enum Appender { path: String, }, RollingFile { - path: String, + path: String, #[cfg_attr(feature = "serde", serde(rename = "rolloverPolicy"))] policy: Policy, }, @@ -338,6 +324,7 @@ impl Appender { Self::File { path: path.into() } } + #[must_use] pub fn console() -> Self { Self::Console } @@ -408,10 +395,7 @@ impl Policy { Err(e) => return Err(e.into()), }; - let unit = match unit { - Some(u) => u, - None => return Ok(number), - }; + let Some(unit) = unit else { return Ok(number) }; let bytes_number = if unit.eq_ignore_ascii_case("b") { Some(number) @@ -438,18 +422,15 @@ impl Policy { mod test { use literally::hset; - use super::{ - LevelFilter, - Logger, - }; + use super::{LevelFilter, Logger}; use crate::config::Format; #[test] fn test_format_serde() { let lgr = Logger { appenders: hset! {}, - level: LevelFilter::OFF, - format: Format::Normal, + level: LevelFilter::OFF, + format: Format::Normal, }; let lgr_value = dbg!(serde_json::to_value(&lgr).unwrap()); assert!(lgr_value.get("format").is_none()); @@ -458,8 +439,8 @@ mod test { let lgr = Logger { appenders: hset! {}, - level: LevelFilter::OFF, - format: Format::MessageOnly, + level: LevelFilter::OFF, + format: Format::MessageOnly, }; let lgr_value = dbg!(serde_json::to_value(&lgr).unwrap()); let fmt = lgr_value.get("format").unwrap().as_str().unwrap(); @@ -469,8 +450,8 @@ mod test { let lgr = Logger { appenders: hset! {}, - level: LevelFilter::OFF, - format: Format::Custom("foobar".to_string()), + level: LevelFilter::OFF, + format: Format::Custom("foobar".to_string()), }; let lgr_value = dbg!(serde_json::to_value(&lgr).unwrap()); let fmt = lgr_value.get("format").unwrap().as_str().unwrap(); diff --git a/trace4rs-config/src/error.rs b/trace4rs-config/src/error.rs index 45fb67b..3516a58 100644 --- a/trace4rs-config/src/error.rs +++ b/trace4rs-config/src/error.rs @@ -1,7 +1,8 @@ use core::num::ParseIntError; +use std::result; /// A `trace4rs_config` Result. -pub type Result = std::result::Result; +pub type Result = result::Result; /// An enum representing the possible errors encountered. #[derive(Debug, thiserror::Error)] diff --git a/trace4rs-fmtorp/Cargo.toml b/trace4rs-fmtorp/Cargo.toml index 2cb912e..df71579 100644 --- a/trace4rs-fmtorp/Cargo.toml +++ b/trace4rs-fmtorp/Cargo.toml @@ -1,9 +1,17 @@ [package] name = "trace4rs-fmtorp" -version = "0.5.1" -edition = "2021" description = "Torpid formatting for trace4rs" -license = "MIT" +version.workspace = true +edition.workspace = true +license.workspace = true +authors.workspace = true +keywords.workspace = true +repository.workspace = true +readme.workspace = true +categories.workspace = true + +[lints] +workspace = true # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [features] diff --git a/trace4rs-fmtorp/src/lib.rs b/trace4rs-fmtorp/src/lib.rs index 28300e6..ab15dc3 100644 --- a/trace4rs-fmtorp/src/lib.rs +++ b/trace4rs-fmtorp/src/lib.rs @@ -1,10 +1,5 @@ -#![allow(clippy::single_char_lifetime_names)] use core::fmt; -use std::{ - borrow::Cow, - collections::HashSet, - ops::RangeInclusive, -}; +use std::{borrow::Cow, collections::HashSet, ops::RangeInclusive}; use tracing_subscriber::fmt::format; @@ -23,13 +18,13 @@ pub enum Error { #[derive(Debug)] pub struct Fmtr<'fmtstr> { /// The owned or static borrowed format string. - fmt_str: Cow<'fmtstr, str>, + fmt_str: Cow<'fmtstr, str>, /// The ranges indexing `fmt_str` which 1-1 index `ordered_fields`. /// # Invariants /// Ranges are strictly within bounds of fmt_str field_ranges: Vec>, /// The names of fields indexed identically to field_ranges. - field_names: Vec<&'static str>, + field_names: Vec<&'static str>, } impl<'fmtstr> Fmtr<'fmtstr> { /// Unrecognized fields should be an error @@ -57,14 +52,14 @@ impl<'fmtstr> Fmtr<'fmtstr> { } // end match if x == '}' { - #[allow(clippy::integer_arithmetic)] // no overflow potential + #[allow(clippy::arithmetic_side_effects)] // no overflow potential if strt + 1 == xi { return Err(Error::EmptyField); } field_ranges.push(strt..=xi); // safe since we know the slice is non-empty and xi in bounds // and no overflow potential - #[allow(clippy::indexing_slicing, clippy::integer_arithmetic)] + #[allow(clippy::indexing_slicing, clippy::arithmetic_side_effects)] let ff = &fmt_str[(strt + 1)..xi]; if let Some(f) = fields.get(ff) { field_names.push(*f); @@ -100,6 +95,7 @@ impl<'fmtstr> Fmtr<'fmtstr> { }) } + #[must_use] pub fn field_from_id(&self, i: usize) -> Option<&'static str> { self.field_names.get(i).copied() } @@ -110,9 +106,9 @@ impl<'fmtstr> Fmtr<'fmtstr> { /// # Panics /// Panics should only happen on bugs. #[allow(clippy::unwrap_in_result)] - pub fn write<'writer>( + pub fn write( &self, - mut writer: format::Writer<'writer>, + mut writer: format::Writer<'_>, value_writer: &impl FieldValueWriter, ) -> fmt::Result { let mut last = 0; @@ -130,7 +126,7 @@ impl<'fmtstr> Fmtr<'fmtstr> { value_writer.write_value(writer.by_ref(), field)?; // last may run off the end if last range - #[allow(clippy::integer_arithmetic)] + #[allow(clippy::arithmetic_side_effects)] { last = range.end() + 1; } diff --git a/trace4rs/Cargo.toml b/trace4rs/Cargo.toml index 814949e..bcb6232 100644 --- a/trace4rs/Cargo.toml +++ b/trace4rs/Cargo.toml @@ -1,11 +1,17 @@ [package] name = "trace4rs" -version = "0.5.1" -edition = "2021" description = "log4rs like usability with the `tracing` crate as the base" -keywords = ["tracing", "logging", "log4rs"] -authors = ["Evan Simmons", "Everett Pompeii", "Richard Meester"] -license = "MIT" +version.workspace = true +edition.workspace = true +license.workspace = true +authors.workspace = true +keywords.workspace = true +repository.workspace = true +readme.workspace = true +categories.workspace = true + +[lints] +workspace = true [features] tracing-macros = [] # internal, for benches diff --git a/trace4rs/src/appenders/rolling.rs b/trace4rs/src/appenders/rolling.rs index 44f50f7..1bfeae8 100644 --- a/trace4rs/src/appenders/rolling.rs +++ b/trace4rs/src/appenders/rolling.rs @@ -1,23 +1,13 @@ use std::{ fs, - io::{ - self, - LineWriter, - Write, - }, + io::{self, LineWriter, Write}, }; -use camino::{ - Utf8Path, - Utf8PathBuf, -}; +use camino::{Utf8Path, Utf8PathBuf}; use crate::{ env::try_expand_env_vars, - error::{ - Error, - Result, - }, + error::{Error, Result}, }; /// `LogFileMeta` allows us to keep track of an estimated length for a given @@ -68,8 +58,8 @@ impl Trigger { #[derive(Clone)] pub struct FixedWindow { /// invariant last < count - last: Option, - count: usize, + last: Option, + count: usize, pattern: String, } impl FixedWindow { @@ -96,25 +86,13 @@ impl FixedWindow { fn roll(&mut self, path: &Utf8Path) -> io::Result<()> { // if None, we just need to roll to zero, which happens after this block - // see todo below - // 'outer: { - { + 'outer: { if let Some(mut c) = self.last { // holding max rolls, saturation should be fine if c.saturating_add(1) == self.count { - // if Some(0) and 1 = self.count we skip if c == 0 { - // todo: uncomment the following break and delete everything - // after it in block once we can use `feature(label_break_value)` - - // break 'outer; - self.inc_last(); - - let new_path = self - .pattern - .replace(Self::INDEX_TOKEN, &Self::COUNT_BASE.to_string()); - - return fs::rename(path, new_path); + // if self.last = Some(0) and self.count = 1: skip + break 'outer; } // We skip the last file if we're at the max so it'll get overwritten. c = c.saturating_sub(1); @@ -186,13 +164,13 @@ impl Roller { /// An appender which writes to a file and manages rolling said file, either to /// backups or by deletion. pub struct RollingFile { - path: Utf8PathBuf, + path: Utf8PathBuf, /// Writer will always be some except when it is being rolled or if there /// was an error initing a new writer after abandonment of the previous. - writer: Option>, - meta: LogFileMeta, + writer: Option>, + meta: LogFileMeta, trigger: Trigger, - roller: Roller, + roller: Roller, } impl RollingFile { const DEFAULT_FILE_NAME: &'static str = "log"; @@ -211,14 +189,14 @@ impl RollingFile { let expanded_path = try_expand_env_vars(p.as_ref()); let (writer, meta) = { let writer = Self::new_writer(&expanded_path).map_err(|e| Error::CreateFailed { - path: expanded_path.clone().into_owned(), + path: expanded_path.clone().into_owned(), source: e, })?; let meta = writer .get_ref() .metadata() .map_err(|e| Error::MetadataFailed { - path: expanded_path.clone().into_owned(), + path: expanded_path.clone().into_owned(), source: e, })?; (writer, LogFileMeta::from_meta(&meta)) @@ -288,7 +266,7 @@ impl RollingFile { /// pattern: "{filename}.{}". /// /// ```ignore - /// + /// /// make_qualified_pattern(Path::from("./foo/bar.log"), None); // -> "./foo/bar.log.{}" /// make_qualified_pattern(Path::from("./foo/bar.log"), Some("bar_roll.{}")); // -> "./foo/bar_roll.{}" /// ``` diff --git a/trace4rs/src/handle/layers.rs b/trace4rs/src/handle/layers.rs index beb907f..700db16 100644 --- a/trace4rs/src/handle/layers.rs +++ b/trace4rs/src/handle/layers.rs @@ -1,4 +1,4 @@ -use tracing::{metadata::LevelFilter, Event, Subscriber}; +use tracing::{metadata::LevelFilter, Event, Level, Subscriber}; use tracing_log::NormalizeEvent; use tracing_subscriber::{ fmt::{format::DefaultFields, writer::BoxMakeWriter, Layer as FmtLayer}, @@ -17,26 +17,16 @@ use crate::{ error::Result, }; +type DynLayer = Box + Send + Sync>; + pub struct Trace4Layers { enabled: bool, default: Logger, loggers: Vec>, + extra: Vec + Send + Sync>>, appenders: Appenders, } -impl Clone for Trace4Layers -where - Logger: Clone, -{ - fn clone(&self) -> Self { - Self { - enabled: self.enabled, - default: self.default.clone(), - loggers: self.loggers.clone(), - appenders: self.appenders.clone(), - } - } -} impl Trace4Layers { /// If the files which are the target of appenders have been moved we /// abandon the moved files and remount at the correct path. @@ -52,23 +42,23 @@ impl Trace4Layers { impl Trace4Layers { /// The default `Layers` backed by `broker` (`INFO` and above goes to /// stdout). - pub fn default(registry: Reg) -> Trace4Layers + pub fn default() -> Trace4Layers where - Reg: Subscriber + Send + Sync + for<'b> LookupSpan<'b>, + Reg: Layer + Subscriber + Send + Sync + for<'s> LookupSpan<'s>, Logger: Layer, { let stdout_appender = AppenderId("stdout".to_string()); let appenders = Appenders::new(literally::hmap! {stdout_appender.clone() => Appender::new_console()}); let default = Logger::new( - registry, LevelFilter::INFO, None, (&[stdout_appender]).into_iter(), &appenders, EventFormatter::Normal, ); - Trace4Layers::new(default, vec![], appenders) + + Trace4Layers::new(default, vec![], appenders, Self::mk_extra()) } /// Create a new `Layers` from a default layer and a pre-generated vec of @@ -77,12 +67,14 @@ impl Trace4Layers { default: Logger, loggers: Vec>, appenders: Appenders, + extra: Vec>, ) -> Trace4Layers { Trace4Layers { enabled: true, default, loggers, appenders, + extra, } } @@ -90,9 +82,9 @@ impl Trace4Layers { /// /// # Errors /// An error may occur while building the appenders. - pub fn from_config(registry: Reg, config: &Config) -> Result> + pub fn from_config(config: &Config) -> Result> where - Reg: Clone + Subscriber + Send + Sync + for<'b> LookupSpan<'b>, + Reg: Layer + Subscriber + Send + Sync + for<'s> LookupSpan<'s>, Logger: Layer, { let appenders = (&config.appenders).try_into()?; @@ -101,7 +93,6 @@ impl Trace4Layers { .iter() .map(|(targ, lg)| { Logger::new( - registry.clone(), lg.level.into(), Some(targ.clone()), lg.appenders.iter(), @@ -112,7 +103,6 @@ impl Trace4Layers { .collect(); let default = Logger::new( - registry, config.default.level.into(), None, config.default.appenders.iter(), @@ -120,7 +110,33 @@ impl Trace4Layers { config.default.format.clone().into(), ); - Ok(Trace4Layers::new(default, layers, appenders)) + Ok(Trace4Layers::new( + default, + layers, + appenders, + Self::mk_extra(), + )) + } + fn mk_extra() -> Vec> + where + Reg: Layer + Subscriber + Send + Sync + for<'s> LookupSpan<'s>, + { + let layer = tracing_tree::HierarchicalLayer::default() + .with_indent_lines(true) + .with_indent_amount(2) + .with_thread_names(true) + .with_thread_ids(true) + .with_verbose_exit(true) + .with_verbose_entry(true) + .with_targets(true) + .with_higher_precision(true); + + let filter = tracing_subscriber::filter::targets::Targets::new() + .with_target("rasp_ffi", Level::TRACE); + + let filtered = layer.with_filter(filter); + + vec![Box::new(filtered) as DynLayer] } } @@ -138,7 +154,7 @@ impl Trace4Layers { impl Layer for Trace4Layers where - S: Subscriber + Clone, + S: Subscriber, FmtLayer: Layer, { fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) { @@ -158,6 +174,11 @@ where layer.on_event(event, ctx.clone()); } } + for layer in &self.extra { + if layer.enabled(metadata, ctx.clone()) { + layer.on_event(event, ctx.clone()); + } + } // If no other layer logged this then the default one will if !any && self.default.enabled(metadata, ctx.clone()) { self.default.on_event(event, ctx); diff --git a/trace4rs/src/handle/loggers.rs b/trace4rs/src/handle/loggers.rs index c1a7fed..9b63bae 100644 --- a/trace4rs/src/handle/loggers.rs +++ b/trace4rs/src/handle/loggers.rs @@ -13,10 +13,9 @@ use tracing_subscriber::{ writer::{BoxMakeWriter, MakeWriterExt}, FmtContext, FormatEvent, FormatFields, Layer as FmtLayer, }, - layer::{Context, Layered}, - prelude::__tracing_subscriber_SubscriberExt, + layer::Context, registry::LookupSpan, - Layer, Registry, + Layer, }; use crate::{ @@ -35,12 +34,11 @@ static NORMAL_FMT: Lazy> = pub struct Logger { level: LevelFilter, target: Option, - layer: Layered, Reg>, + layer: FmtLayer, } impl Logger { pub fn new<'a, Reg>( - r: Reg, level: LevelFilter, target: Option, ids: impl Iterator, @@ -55,8 +53,8 @@ impl Logger { Self::mk_writer(ids, appenders).unwrap_or_else(|| BoxMakeWriter::new(io::sink)); let fmt_layer = FmtLayer::default().event_format(format).with_ansi(false); - let append_layer = fmt_layer.with_writer(writer); - let layer = r.with(append_layer); + let layer = fmt_layer.with_writer(writer); + // let layer = r.with(append_layer); Logger { level, @@ -103,8 +101,8 @@ where Logger::is_enabled(self, meta) } - fn on_event(&self, event: &Event<'_>, _ctx: Context<'_, Sub>) { - self.layer.event(event); + fn on_event(&self, event: &Event<'_>, ctx: Context<'_, Sub>) { + self.layer.on_event(event, ctx); } } diff --git a/trace4rs/src/handle/mod.rs b/trace4rs/src/handle/mod.rs index 4988bde..5bda99e 100644 --- a/trace4rs/src/handle/mod.rs +++ b/trace4rs/src/handle/mod.rs @@ -1,5 +1,6 @@ -use std::convert::TryFrom; +use std::sync::Arc; +use derive_where::derive_where; use tracing::Subscriber; use tracing_subscriber::{ layer::{Layer, Layered}, @@ -8,10 +9,7 @@ use tracing_subscriber::{ }; use tracing_tree::HierarchicalLayer; -use crate::{ - config::Config, - error::{Error, Result}, -}; +use crate::{config::Config, error::Result}; mod layers; mod loggers; @@ -24,16 +22,13 @@ pub use trace_logger::TraceLogger; use self::loggers::Logger; -type DynHandle = Handle>; pub type StandardHandle = Handle; /// The reloadable handle for a `TraceLogger`, with this we can modify the /// logging configuration at runtime. -#[derive(Clone)] +#[derive_where(Clone)] pub struct Handle { - reload_handle: reload::Handle, Reg>, - trace_logger: TraceLogger, - root_subscriber: Reg, + reload_handle: Arc, Reg>>, } /// Initializes the default `trace4rs` handle as the `tracing` global default. @@ -41,35 +36,26 @@ pub struct Handle { /// # Errors /// We could fail to set the global default subscriber for `tracing`. pub fn init_console_logger() -> Result { - let h = Handle::default(); - tracing::subscriber::set_global_default(h.subscriber())?; + let (h, t) = Handle::new(); + tracing::subscriber::set_global_default(t)?; Ok(h) } pub type HierarchicalHandle = Handle>; impl Handle where - Reg: Default + Subscriber + Send + Sync + Clone + for<'b> LookupSpan<'b>, + Reg: Layer + Subscriber + Send + Sync + Default + for<'s> LookupSpan<'s>, Logger: Layer, { - pub fn new() -> Handle { - let registry = Reg::default(); - let layers = Trace4Layers::default(registry.clone()); - - Handle::::from_layers(registry, layers) + pub fn unit() -> Self { + let (handle, layer) = Handle::from_layers(Trace4Layers::default()); + handle } - // pub fn new_hierarchical(n: usize) -> HierarchicalHandle { - // let registry = Spanregistry::new_hierarchical(n); - // let layers = Layers::::default(registry.clone()); + pub fn new() -> (Handle, TraceLogger) { + let layers = Trace4Layers::default(); - // Handle::::from_layers(registry, layers) - // } - - /// Get the subscriber that backs this handle. - #[must_use] - pub fn subscriber(&self) -> TraceLogger { - self.trace_logger.clone() + Handle::from_layers(layers) } /// Disable the subscriber. @@ -123,8 +109,7 @@ where /// - Building the appenders in the config, for example /// opening a file for write. pub fn update(&mut self, config: &Config) -> Result<()> { - let broke_clone = self.root_subscriber.clone(); - let ls = Trace4Layers::from_config(broke_clone, config)?; + let ls = Trace4Layers::from_config(config)?; Ok(self.reload_handle.reload(ls)?) } @@ -133,50 +118,27 @@ where /// # Errors /// This could fail building the appenders in the config, for example /// opening a file for write. - pub fn from_config(reg: Reg, config: &Config) -> Result> + pub fn from_config(config: &Config) -> Result<(Handle, TraceLogger)> where - Reg: Subscriber + Send + Sync + Clone, + Reg: Subscriber + Send + Sync + for<'s> LookupSpan<'s>, { - let layers: Trace4Layers = Trace4Layers::from_config(reg.clone(), config)?; - Ok(Self::from_layers(reg, layers)) + let layers: Trace4Layers = Trace4Layers::from_config(config)?; + Ok(Self::from_layers(layers)) } /// Builds `Self` from `Layers` and the backing `Reg`. - fn from_layers(registry: Reg, layers: Trace4Layers) -> Handle + fn from_layers(layers: Trace4Layers) -> (Handle, TraceLogger) where Reg: Subscriber + Send + Sync, { let (reloadable, reload_handle) = reload::Layer::new(layers); - let root_subscriber = registry.clone(); - let trace_logger = TraceLogger::new(root_subscriber.clone(), reloadable); + let trace_logger = TraceLogger::new(Reg::default(), reloadable); - Handle { - reload_handle, + ( + Handle { + reload_handle: Arc::new(reload_handle), + }, trace_logger, - root_subscriber, - } - } -} - -impl Default for Handle { - fn default() -> Self { - Self::new() - } -} - -impl TryFrom for Handle { - type Error = Error; - - fn try_from(c: Config) -> Result { - Self::try_from(&c) - } -} - -impl TryFrom<&Config> for Handle { - type Error = Error; - - fn try_from(c: &Config) -> Result { - let reg = SharedRegistry::default(); - Handle::from_config(reg, c) + ) } } diff --git a/trace4rs/src/handle/shared_registry.rs b/trace4rs/src/handle/shared_registry.rs index d4a2edb..f5ece2e 100644 --- a/trace4rs/src/handle/shared_registry.rs +++ b/trace4rs/src/handle/shared_registry.rs @@ -1,7 +1,5 @@ #![allow(clippy::single_char_lifetime_names)] -use std::sync::Arc; - use derive_where::derive_where; use tracing::{span, Event, Subscriber}; use tracing_subscriber::{ @@ -9,42 +7,24 @@ use tracing_subscriber::{ Registry, }; -type DynRegistry = SharedRegistry>; +// type DynRegistry = SharedRegistry>; /// SharedRegistry exists because we need to be able to override the layer functionality. /// Also we would otherwise need to wrap a registry in an arc to share it as much as we do. /// #[derive(Debug)] -#[derive_where(Clone)] #[derive_where(Default; Reg: Default)] pub struct SharedRegistry { - inner: Arc, + inner: Reg, } impl SharedRegistry { pub fn new() -> Self { SharedRegistry { - inner: Arc::new(tracing_subscriber::registry()), + inner: tracing_subscriber::registry(), } } - - // pub fn new_hierarchical(n: usize) -> HierarchicalBroker { - // use tracing_subscriber::layer::SubscriberExt; - - // let hier = HierarchicalLayer::new(n).with_writer(Self::open_metrics()); - // let reg = tracing_subscriber::registry().with(hier); - // SpanBroker { - // inner: Arc::new(reg), - // } - // } } -// pub type HierarchicalBroker = -// SharedRegistry>, Registry>>; -// impl Default for HierarchicalBroker { -// fn default() -> Self { -// SharedRegistry::new_hierarchical(2) -// } -// } impl tracing_subscriber::Layer for SharedRegistry {} @@ -59,6 +39,9 @@ where fn span_data(&'a self, id: &tracing::Id) -> Option { self.inner.span_data(id) } + fn register_filter(&mut self) -> tracing_subscriber::filter::FilterId { + self.inner.register_filter() + } } impl Subscriber for SharedRegistry diff --git a/trace4rs/src/handle/trace_logger.rs b/trace4rs/src/handle/trace_logger.rs index 4b6ab91..3e4c547 100644 --- a/trace4rs/src/handle/trace_logger.rs +++ b/trace4rs/src/handle/trace_logger.rs @@ -1,27 +1,25 @@ -use std::sync::Arc; - use tracing::{span, Event, Subscriber}; -use tracing_subscriber::{layer::Layered, prelude::*, registry::LookupSpan, reload, Registry}; +use tracing_subscriber::{layer::Layered, prelude::*, registry::LookupSpan, reload}; use crate::handle::Trace4Layers; use super::shared_registry::SharedRegistry; /// The `tracing::Subscriber` that this crate implements. -#[derive(Clone)] pub struct TraceLogger { - inner: Arc, Reg>, Reg>>, + inner: Layered, Reg>, Reg>, } +// TODO(eas): extract `extra` from Trace4Layers to this level impl TraceLogger { pub(crate) fn new( broker: Reg, layers: reload::Layer, Reg>, ) -> TraceLogger where - Reg: Subscriber + Clone + for<'a> LookupSpan<'a>, + Reg: Subscriber + for<'a> LookupSpan<'a>, { - let inner = Arc::new(broker.with(layers)); + let inner = broker.with(layers); TraceLogger { inner } } } @@ -30,7 +28,7 @@ impl TraceLogger { impl Subscriber for TraceLogger where - Reg: Subscriber + Clone + for<'a> LookupSpan<'a>, + Reg: Subscriber + for<'a> LookupSpan<'a>, { fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool { Subscriber::enabled(&self.inner, metadata) From 6ae7a009d19bcf2711349210ff555d6dd9a25158 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Fri, 17 Nov 2023 13:12:47 -0800 Subject: [PATCH 04/23] clippy --- Cargo.toml | 4 ++- trace4rs-config/Cargo.toml | 1 - trace4rs-config/src/config.rs | 18 ++++++------ trace4rs/Cargo.toml | 10 +++---- trace4rs/src/appenders/mod.rs | 43 +++++++++-------------------- trace4rs/src/appenders/rolling.rs | 12 ++++---- trace4rs/src/appenders/test.rs | 35 ++++++----------------- trace4rs/src/env/mod.rs | 2 +- trace4rs/src/handle/layers.rs | 29 ++++++++----------- trace4rs/src/handle/loggers.rs | 6 ++-- trace4rs/src/handle/mod.rs | 32 +++++++++------------ trace4rs/src/handle/trace_logger.rs | 6 ++-- trace4rs/src/lib.rs | 2 +- 13 files changed, 79 insertions(+), 121 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index f455a14..d73d7d9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -20,7 +20,6 @@ categories = ["development-tools"] all = "warn" # correctness, sus, style, complexity, perf pedantic = "warn" cargo = "warn" -absolute_paths = "warn" assertions_on_result_states = "warn" arithmetic_side_effects = "warn" create_dir = "warn" @@ -60,3 +59,6 @@ verbose_file_reads = "warn" # Enable when stabilized # allow_attributes = "warn" # allow_attributes_without_reason = "warn" + +# Unsure of +# absolute_paths = "warn" diff --git a/trace4rs-config/Cargo.toml b/trace4rs-config/Cargo.toml index d11aa1d..0752b04 100644 --- a/trace4rs-config/Cargo.toml +++ b/trace4rs-config/Cargo.toml @@ -20,7 +20,6 @@ in-order-serialization = ["serde"] literally = "0.1.3" schemars = { version = "0.8.3", optional = true } serde = { version = "1.0.130", optional = true, features = ["derive"] } -smart-default = "0.6.0" thiserror = "1.0.29" tracing = "0.1.0" diff --git a/trace4rs-config/src/config.rs b/trace4rs-config/src/config.rs index 4c5ac1a..fffaec8 100644 --- a/trace4rs-config/src/config.rs +++ b/trace4rs-config/src/config.rs @@ -11,7 +11,6 @@ use std::{ use schemars::JsonSchema; #[cfg(feature = "serde")] use serde::{Deserialize, Deserializer, Serialize, Serializer}; -use smart_default::SmartDefault; use tracing::level_filters; use crate::error::{Error, Result}; @@ -44,14 +43,14 @@ pub struct Config { /// # Errors /// Returns an error if serialization fails #[cfg(feature = "in-order-serialization")] -pub fn ordered_map( - value: &HashMap, - serializer: S, -) -> std::result::Result +pub fn ordered_map( + value: &HashMap, + serializer: Ser, +) -> std::result::Result where K: Ord + Serialize, V: Serialize, - S: Serializer, + Ser: Serializer, { let ordered: std::collections::BTreeMap<_, _> = value.iter().collect(); ordered.serialize(serializer) @@ -60,7 +59,10 @@ where /// # Errors /// Returns an error if serialization fails #[cfg(feature = "in-order-serialization")] -pub fn ordered_set(value: &HashSet, serializer: S) -> std::result::Result +pub fn ordered_set( + value: &HashSet, + serializer: S, +) -> std::result::Result where K: Ord + Serialize, S: Serializer, @@ -216,7 +218,7 @@ mod format { } } -#[derive(PartialEq, Eq, Clone, Debug, SmartDefault)] +#[derive(PartialEq, Eq, Clone, Debug, Default)] #[cfg_attr( feature = "serde", derive(Serialize, Deserialize), diff --git a/trace4rs/Cargo.toml b/trace4rs/Cargo.toml index bcb6232..6d4c091 100644 --- a/trace4rs/Cargo.toml +++ b/trace4rs/Cargo.toml @@ -32,20 +32,20 @@ tracing-subscriber = { version = "0.3", features = [ "local-time", "registry", ] } -tracing-log = "0.1.2" -time = { version = "=0.3.20", features = ["formatting", "macros"] } +tracing-log = "0.2" +time = { version = "0.3", features = ["formatting", "macros"] } path-absolutize = "3.0.11" trace4rs-config = { version = "0.5.1", path = "../trace4rs-config" } trace4rs-fmtorp = { version = "0.5.1", path = "../trace4rs-fmtorp" } -utc-offset = "0.3.0" +# utc-offset = "0.3.0" +utc-offset = { git = "https://github.com/estk/utc_offset" } camino = "1.1.2" rustversion = "1.0.14" tracing-tree = { version = "0.3.0", features = ["time"] } -ambassador = "0.3.5" derive-where = "1.2.5" [dev-dependencies] -criterion = "0.4.0" +criterion = "0.5.0" criterion-macro = "0.4.0" literally = "0.1.3" log4rs = "1.0.0" diff --git a/trace4rs/src/appenders/mod.rs b/trace4rs/src/appenders/mod.rs index 21686cc..ac80810 100644 --- a/trace4rs/src/appenders/mod.rs +++ b/trace4rs/src/appenders/mod.rs @@ -2,40 +2,26 @@ use std::{ collections::HashMap, convert::TryFrom, - fs::{self,}, - io::{ - self, - LineWriter, - Write, - }, + fs::{self}, + io::{self, LineWriter, Write}, ops::Deref, path::Path, sync::Arc, }; -use camino::{ - Utf8Path, - Utf8PathBuf, -}; +use camino::{Utf8Path, Utf8PathBuf}; use parking_lot::Mutex; use path_absolutize::Absolutize; use tracing_subscriber::fmt::MakeWriter; use crate::{ - config::{ - self, - AppenderId, - Policy, - }, + config::{self, AppenderId, Policy}, env::try_expand_env_vars, - error::{ - Error, - Result, - }, + error::{Error, Result}, }; mod rolling; -use rolling::RollingFile; +use rolling::Rolling; #[cfg(test)] mod test; @@ -84,7 +70,7 @@ impl Deref for Appenders { type Target = AppenderMap; fn deref(&self) -> &Self::Target { - &*self.appenders + &self.appenders } } impl TryFrom<&HashMap> for Appenders { @@ -133,7 +119,7 @@ pub enum Appender { /// A file appender. File(Arc>), /// A file appender which rolls files. - RollingFile(Arc>), + RollingFile(Arc>), /// Logs are ignored Null, } @@ -169,10 +155,7 @@ impl Appender { count: usize, size: &str, ) -> Result { - use rolling::{ - Roller, - Trigger, - }; + use rolling::{Roller, Trigger}; let abs_path = { let ps = path_str.as_ref(); let cp = Utf8Path::new(ps); @@ -184,7 +167,7 @@ impl Appender { .unwrap_or_else(|| cp.to_path_buf()) .to_path_buf() }; - let pattern = RollingFile::make_qualified_pattern(&abs_path, pattern_opt); + let pattern = Rolling::make_qualified_pattern(&abs_path, pattern_opt); let trigger = Trigger::Size { limit: config::Policy::calculate_maximum_file_size(size)?, @@ -194,7 +177,7 @@ impl Appender { } else { Roller::new_fixed(pattern, count) }; - Ok(Self::RollingFile(Arc::new(Mutex::new(RollingFile::new( + Ok(Self::RollingFile(Arc::new(Mutex::new(Rolling::new( abs_path, trigger, roller, )?)))) } @@ -281,7 +264,7 @@ impl io::Write for Appender { pub struct Console; impl Console { pub fn new() -> Self { - Self::default() + Self } } impl io::Write for Console { @@ -296,7 +279,7 @@ impl io::Write for Console { /// An appender which writes to a file. pub struct File { - path: Utf8PathBuf, + path: Utf8PathBuf, writer: LineWriter, } impl File { diff --git a/trace4rs/src/appenders/rolling.rs b/trace4rs/src/appenders/rolling.rs index 1bfeae8..ec65a65 100644 --- a/trace4rs/src/appenders/rolling.rs +++ b/trace4rs/src/appenders/rolling.rs @@ -1,5 +1,5 @@ use std::{ - fs, + cmp, fs, io::{self, LineWriter, Write}, }; @@ -98,7 +98,7 @@ impl FixedWindow { c = c.saturating_sub(1); } - while c > 0 && c > Self::COUNT_BASE { + while c > cmp::max(0, Self::COUNT_BASE) { Self::pattern_roll(&self.pattern, c, c.saturating_add(1))?; c = c.saturating_sub(1); } @@ -156,14 +156,14 @@ impl Roller { }, Self::Delete => fs::remove_file(path)?, } - writer.replace(RollingFile::new_writer(path)?); + writer.replace(Rolling::new_writer(path)?); Ok(()) } } /// An appender which writes to a file and manages rolling said file, either to /// backups or by deletion. -pub struct RollingFile { +pub struct Rolling { path: Utf8PathBuf, /// Writer will always be some except when it is being rolled or if there /// was an error initing a new writer after abandonment of the previous. @@ -172,7 +172,7 @@ pub struct RollingFile { trigger: Trigger, roller: Roller, } -impl RollingFile { +impl Rolling { const DEFAULT_FILE_NAME: &'static str = "log"; const DEFAULT_ROLL_PATTERN: &'static str = "{filename}.{}"; const FILE_NAME_TOKEN: &'static str = "{filename}"; @@ -310,7 +310,7 @@ impl RollingFile { } } -impl io::Write for RollingFile { +impl io::Write for Rolling { fn write(&mut self, buf: &[u8]) -> io::Result { if let Some(w) = &mut self.writer { let bs_written = w.write(buf)?; diff --git a/trace4rs/src/appenders/test.rs b/trace4rs/src/appenders/test.rs index 86a8d8a..cb2a873 100644 --- a/trace4rs/src/appenders/test.rs +++ b/trace4rs/src/appenders/test.rs @@ -1,27 +1,10 @@ -use std::{ - fs, - io::Write, - path::Component, - sync::Arc, -}; - -use camino::{ - Utf8Component, - Utf8Path, - Utf8PathBuf, -}; +use std::{fs, io::Write, path::Component, sync::Arc}; + +use camino::{Utf8Component, Utf8Path, Utf8PathBuf}; use parking_lot::Mutex; -use super::rolling::{ - self, - Roller, - RollingFile, - Trigger, -}; -use crate::{ - appenders::rolling::FixedWindow, - Appender, -}; +use super::rolling::{self, Roller, Rolling, Trigger}; +use crate::{appenders::rolling::FixedWindow, Appender}; fn get_appender(path: &Utf8Path, pattern: &Option) -> Appender { Appender::new_rolling(path.as_str(), pattern.as_deref(), 2, "10 B").unwrap() @@ -145,7 +128,7 @@ fn correct_paths() { let trigger = Trigger::Size { limit: 10 }; let roller = Roller::Delete; let mut appender = Appender::RollingFile(Arc::new(Mutex::new( - RollingFile::new(path.to_str().unwrap(), trigger, roller).unwrap(), + Rolling::new(path.to_str().unwrap(), trigger, roller).unwrap(), ))); // sanity check/add some bytes to the file @@ -181,7 +164,7 @@ fn size_delete_roll() { let roller = Roller::Delete; let mut appender = Appender::RollingFile(Arc::new(Mutex::new( - RollingFile::new(path.to_str().unwrap(), trigger, roller).unwrap(), + Rolling::new(path.to_str().unwrap(), trigger, roller).unwrap(), ))); let buf1 = "123456789".to_string(); appender.write_all(buf1.as_bytes()).unwrap(); @@ -215,7 +198,7 @@ fn size_window_roll() { fn size_window_roll_no_pattern() { let tmpdir = tempfile::tempdir().unwrap(); let path = Utf8Path::from_path(tmpdir.path()).unwrap().join("foo.log"); - let pattern = rolling::RollingFile::make_qualified_pattern(&path, None); + let pattern = rolling::Rolling::make_qualified_pattern(&path, None); let appender = get_appender(&path, &None); window_roll(&path, pattern, appender); } @@ -235,7 +218,7 @@ fn size_window_roll_no_pattern_relative() { let tmpdir = tempfile::tempdir().unwrap(); let path = Utf8Path::from_path(tmpdir.path()).unwrap().join("foo.log"); let rel_path = as_rel_path(&path); - let pattern = rolling::RollingFile::make_qualified_pattern(&path, None); + let pattern = rolling::Rolling::make_qualified_pattern(&path, None); let appender = get_appender(&rel_path, &None); window_roll(&path, pattern, appender); } diff --git a/trace4rs/src/env/mod.rs b/trace4rs/src/env/mod.rs index 01778eb..0b516ae 100644 --- a/trace4rs/src/env/mod.rs +++ b/trace4rs/src/env/mod.rs @@ -11,7 +11,7 @@ mod test; #[allow(clippy::unwrap_used)] // ok since its a lit and tests hit this. static RE: once_cell::sync::Lazy = - once_cell::sync::Lazy::new(|| regex::Regex::new(r#"\$ENV\{([\w][\w|\d|\.|_]*)\}"#).unwrap()); + once_cell::sync::Lazy::new(|| regex::Regex::new(r"\$ENV\{([\w][\w|\d|\.|_]*)\}").unwrap()); pub(crate) fn expand_env_vars(path: &str) -> Cow { RE.replace_all(path, |c: &Captures| { diff --git a/trace4rs/src/handle/layers.rs b/trace4rs/src/handle/layers.rs index 700db16..d607756 100644 --- a/trace4rs/src/handle/layers.rs +++ b/trace4rs/src/handle/layers.rs @@ -19,7 +19,7 @@ use crate::{ type DynLayer = Box + Send + Sync>; -pub struct Trace4Layers { +pub struct T4Layer { enabled: bool, default: Logger, loggers: Vec>, @@ -27,7 +27,7 @@ pub struct Trace4Layers { appenders: Appenders, } -impl Trace4Layers { +impl T4Layer { /// If the files which are the target of appenders have been moved we /// abandon the moved files and remount at the correct path. pub fn correct_appender_paths(&self) -> Result<()> { @@ -39,10 +39,10 @@ impl Trace4Layers { } } -impl Trace4Layers { +impl T4Layer { /// The default `Layers` backed by `broker` (`INFO` and above goes to /// stdout). - pub fn default() -> Trace4Layers + pub fn default() -> T4Layer where Reg: Layer + Subscriber + Send + Sync + for<'s> LookupSpan<'s>, Logger: Layer, @@ -53,12 +53,12 @@ impl Trace4Layers { let default = Logger::new( LevelFilter::INFO, None, - (&[stdout_appender]).into_iter(), + [stdout_appender].iter(), &appenders, EventFormatter::Normal, ); - Trace4Layers::new(default, vec![], appenders, Self::mk_extra()) + T4Layer::new(default, vec![], appenders, Self::mk_extra()) } /// Create a new `Layers` from a default layer and a pre-generated vec of @@ -68,8 +68,8 @@ impl Trace4Layers { loggers: Vec>, appenders: Appenders, extra: Vec>, - ) -> Trace4Layers { - Trace4Layers { + ) -> T4Layer { + T4Layer { enabled: true, default, loggers, @@ -82,7 +82,7 @@ impl Trace4Layers { /// /// # Errors /// An error may occur while building the appenders. - pub fn from_config(config: &Config) -> Result> + pub fn from_config(config: &Config) -> Result> where Reg: Layer + Subscriber + Send + Sync + for<'s> LookupSpan<'s>, Logger: Layer, @@ -110,12 +110,7 @@ impl Trace4Layers { config.default.format.clone().into(), ); - Ok(Trace4Layers::new( - default, - layers, - appenders, - Self::mk_extra(), - )) + Ok(T4Layer::new(default, layers, appenders, Self::mk_extra())) } fn mk_extra() -> Vec> where @@ -140,7 +135,7 @@ impl Trace4Layers { } } -impl Trace4Layers { +impl T4Layer { /// Disable this subscriber. pub fn disable(&mut self) { self.enabled = false; @@ -152,7 +147,7 @@ impl Trace4Layers { } } -impl Layer for Trace4Layers +impl Layer for T4Layer where S: Subscriber, FmtLayer: Layer, diff --git a/trace4rs/src/handle/loggers.rs b/trace4rs/src/handle/loggers.rs index 9b63bae..6d131e5 100644 --- a/trace4rs/src/handle/loggers.rs +++ b/trace4rs/src/handle/loggers.rs @@ -141,7 +141,7 @@ impl From for EventFormatter { } } -impl<'w, 'ctx, 'evt, S> FormatEvent for EventFormatter +impl FormatEvent for EventFormatter where S: Subscriber + for<'b> LookupSpan<'b>, { @@ -287,9 +287,9 @@ impl<'w> Visit for SingleFieldVisitor<'w> { #[allow(unused_must_use, clippy::use_debug)] if field.name() == self.field_name { if self.newline { - writeln!(self.writer, "{:?}", value); + writeln!(self.writer, "{value:?}"); } else { - write!(self.writer, "{:?}", value); + write!(self.writer, "{value:?}"); } } } diff --git a/trace4rs/src/handle/mod.rs b/trace4rs/src/handle/mod.rs index 5bda99e..7dc4234 100644 --- a/trace4rs/src/handle/mod.rs +++ b/trace4rs/src/handle/mod.rs @@ -2,12 +2,7 @@ use std::sync::Arc; use derive_where::derive_where; use tracing::Subscriber; -use tracing_subscriber::{ - layer::{Layer, Layered}, - registry::LookupSpan, - reload, -}; -use tracing_tree::HierarchicalLayer; +use tracing_subscriber::{layer::Layer, registry::LookupSpan, reload}; use crate::{config::Config, error::Result}; @@ -16,19 +11,17 @@ mod loggers; mod shared_registry; mod trace_logger; -use layers::Trace4Layers; +use layers::T4Layer; use shared_registry::SharedRegistry; pub use trace_logger::TraceLogger; use self::loggers::Logger; -pub type StandardHandle = Handle; - /// The reloadable handle for a `TraceLogger`, with this we can modify the /// logging configuration at runtime. #[derive_where(Clone)] pub struct Handle { - reload_handle: Arc, Reg>>, + reload_handle: Arc, Reg>>, } /// Initializes the default `trace4rs` handle as the `tracing` global default. @@ -40,20 +33,21 @@ pub fn init_console_logger() -> Result { tracing::subscriber::set_global_default(t)?; Ok(h) } -pub type HierarchicalHandle = Handle>; impl Handle where Reg: Layer + Subscriber + Send + Sync + Default + for<'s> LookupSpan<'s>, Logger: Layer, { + #[must_use] pub fn unit() -> Self { - let (handle, layer) = Handle::from_layers(Trace4Layers::default()); + let (handle, _layer) = Handle::from_layers(T4Layer::default()); handle } + #[must_use] pub fn new() -> (Handle, TraceLogger) { - let layers = Trace4Layers::default(); + let layers = T4Layer::default(); Handle::from_layers(layers) } @@ -65,7 +59,7 @@ where /// - We were unable to update the subscriber. pub fn disable(&self) -> Result<()> { self.reload_handle - .modify(Trace4Layers::disable) + .modify(T4Layer::disable) .map_err(Into::into) } @@ -76,7 +70,7 @@ where /// - We were unable to update the subscriber. pub fn enable(&self) -> Result<()> { self.reload_handle - .modify(Trace4Layers::enable) + .modify(T4Layer::enable) .map_err(Into::into) } @@ -98,7 +92,7 @@ where /// - Re-mounting a file has failed. pub fn correct_appender_paths(&self) -> Result<()> { self.reload_handle - .with_current(Trace4Layers::correct_appender_paths)??; + .with_current(T4Layer::correct_appender_paths)??; Ok(()) } @@ -109,7 +103,7 @@ where /// - Building the appenders in the config, for example /// opening a file for write. pub fn update(&mut self, config: &Config) -> Result<()> { - let ls = Trace4Layers::from_config(config)?; + let ls = T4Layer::from_config(config)?; Ok(self.reload_handle.reload(ls)?) } @@ -122,12 +116,12 @@ where where Reg: Subscriber + Send + Sync + for<'s> LookupSpan<'s>, { - let layers: Trace4Layers = Trace4Layers::from_config(config)?; + let layers: T4Layer = T4Layer::from_config(config)?; Ok(Self::from_layers(layers)) } /// Builds `Self` from `Layers` and the backing `Reg`. - fn from_layers(layers: Trace4Layers) -> (Handle, TraceLogger) + fn from_layers(layers: T4Layer) -> (Handle, TraceLogger) where Reg: Subscriber + Send + Sync, { diff --git a/trace4rs/src/handle/trace_logger.rs b/trace4rs/src/handle/trace_logger.rs index 3e4c547..61b092e 100644 --- a/trace4rs/src/handle/trace_logger.rs +++ b/trace4rs/src/handle/trace_logger.rs @@ -1,20 +1,20 @@ use tracing::{span, Event, Subscriber}; use tracing_subscriber::{layer::Layered, prelude::*, registry::LookupSpan, reload}; -use crate::handle::Trace4Layers; +use crate::handle::T4Layer; use super::shared_registry::SharedRegistry; /// The `tracing::Subscriber` that this crate implements. pub struct TraceLogger { - inner: Layered, Reg>, Reg>, + inner: Layered, Reg>, Reg>, } // TODO(eas): extract `extra` from Trace4Layers to this level impl TraceLogger { pub(crate) fn new( broker: Reg, - layers: reload::Layer, Reg>, + layers: reload::Layer, Reg>, ) -> TraceLogger where Reg: Subscriber + for<'a> LookupSpan<'a>, diff --git a/trace4rs/src/lib.rs b/trace4rs/src/lib.rs index 583c56e..c426e97 100644 --- a/trace4rs/src/lib.rs +++ b/trace4rs/src/lib.rs @@ -22,5 +22,5 @@ pub mod error; mod test; pub use appenders::Appender; -pub use handle::{init_console_logger, Handle, HierarchicalHandle, StandardHandle, TraceLogger}; +pub use handle::{init_console_logger, Handle, TraceLogger}; pub use trace4rs_config::{config, config::Config, error::Error as ConfigError}; From dcf5b76470ca51c54cd24241b9ee0d966b58dd13 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Fri, 17 Nov 2023 14:18:38 -0800 Subject: [PATCH 05/23] save work --- trace4rs/src/handle/layers.rs | 37 +-------- trace4rs/src/handle/mod.rs | 14 ++-- trace4rs/src/handle/trace_logger.rs | 118 +++++++++++++++++++++++++--- 3 files changed, 116 insertions(+), 53 deletions(-) diff --git a/trace4rs/src/handle/layers.rs b/trace4rs/src/handle/layers.rs index d607756..ebba613 100644 --- a/trace4rs/src/handle/layers.rs +++ b/trace4rs/src/handle/layers.rs @@ -1,4 +1,4 @@ -use tracing::{metadata::LevelFilter, Event, Level, Subscriber}; +use tracing::{metadata::LevelFilter, Event, Subscriber}; use tracing_log::NormalizeEvent; use tracing_subscriber::{ fmt::{format::DefaultFields, writer::BoxMakeWriter, Layer as FmtLayer}, @@ -17,13 +17,10 @@ use crate::{ error::Result, }; -type DynLayer = Box + Send + Sync>; - pub struct T4Layer { enabled: bool, default: Logger, loggers: Vec>, - extra: Vec + Send + Sync>>, appenders: Appenders, } @@ -58,7 +55,7 @@ impl T4Layer { EventFormatter::Normal, ); - T4Layer::new(default, vec![], appenders, Self::mk_extra()) + T4Layer::new(default, vec![], appenders) } /// Create a new `Layers` from a default layer and a pre-generated vec of @@ -67,14 +64,12 @@ impl T4Layer { default: Logger, loggers: Vec>, appenders: Appenders, - extra: Vec>, ) -> T4Layer { T4Layer { enabled: true, default, loggers, appenders, - extra, } } @@ -110,28 +105,7 @@ impl T4Layer { config.default.format.clone().into(), ); - Ok(T4Layer::new(default, layers, appenders, Self::mk_extra())) - } - fn mk_extra() -> Vec> - where - Reg: Layer + Subscriber + Send + Sync + for<'s> LookupSpan<'s>, - { - let layer = tracing_tree::HierarchicalLayer::default() - .with_indent_lines(true) - .with_indent_amount(2) - .with_thread_names(true) - .with_thread_ids(true) - .with_verbose_exit(true) - .with_verbose_entry(true) - .with_targets(true) - .with_higher_precision(true); - - let filter = tracing_subscriber::filter::targets::Targets::new() - .with_target("rasp_ffi", Level::TRACE); - - let filtered = layer.with_filter(filter); - - vec![Box::new(filtered) as DynLayer] + Ok(T4Layer::new(default, layers, appenders)) } } @@ -169,11 +143,6 @@ where layer.on_event(event, ctx.clone()); } } - for layer in &self.extra { - if layer.enabled(metadata, ctx.clone()) { - layer.on_event(event, ctx.clone()); - } - } // If no other layer logged this then the default one will if !any && self.default.enabled(metadata, ctx.clone()) { self.default.on_event(event, ctx); diff --git a/trace4rs/src/handle/mod.rs b/trace4rs/src/handle/mod.rs index 7dc4234..927978f 100644 --- a/trace4rs/src/handle/mod.rs +++ b/trace4rs/src/handle/mod.rs @@ -13,11 +13,11 @@ mod trace_logger; use layers::T4Layer; use shared_registry::SharedRegistry; -pub use trace_logger::TraceLogger; +pub use trace_logger::ExtraTraceLogger; -use self::loggers::Logger; +pub use self::{loggers::Logger, trace_logger::TraceLogger}; -/// The reloadable handle for a `TraceLogger`, with this we can modify the +/// The reloadable handle for a `ExtraTraceLogger`, with this we can modify the /// logging configuration at runtime. #[derive_where(Clone)] pub struct Handle { @@ -46,7 +46,7 @@ where } #[must_use] - pub fn new() -> (Handle, TraceLogger) { + pub fn new() -> (Handle, ExtraTraceLogger) { let layers = T4Layer::default(); Handle::from_layers(layers) @@ -112,7 +112,7 @@ where /// # Errors /// This could fail building the appenders in the config, for example /// opening a file for write. - pub fn from_config(config: &Config) -> Result<(Handle, TraceLogger)> + pub fn from_config(config: &Config) -> Result<(Handle, ExtraTraceLogger)> where Reg: Subscriber + Send + Sync + for<'s> LookupSpan<'s>, { @@ -121,12 +121,12 @@ where } /// Builds `Self` from `Layers` and the backing `Reg`. - fn from_layers(layers: T4Layer) -> (Handle, TraceLogger) + fn from_layers(layers: T4Layer) -> (Handle, ExtraTraceLogger) where Reg: Subscriber + Send + Sync, { let (reloadable, reload_handle) = reload::Layer::new(layers); - let trace_logger = TraceLogger::new(Reg::default(), reloadable); + let trace_logger = TraceLogger::new_extra(Reg::default(), reloadable); ( Handle { diff --git a/trace4rs/src/handle/trace_logger.rs b/trace4rs/src/handle/trace_logger.rs index 61b092e..fb03340 100644 --- a/trace4rs/src/handle/trace_logger.rs +++ b/trace4rs/src/handle/trace_logger.rs @@ -1,34 +1,128 @@ -use tracing::{span, Event, Subscriber}; -use tracing_subscriber::{layer::Layered, prelude::*, registry::LookupSpan, reload}; +use std::marker::PhantomData; + +use tracing::instrument::WithSubscriber; +use tracing::{span, Event, Level, Subscriber}; +use tracing_subscriber::filter::Filtered; +use tracing_subscriber::layer::Filter; +use tracing_subscriber::{layer::Layered, registry::LookupSpan, reload, Layer}; use crate::handle::T4Layer; use super::shared_registry::SharedRegistry; +trait T4Sub<'a, S>: Layer + Subscriber + Send + Sync + LookupSpan<'a> +where + S: Subscriber, +{ +} +impl<'a, L, I, S> T4Sub<'a, S> for Layered +where + L: Layer + Send + Sync, + I: Layer + Send + Sync, + S: Subscriber, + Layered: Subscriber + LookupSpan<'a>, +{ +} +impl<'a, L, F, S> T4Sub<'a, S> for Filtered +where + L: Layer + Send + Sync, + F: Filter + Send + Sync, + for<'s> S: Subscriber + LookupSpan<'s>, + for<'s> Filtered: Subscriber + LookupSpan<'s>, +{ +} + +type DynSubscriber +where + S: Subscriber + for<'a> LookupSpan<'a>, += Box T4Sub<'a, S, Data = >::Data>>; + /// The `tracing::Subscriber` that this crate implements. -pub struct TraceLogger { - inner: Layered, Reg>, Reg>, +pub struct TraceLogger, Reg>, Reg>> { + inner: L, + reg: PhantomData, } -// TODO(eas): extract `extra` from Trace4Layers to this level +pub type ExtraTraceLogger = TraceLogger< + Reg, + Layered< + tracing_subscriber::reload::Layer, Reg>, + Layered, Reg>, + Reg, + >, +>; + impl TraceLogger { - pub(crate) fn new( + pub(crate) fn new_dyn( + broker: Reg, + layers: reload::Layer, Reg>, + ) -> ExtraTraceLogger + where + Reg: Layer + Subscriber + Send + Sync + for<'a> LookupSpan<'a>, + { + let extra = Self::mk_extra().with_subscriber(broker); + let inner = extra.and_then(layers); + TraceLogger { + inner, + reg: PhantomData, + } + } + pub(crate) fn new_extra( broker: Reg, layers: reload::Layer, Reg>, - ) -> TraceLogger + ) -> ExtraTraceLogger where - Reg: Subscriber + for<'a> LookupSpan<'a>, + Reg: Layer + Subscriber + Send + Sync + for<'a> LookupSpan<'a>, { - let inner = broker.with(layers); - TraceLogger { inner } + let extra = Self::mk_extra().with_subscriber(broker); + let inner = extra.and_then(layers); + TraceLogger { + inner, + reg: PhantomData, + } + } + pub fn mk_extra() -> DynSubscriber + where + Reg: Layer + Subscriber + Send + Sync + for<'s> LookupSpan<'s>, + { + let layer = tracing_tree::HierarchicalLayer::default() + .with_indent_lines(true) + .with_indent_amount(2) + .with_thread_names(true) + .with_thread_ids(true) + .with_verbose_exit(true) + .with_verbose_entry(true) + .with_targets(true) + .with_higher_precision(true); + + let filter = tracing_subscriber::filter::targets::Targets::new() + .with_target("rasp_ffi", Level::TRACE); + + let filtered = layer.with_filter(filter); + + Box::new(filtered) as DynSubscriber } } // ########## DELEGATION BELOW ########### -impl Subscriber for TraceLogger +impl<'a, Reg, Lay> LookupSpan<'a> for TraceLogger +where + Reg: Subscriber, + Lay: T4Sub<'a, Reg>, +{ + type Data = Lay::Data; + fn register_filter(&mut self) -> tracing_subscriber::filter::FilterId { + self.inner.register_filter() + } + fn span_data(&'a self, id: &span::Id) -> Option { + self.inner.span_data(id) + } +} +impl Subscriber for TraceLogger where - Reg: Subscriber + for<'a> LookupSpan<'a>, + Reg: 'static, + Lay: Subscriber, { fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool { Subscriber::enabled(&self.inner, metadata) From 7da5a788c32da28d0482a4f1763cdacee5c134c0 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Mon, 20 Nov 2023 12:53:51 -0800 Subject: [PATCH 06/23] cleanup --- .vscode/settings.json | 4 +- .../handle/{loggers.rs => inner/formatter.rs} | 120 +++--------------- .../src/handle/{layers.rs => inner/layer.rs} | 67 ++++------ trace4rs/src/handle/inner/logger.rs | 95 ++++++++++++++ trace4rs/src/handle/inner/mod.rs | 3 + trace4rs/src/handle/mod.rs | 31 +++-- .../{shared_registry.rs => registry.rs} | 17 +-- .../handle/{trace_logger.rs => subscriber.rs} | 79 +++++------- trace4rs/src/lib.rs | 2 +- trace4rs/src/test.rs | 29 ++--- 10 files changed, 210 insertions(+), 237 deletions(-) rename trace4rs/src/handle/{loggers.rs => inner/formatter.rs} (64%) rename trace4rs/src/handle/{layers.rs => inner/layer.rs} (76%) create mode 100644 trace4rs/src/handle/inner/logger.rs create mode 100644 trace4rs/src/handle/inner/mod.rs rename trace4rs/src/handle/{shared_registry.rs => registry.rs} (78%) rename trace4rs/src/handle/{trace_logger.rs => subscriber.rs} (63%) diff --git a/.vscode/settings.json b/.vscode/settings.json index fdc8dae..b30875d 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -3,6 +3,8 @@ "appender", "appenders", "fmtorp", - "messageonly" + "hmap", + "messageonly", + "targ" ] } diff --git a/trace4rs/src/handle/loggers.rs b/trace4rs/src/handle/inner/formatter.rs similarity index 64% rename from trace4rs/src/handle/loggers.rs rename to trace4rs/src/handle/inner/formatter.rs index 6d131e5..aaefa83 100644 --- a/trace4rs/src/handle/loggers.rs +++ b/trace4rs/src/handle/inner/formatter.rs @@ -1,111 +1,25 @@ -#![allow(clippy::single_char_lifetime_names)] -use core::fmt; -use std::{borrow::Cow, io}; +use std::{borrow::Cow, fmt}; +use crate::config::Format as ConfigFormat; use once_cell::sync::Lazy; use trace4rs_fmtorp::FieldValueWriter; -use tracing::{field::Visit, metadata::LevelFilter, Event, Metadata, Subscriber}; +use tracing::{field::Visit, Event, Subscriber}; use tracing_log::NormalizeEvent; use tracing_subscriber::{ fmt::{ - format::{self, DefaultFields, Format, Full, Writer}, + format::{self, Format, Full, Writer}, time::FormatTime, - writer::{BoxMakeWriter, MakeWriterExt}, - FmtContext, FormatEvent, FormatFields, Layer as FmtLayer, + FmtContext, FormatEvent, FormatFields, }, - layer::Context, registry::LookupSpan, - Layer, }; -use crate::{ - appenders::Appenders, - config::{AppenderId, Format as ConfigFormat, Target}, -}; - -use super::shared_registry::SharedRegistry; - const TIME_FORMAT: time::format_description::well_known::Rfc3339 = time::format_description::well_known::Rfc3339; static NORMAL_FMT: Lazy> = Lazy::new(|| Format::default().with_timer(UtcOffsetTime).with_ansi(false)); -pub struct Logger { - level: LevelFilter, - target: Option, - layer: FmtLayer, -} - -impl Logger { - pub fn new<'a, Reg>( - level: LevelFilter, - target: Option, - ids: impl Iterator, - appenders: &Appenders, - format: EventFormatter, - ) -> Logger - where - Reg: Subscriber + Send + Sync + for<'b> LookupSpan<'b>, - FmtLayer: Layer, - { - let writer = - Self::mk_writer(ids, appenders).unwrap_or_else(|| BoxMakeWriter::new(io::sink)); - - let fmt_layer = FmtLayer::default().event_format(format).with_ansi(false); - let layer = fmt_layer.with_writer(writer); - // let layer = r.with(append_layer); - - Logger { - level, - target, - layer, - } - } - - fn mk_writer<'a>( - ids: impl Iterator, - appenders: &Appenders, - ) -> Option { - let mut accumulated_makewriter = None; - for id in ids { - if let Some(appender) = appenders.get(id).map(ToOwned::to_owned) { - accumulated_makewriter = if let Some(acc) = accumulated_makewriter.take() { - Some(BoxMakeWriter::new(MakeWriterExt::and(acc, appender))) - } else { - Some(BoxMakeWriter::new(appender)) - } - } - } - accumulated_makewriter - } -} - -impl Logger { - fn is_enabled(&self, meta: &Metadata<'_>) -> bool { - let match_level = meta.level() <= &self.level; - let match_target = self - .target - .as_ref() - .map_or(true, |t| meta.target().starts_with(t.as_str())); - - match_level && match_target - } -} -impl Layer for Logger -where - Sub: Subscriber, - FmtLayer: Layer, -{ - fn enabled(&self, meta: &Metadata<'_>, _ctx: Context<'_, Sub>) -> bool { - Logger::is_enabled(self, meta) - } - - fn on_event(&self, event: &Event<'_>, ctx: Context<'_, Sub>) { - self.layer.on_event(event, ctx); - } -} - #[derive(Debug)] pub enum EventFormatter { Normal, @@ -141,13 +55,14 @@ impl From for EventFormatter { } } -impl FormatEvent for EventFormatter +impl FormatEvent for EventFormatter where - S: Subscriber + for<'b> LookupSpan<'b>, + S: Subscriber + for<'a> LookupSpan<'a>, + N: for<'w> FormatFields<'w> + 'static, { fn format_event( &self, - ctx: &FmtContext<'_, S, DefaultFields>, + ctx: &FmtContext<'_, S, N>, writer: Writer<'_>, event: &Event<'_>, ) -> std::fmt::Result { @@ -184,11 +99,11 @@ mod fields { }); } -struct CustomValueWriter<'ctx, 'evt, Broker> { - ctx: &'ctx FmtContext<'ctx, Broker, DefaultFields>, +struct CustomValueWriter<'ctx, 'evt, Broker, N> { + ctx: &'ctx FmtContext<'ctx, Broker, N>, event: &'evt Event<'evt>, } -impl<'ctx, 'evt, Broker> CustomValueWriter<'ctx, 'evt, Broker> { +impl<'ctx, 'evt, Broker, N> CustomValueWriter<'ctx, 'evt, Broker, N> { fn format_timestamp(mut writer: format::Writer<'_>) -> fmt::Result { use tracing_subscriber::fmt::time::OffsetTime; @@ -202,10 +117,10 @@ impl<'ctx, 'evt, Broker> CustomValueWriter<'ctx, 'evt, Broker> { t.format_time(&mut writer) } } -impl<'ctx, 'evt, Broker> FieldValueWriter for CustomValueWriter<'ctx, 'evt, Broker> +impl<'ctx, 'evt, Broker, N> FieldValueWriter for CustomValueWriter<'ctx, 'evt, Broker, N> where Broker: 'static, - for<'writer> FmtContext<'ctx, Broker, DefaultFields>: FormatFields<'writer>, + for<'writer> FmtContext<'ctx, Broker, N>: FormatFields<'writer>, { fn write_value(&self, mut writer: format::Writer<'_>, field: &'static str) -> fmt::Result { let normalized_meta = self.event.normalized_metadata(); @@ -249,14 +164,15 @@ impl CustomFormatter { Ok(Self { fmtr }) } - fn format_event<'ctx, 'evt, 'w, S>( + fn format_event<'ctx, 'evt, 'w, S, N>( &self, - ctx: &FmtContext<'ctx, S, DefaultFields>, + ctx: &FmtContext<'ctx, S, N>, writer: Writer<'w>, event: &Event<'evt>, ) -> fmt::Result where S: Subscriber + for<'b> LookupSpan<'b>, + N: FormatFields<'w> + 'static, { let value_writer = CustomValueWriter { ctx, event }; self.fmtr.write(writer, &value_writer) @@ -295,6 +211,8 @@ impl<'w> Visit for SingleFieldVisitor<'w> { } } +/// We go above and beyond to acquire the local utc offset using +/// the `utc_offset` crate, hence the custom impl. struct UtcOffsetTime; impl FormatTime for UtcOffsetTime { diff --git a/trace4rs/src/handle/layers.rs b/trace4rs/src/handle/inner/layer.rs similarity index 76% rename from trace4rs/src/handle/layers.rs rename to trace4rs/src/handle/inner/layer.rs index ebba613..3de2a92 100644 --- a/trace4rs/src/handle/layers.rs +++ b/trace4rs/src/handle/inner/layer.rs @@ -1,23 +1,17 @@ use tracing::{metadata::LevelFilter, Event, Subscriber}; use tracing_log::NormalizeEvent; -use tracing_subscriber::{ - fmt::{format::DefaultFields, writer::BoxMakeWriter, Layer as FmtLayer}, - layer::Context, - registry::LookupSpan, - Layer, -}; +use tracing_subscriber::{layer::Context, registry::LookupSpan, Layer}; -use super::{ - loggers::{EventFormatter, Logger}, - shared_registry::SharedRegistry, -}; +use super::formatter::EventFormatter; +use super::logger::Logger; +use crate::handle::registry::T4Registry; use crate::{ appenders::{Appender, Appenders}, config::{AppenderId, Config}, error::Result, }; -pub struct T4Layer { +pub struct T4Layer { enabled: bool, default: Logger, loggers: Vec>, @@ -34,16 +28,25 @@ impl T4Layer { pub fn appenders(&self) -> &Appenders { &self.appenders } + /// Disable this subscriber. + pub fn disable(&mut self) { + self.enabled = false; + } + + /// Enable this subscriber. + pub fn enable(&mut self) { + self.enabled = true; + } } -impl T4Layer { +impl T4Layer +where + Reg: Layer + Subscriber + Send + Sync + for<'s> LookupSpan<'s>, + Logger: Layer, +{ /// The default `Layers` backed by `broker` (`INFO` and above goes to /// stdout). - pub fn default() -> T4Layer - where - Reg: Layer + Subscriber + Send + Sync + for<'s> LookupSpan<'s>, - Logger: Layer, - { + pub fn default() -> Self { let stdout_appender = AppenderId("stdout".to_string()); let appenders = Appenders::new(literally::hmap! {stdout_appender.clone() => Appender::new_console()}); @@ -55,17 +58,13 @@ impl T4Layer { EventFormatter::Normal, ); - T4Layer::new(default, vec![], appenders) + Self::new(default, vec![], appenders) } /// Create a new `Layers` from a default layer and a pre-generated vec of /// sub-layers. - fn new( - default: Logger, - loggers: Vec>, - appenders: Appenders, - ) -> T4Layer { - T4Layer { + fn new(default: Logger, loggers: Vec>, appenders: Appenders) -> Self { + Self { enabled: true, default, loggers, @@ -77,11 +76,7 @@ impl T4Layer { /// /// # Errors /// An error may occur while building the appenders. - pub fn from_config(config: &Config) -> Result> - where - Reg: Layer + Subscriber + Send + Sync + for<'s> LookupSpan<'s>, - Logger: Layer, - { + pub fn from_config(config: &Config) -> Result { let appenders = (&config.appenders).try_into()?; let layers: Vec> = config .loggers @@ -109,22 +104,10 @@ impl T4Layer { } } -impl T4Layer { - /// Disable this subscriber. - pub fn disable(&mut self) { - self.enabled = false; - } - - /// Enable this subscriber. - pub fn enable(&mut self) { - self.enabled = true; - } -} - impl Layer for T4Layer where S: Subscriber, - FmtLayer: Layer, + Logger: Layer, { fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) { if !self.enabled { diff --git a/trace4rs/src/handle/inner/logger.rs b/trace4rs/src/handle/inner/logger.rs new file mode 100644 index 0000000..71cbad3 --- /dev/null +++ b/trace4rs/src/handle/inner/logger.rs @@ -0,0 +1,95 @@ +#![allow(clippy::single_char_lifetime_names)] +use std::io; + +use tracing::{metadata::LevelFilter, Event, Metadata, Subscriber}; +use tracing_subscriber::{ + fmt::{ + format::DefaultFields, + writer::{BoxMakeWriter, MakeWriterExt}, + Layer as FmtLayer, + }, + layer::Context, + registry::LookupSpan, + Layer, +}; + +use crate::{ + appenders::Appenders, + config::{AppenderId, Target}, +}; + +use crate::handle::registry::T4Registry; + +use super::formatter::EventFormatter; + +pub struct Logger { + level: LevelFilter, + target: Option, + layer: FmtLayer, +} +impl Logger +where + Reg: Subscriber + for<'a> LookupSpan<'a>, +{ + pub fn new<'a>( + level: LevelFilter, + target: Option, + ids: impl Iterator, + appenders: &Appenders, + format: EventFormatter, + ) -> Logger { + let writer = Logger::::mk_writer(ids, appenders) + .unwrap_or_else(|| BoxMakeWriter::new(io::sink)); + + let fmt_layer = FmtLayer::default().event_format(format).with_ansi(false); + let layer = fmt_layer.with_writer(writer); + + Logger { + level, + target, + layer, + } + } +} + +impl Logger { + fn mk_writer<'a>( + ids: impl Iterator, + appenders: &Appenders, + ) -> Option { + let mut acc_mw = None; + for id in ids { + if let Some(appender) = appenders.get(id).map(ToOwned::to_owned) { + acc_mw = if let Some(acc) = acc_mw.take() { + Some(BoxMakeWriter::new(MakeWriterExt::and(acc, appender))) + } else { + Some(BoxMakeWriter::new(appender)) + } + } + } + acc_mw + } + fn is_enabled(&self, meta: &Metadata<'_>) -> bool { + let match_level = meta.level() <= &self.level; + let match_target = self + .target + .as_ref() + .map_or(true, |t| meta.target().starts_with(t.as_str())); + + match_level && match_target + } +} + +impl Layer for Logger +where + Reg: Subscriber + for<'a> LookupSpan<'a>, + FmtLayer: Layer, +{ + fn enabled(&self, meta: &Metadata<'_>, _ctx: Context<'_, Reg>) -> bool { + Logger::is_enabled(self, meta) + } + + fn on_event(&self, event: &Event<'_>, ctx: Context<'_, Reg>) { + self.layer.on_event(event, ctx); + } +} diff --git a/trace4rs/src/handle/inner/mod.rs b/trace4rs/src/handle/inner/mod.rs new file mode 100644 index 0000000..833d728 --- /dev/null +++ b/trace4rs/src/handle/inner/mod.rs @@ -0,0 +1,3 @@ +pub mod formatter; +pub mod layer; +pub mod logger; diff --git a/trace4rs/src/handle/mod.rs b/trace4rs/src/handle/mod.rs index 927978f..d60433a 100644 --- a/trace4rs/src/handle/mod.rs +++ b/trace4rs/src/handle/mod.rs @@ -6,21 +6,20 @@ use tracing_subscriber::{layer::Layer, registry::LookupSpan, reload}; use crate::{config::Config, error::Result}; -mod layers; -mod loggers; -mod shared_registry; -mod trace_logger; +mod inner; +mod registry; +mod subscriber; -use layers::T4Layer; -use shared_registry::SharedRegistry; -pub use trace_logger::ExtraTraceLogger; +use inner::layer::T4Layer; +use registry::T4Registry; -pub use self::{loggers::Logger, trace_logger::TraceLogger}; +pub use inner::logger::Logger; +pub use subscriber::T4Subscriber; /// The reloadable handle for a `ExtraTraceLogger`, with this we can modify the /// logging configuration at runtime. #[derive_where(Clone)] -pub struct Handle { +pub struct Handle { reload_handle: Arc, Reg>>, } @@ -29,14 +28,14 @@ pub struct Handle { /// # Errors /// We could fail to set the global default subscriber for `tracing`. pub fn init_console_logger() -> Result { - let (h, t) = Handle::new(); + let (h, t): (Handle, T4Subscriber) = Handle::new(); tracing::subscriber::set_global_default(t)?; Ok(h) } impl Handle where - Reg: Layer + Subscriber + Send + Sync + Default + for<'s> LookupSpan<'s>, + Reg: Layer + Subscriber + for<'s> LookupSpan<'s> + Send + Sync + Default, Logger: Layer, { #[must_use] @@ -46,7 +45,7 @@ where } #[must_use] - pub fn new() -> (Handle, ExtraTraceLogger) { + pub fn new() -> (Handle, T4Subscriber) { let layers = T4Layer::default(); Handle::from_layers(layers) @@ -107,12 +106,12 @@ where Ok(self.reload_handle.reload(ls)?) } - /// Using the given `SharedRegistry` we configure and initialize our `Self`. + /// Using the given `T4Registry` we configure and initialize our `Self`. /// /// # Errors /// This could fail building the appenders in the config, for example /// opening a file for write. - pub fn from_config(config: &Config) -> Result<(Handle, ExtraTraceLogger)> + pub fn from_config(config: &Config) -> Result<(Handle, T4Subscriber)> where Reg: Subscriber + Send + Sync + for<'s> LookupSpan<'s>, { @@ -121,12 +120,12 @@ where } /// Builds `Self` from `Layers` and the backing `Reg`. - fn from_layers(layers: T4Layer) -> (Handle, ExtraTraceLogger) + fn from_layers(layers: T4Layer) -> (Handle, T4Subscriber) where Reg: Subscriber + Send + Sync, { let (reloadable, reload_handle) = reload::Layer::new(layers); - let trace_logger = TraceLogger::new_extra(Reg::default(), reloadable); + let trace_logger = T4Subscriber::new_extra(Reg::default(), reloadable); ( Handle { diff --git a/trace4rs/src/handle/shared_registry.rs b/trace4rs/src/handle/registry.rs similarity index 78% rename from trace4rs/src/handle/shared_registry.rs rename to trace4rs/src/handle/registry.rs index f5ece2e..6ddb32b 100644 --- a/trace4rs/src/handle/shared_registry.rs +++ b/trace4rs/src/handle/registry.rs @@ -7,30 +7,31 @@ use tracing_subscriber::{ Registry, }; -// type DynRegistry = SharedRegistry>; +// type DynRegistry = T4Registry>; -/// SharedRegistry exists because we need to be able to override the layer functionality. +/// T4Registry exists because we need to be able to override the layer functionality. /// Also we would otherwise need to wrap a registry in an arc to share it as much as we do. /// #[derive(Debug)] #[derive_where(Default; Reg: Default)] -pub struct SharedRegistry { +pub struct T4Registry { inner: Reg, } -impl SharedRegistry { +impl T4Registry { pub fn new() -> Self { - SharedRegistry { + T4Registry { inner: tracing_subscriber::registry(), } } } -impl tracing_subscriber::Layer for SharedRegistry {} +// eas: verify necessary, if not use a naked registry +impl tracing_subscriber::Layer for T4Registry {} // ########## DELEGATION BELOW ########### -impl<'a, R> LookupSpan<'a> for SharedRegistry +impl<'a, R> LookupSpan<'a> for T4Registry where R: LookupSpan<'a, Data = registry::Data<'a>>, { @@ -44,7 +45,7 @@ where } } -impl Subscriber for SharedRegistry +impl Subscriber for T4Registry where R: Subscriber, { diff --git a/trace4rs/src/handle/trace_logger.rs b/trace4rs/src/handle/subscriber.rs similarity index 63% rename from trace4rs/src/handle/trace_logger.rs rename to trace4rs/src/handle/subscriber.rs index fb03340..a7f0e82 100644 --- a/trace4rs/src/handle/trace_logger.rs +++ b/trace4rs/src/handle/subscriber.rs @@ -1,14 +1,14 @@ use std::marker::PhantomData; -use tracing::instrument::WithSubscriber; use tracing::{span, Event, Level, Subscriber}; -use tracing_subscriber::filter::Filtered; -use tracing_subscriber::layer::Filter; +use tracing_subscriber::filter::{Filtered, Targets}; +use tracing_subscriber::layer::{Filter, SubscriberExt}; use tracing_subscriber::{layer::Layered, registry::LookupSpan, reload, Layer}; +use tracing_tree::HierarchicalLayer; use crate::handle::T4Layer; -use super::shared_registry::SharedRegistry; +use super::registry::T4Registry; trait T4Sub<'a, S>: Layer + Subscriber + Send + Sync + LookupSpan<'a> where @@ -23,67 +23,52 @@ where Layered: Subscriber + LookupSpan<'a>, { } -impl<'a, L, F, S> T4Sub<'a, S> for Filtered +impl<'a, L, F, Reg> T4Sub<'a, Reg> for Filtered where - L: Layer + Send + Sync, - F: Filter + Send + Sync, - for<'s> S: Subscriber + LookupSpan<'s>, - for<'s> Filtered: Subscriber + LookupSpan<'s>, + L: Layer + Send + Sync, + F: Filter + Send + Sync, + for<'s> Reg: Subscriber + LookupSpan<'s>, + for<'s> Filtered: Subscriber + LookupSpan<'s>, { } -type DynSubscriber +pub type DynSubscriber where - S: Subscriber + for<'a> LookupSpan<'a>, + S: Subscriber + for<'a> LookupSpan<'a> + Send + Sync, = Box T4Sub<'a, S, Data = >::Data>>; /// The `tracing::Subscriber` that this crate implements. -pub struct TraceLogger, Reg>, Reg>> { - inner: L, - reg: PhantomData, -} - -pub type ExtraTraceLogger = TraceLogger< - Reg, - Layered< +pub struct T4Subscriber< + Reg = T4Registry, + L = Layered< + Layered, Reg>, tracing_subscriber::reload::Layer, Reg>, - Layered, Reg>, Reg, >, ->; +> { + inner: L, + reg: PhantomData, +} -impl TraceLogger { - pub(crate) fn new_dyn( - broker: Reg, - layers: reload::Layer, Reg>, - ) -> ExtraTraceLogger - where - Reg: Layer + Subscriber + Send + Sync + for<'a> LookupSpan<'a>, - { - let extra = Self::mk_extra().with_subscriber(broker); - let inner = extra.and_then(layers); - TraceLogger { - inner, - reg: PhantomData, - } - } +impl T4Subscriber { pub(crate) fn new_extra( broker: Reg, layers: reload::Layer, Reg>, - ) -> ExtraTraceLogger + ) -> T4Subscriber where Reg: Layer + Subscriber + Send + Sync + for<'a> LookupSpan<'a>, { - let extra = Self::mk_extra().with_subscriber(broker); - let inner = extra.and_then(layers); - TraceLogger { + let extra: Layered, Reg> = + broker.with(Self::mk_extra()); + let inner = layers.and_then(extra); + T4Subscriber { inner, reg: PhantomData, } } - pub fn mk_extra() -> DynSubscriber + pub fn mk_extra() -> Filtered where - Reg: Layer + Subscriber + Send + Sync + for<'s> LookupSpan<'s>, + Reg: Subscriber + for<'s> LookupSpan<'s>, { let layer = tracing_tree::HierarchicalLayer::default() .with_indent_lines(true) @@ -100,13 +85,13 @@ impl TraceLogger { let filtered = layer.with_filter(filter); - Box::new(filtered) as DynSubscriber + filtered } } // ########## DELEGATION BELOW ########### -impl<'a, Reg, Lay> LookupSpan<'a> for TraceLogger +impl<'a, Reg, Lay> LookupSpan<'a> for T4Subscriber where Reg: Subscriber, Lay: T4Sub<'a, Reg>, @@ -119,10 +104,10 @@ where self.inner.span_data(id) } } -impl Subscriber for TraceLogger +impl Subscriber for T4Subscriber where - Reg: 'static, - Lay: Subscriber, + Reg: Subscriber, + Lay: Subscriber + Layer, { fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool { Subscriber::enabled(&self.inner, metadata) diff --git a/trace4rs/src/lib.rs b/trace4rs/src/lib.rs index c426e97..4e961e7 100644 --- a/trace4rs/src/lib.rs +++ b/trace4rs/src/lib.rs @@ -22,5 +22,5 @@ pub mod error; mod test; pub use appenders::Appender; -pub use handle::{init_console_logger, Handle, TraceLogger}; +pub use handle::{init_console_logger, Handle, T4Subscriber}; pub use trace4rs_config::{config, config::Config, error::Error as ConfigError}; diff --git a/trace4rs/src/test.rs b/trace4rs/src/test.rs index f479596..41865b7 100644 --- a/trace4rs/src/test.rs +++ b/trace4rs/src/test.rs @@ -1,26 +1,13 @@ #![cfg(test)] -use std::{ - convert::TryFrom, - fs, - io::Read, -}; +use std::{convert::TryFrom, fs, io::Read}; -use trace4rs_config::config::{ - Appender, - Config, - Format, - LevelFilter, - Logger, -}; +use trace4rs_config::config::{Appender, Config, Format, LevelFilter, Logger}; use tracing::Subscriber; -use crate::{ - Handle, - TraceLogger, -}; +use crate::{Handle, T4Subscriber}; -static_assertions::assert_impl_all!(TraceLogger: Subscriber, Send, Sync); +static_assertions::assert_impl_all!(T4Subscriber: Subscriber, Send, Sync); #[test] fn test_set_global() { @@ -37,14 +24,14 @@ fn test_set_global() { "file" => file, }; let default = Logger { - level: LevelFilter::WARN, + level: LevelFilter::WARN, appenders: literally::hset! {"console"}, - format: Format::default(), + format: Format::default(), }; let l1 = Logger { - level: LevelFilter::INFO, + level: LevelFilter::INFO, appenders: literally::hset! {"file"}, - format: Format::default(), + format: Format::default(), }; let config = Config { default, From 9005d42b70b669a8f096224195550f75f2f9f641 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Tue, 21 Nov 2023 12:27:15 -0800 Subject: [PATCH 07/23] switch to tracing-span-tree --- .vscode/settings.json | 1 + Cargo.toml | 5 ++ trace4rs/Cargo.toml | 2 +- trace4rs/src/appenders/mod.rs | 7 +- trace4rs/src/appenders/rolling.rs | 9 +-- trace4rs/src/handle/inner/formatter.rs | 4 +- trace4rs/src/handle/inner/layer.rs | 9 +-- trace4rs/src/handle/inner/logger.rs | 17 +++-- trace4rs/src/handle/mod.rs | 16 ++--- trace4rs/src/handle/registry.rs | 79 ---------------------- trace4rs/src/handle/subscriber.rs | 94 ++++++++------------------ trace4rs/src/test.rs | 9 +-- 12 files changed, 74 insertions(+), 178 deletions(-) delete mode 100644 trace4rs/src/handle/registry.rs diff --git a/.vscode/settings.json b/.vscode/settings.json index b30875d..5780233 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -3,6 +3,7 @@ "appender", "appenders", "fmtorp", + "fmtr", "hmap", "messageonly", "targ" diff --git a/Cargo.toml b/Cargo.toml index d73d7d9..d883b98 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,6 +16,11 @@ repository = "https://github.com/imperva/trace4rs" readme = "readme.md" categories = ["development-tools"] +[profile.dev] +opt-level = 1 +[profile.dev.package."*"] +opt-level = 3 + [workspace.lints.clippy] all = "warn" # correctness, sus, style, complexity, perf pedantic = "warn" diff --git a/trace4rs/Cargo.toml b/trace4rs/Cargo.toml index 6d4c091..9b845f1 100644 --- a/trace4rs/Cargo.toml +++ b/trace4rs/Cargo.toml @@ -41,8 +41,8 @@ trace4rs-fmtorp = { version = "0.5.1", path = "../trace4rs-fmtorp" } utc-offset = { git = "https://github.com/estk/utc_offset" } camino = "1.1.2" rustversion = "1.0.14" -tracing-tree = { version = "0.3.0", features = ["time"] } derive-where = "1.2.5" +tracing-span-tree = "0.1.1" [dev-dependencies] criterion = "0.5.0" diff --git a/trace4rs/src/appenders/mod.rs b/trace4rs/src/appenders/mod.rs index ac80810..a2450e8 100644 --- a/trace4rs/src/appenders/mod.rs +++ b/trace4rs/src/appenders/mod.rs @@ -31,7 +31,7 @@ type AppenderMap = HashMap; /// Appenders holds the global map of appenders which can be referenced by /// Layers, it may be cheaply cloned. -#[derive(Clone)] +#[derive(Clone, Debug)] pub struct Appenders { appenders: Arc, } @@ -112,7 +112,7 @@ impl TryFrom<&config::Appender> for Appender { } /// An Appender represents a sink where logs can be written. -#[derive(Clone)] +#[derive(Clone, Debug)] pub enum Appender { /// Logs are written to stdout. Console(Console), @@ -260,7 +260,7 @@ impl io::Write for Appender { } /// An appender which writes to stdout. -#[derive(Clone, Default)] +#[derive(Clone, Default, Debug)] pub struct Console; impl Console { pub fn new() -> Self { @@ -278,6 +278,7 @@ impl io::Write for Console { } /// An appender which writes to a file. +#[derive(Debug)] pub struct File { path: Utf8PathBuf, writer: LineWriter, diff --git a/trace4rs/src/appenders/rolling.rs b/trace4rs/src/appenders/rolling.rs index ec65a65..7ff69d6 100644 --- a/trace4rs/src/appenders/rolling.rs +++ b/trace4rs/src/appenders/rolling.rs @@ -12,7 +12,7 @@ use crate::{ /// `LogFileMeta` allows us to keep track of an estimated length for a given /// file. -#[derive(Clone, Default)] +#[derive(Clone, Default, Debug)] pub struct LogFileMeta { est_len: u64, } @@ -37,7 +37,7 @@ impl LogFileMeta { } /// A Trigger which specifies when to roll a file. -#[derive(Clone)] +#[derive(Clone, Debug)] pub enum Trigger { Size { limit: u64 }, } @@ -55,7 +55,7 @@ impl Trigger { /// - foo.1 /// - foo.2 # the oldest rolled log file /// ``` -#[derive(Clone)] +#[derive(Clone, Debug)] pub struct FixedWindow { /// invariant last < count last: Option, @@ -125,7 +125,7 @@ impl FixedWindow { } /// Roller specifies how to roll a file. -#[derive(Clone)] +#[derive(Clone, Debug)] pub enum Roller { Delete, FixedWindow(FixedWindow), @@ -163,6 +163,7 @@ impl Roller { /// An appender which writes to a file and manages rolling said file, either to /// backups or by deletion. +#[derive(Debug)] pub struct Rolling { path: Utf8PathBuf, /// Writer will always be some except when it is being rolled or if there diff --git a/trace4rs/src/handle/inner/formatter.rs b/trace4rs/src/handle/inner/formatter.rs index aaefa83..82342e2 100644 --- a/trace4rs/src/handle/inner/formatter.rs +++ b/trace4rs/src/handle/inner/formatter.rs @@ -171,8 +171,8 @@ impl CustomFormatter { event: &Event<'evt>, ) -> fmt::Result where - S: Subscriber + for<'b> LookupSpan<'b>, - N: FormatFields<'w> + 'static, + S: Subscriber + for<'a> LookupSpan<'a>, + N: for<'a> FormatFields<'a> + 'static, { let value_writer = CustomValueWriter { ctx, event }; self.fmtr.write(writer, &value_writer) diff --git a/trace4rs/src/handle/inner/layer.rs b/trace4rs/src/handle/inner/layer.rs index 3de2a92..ec3ae53 100644 --- a/trace4rs/src/handle/inner/layer.rs +++ b/trace4rs/src/handle/inner/layer.rs @@ -1,17 +1,18 @@ +use derive_where::derive_where; use tracing::{metadata::LevelFilter, Event, Subscriber}; use tracing_log::NormalizeEvent; -use tracing_subscriber::{layer::Context, registry::LookupSpan, Layer}; +use tracing_subscriber::{layer::Context, registry::LookupSpan, Layer, Registry}; use super::formatter::EventFormatter; use super::logger::Logger; -use crate::handle::registry::T4Registry; use crate::{ appenders::{Appender, Appenders}, config::{AppenderId, Config}, error::Result, }; -pub struct T4Layer { +#[derive_where(Debug)] +pub struct T4Layer { enabled: bool, default: Logger, loggers: Vec>, @@ -41,7 +42,7 @@ impl T4Layer { impl T4Layer where - Reg: Layer + Subscriber + Send + Sync + for<'s> LookupSpan<'s>, + Reg: Subscriber + Send + Sync + for<'s> LookupSpan<'s>, Logger: Layer, { /// The default `Layers` backed by `broker` (`INFO` and above goes to diff --git a/trace4rs/src/handle/inner/logger.rs b/trace4rs/src/handle/inner/logger.rs index 71cbad3..b23b40a 100644 --- a/trace4rs/src/handle/inner/logger.rs +++ b/trace4rs/src/handle/inner/logger.rs @@ -1,5 +1,5 @@ #![allow(clippy::single_char_lifetime_names)] -use std::io; +use std::{fmt, io}; use tracing::{metadata::LevelFilter, Event, Metadata, Subscriber}; use tracing_subscriber::{ @@ -10,7 +10,7 @@ use tracing_subscriber::{ }, layer::Context, registry::LookupSpan, - Layer, + Layer, Registry, }; use crate::{ @@ -18,15 +18,22 @@ use crate::{ config::{AppenderId, Target}, }; -use crate::handle::registry::T4Registry; - use super::formatter::EventFormatter; -pub struct Logger { +pub struct Logger { level: LevelFilter, target: Option, layer: FmtLayer, } +impl fmt::Debug for Logger { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "Point {{level: {:?}, target: {:?}}}", + self.level, self.target + ) + } +} impl Logger where Reg: Subscriber + for<'a> LookupSpan<'a>, diff --git a/trace4rs/src/handle/mod.rs b/trace4rs/src/handle/mod.rs index d60433a..d9107b2 100644 --- a/trace4rs/src/handle/mod.rs +++ b/trace4rs/src/handle/mod.rs @@ -1,17 +1,15 @@ -use std::sync::Arc; +use std::{fmt, sync::Arc}; use derive_where::derive_where; use tracing::Subscriber; -use tracing_subscriber::{layer::Layer, registry::LookupSpan, reload}; +use tracing_subscriber::{layer::Layer, registry::LookupSpan, reload, Registry}; use crate::{config::Config, error::Result}; mod inner; -mod registry; mod subscriber; use inner::layer::T4Layer; -use registry::T4Registry; pub use inner::logger::Logger; pub use subscriber::T4Subscriber; @@ -19,7 +17,7 @@ pub use subscriber::T4Subscriber; /// The reloadable handle for a `ExtraTraceLogger`, with this we can modify the /// logging configuration at runtime. #[derive_where(Clone)] -pub struct Handle { +pub struct Handle { reload_handle: Arc, Reg>>, } @@ -35,7 +33,7 @@ pub fn init_console_logger() -> Result { impl Handle where - Reg: Layer + Subscriber + for<'s> LookupSpan<'s> + Send + Sync + Default, + Reg: Subscriber + for<'s> LookupSpan<'s> + Send + Sync + Default + fmt::Debug, Logger: Layer, { #[must_use] @@ -106,14 +104,14 @@ where Ok(self.reload_handle.reload(ls)?) } - /// Using the given `T4Registry` we configure and initialize our `Self`. + /// Using the given `Registry` we configure and initialize our `Self`. /// /// # Errors /// This could fail building the appenders in the config, for example /// opening a file for write. pub fn from_config(config: &Config) -> Result<(Handle, T4Subscriber)> where - Reg: Subscriber + Send + Sync + for<'s> LookupSpan<'s>, + Reg: Subscriber + Send + Sync + for<'s> LookupSpan<'s> + fmt::Debug, { let layers: T4Layer = T4Layer::from_config(config)?; Ok(Self::from_layers(layers)) @@ -122,7 +120,7 @@ where /// Builds `Self` from `Layers` and the backing `Reg`. fn from_layers(layers: T4Layer) -> (Handle, T4Subscriber) where - Reg: Subscriber + Send + Sync, + Reg: Subscriber + Send + Sync + fmt::Debug, { let (reloadable, reload_handle) = reload::Layer::new(layers); let trace_logger = T4Subscriber::new_extra(Reg::default(), reloadable); diff --git a/trace4rs/src/handle/registry.rs b/trace4rs/src/handle/registry.rs deleted file mode 100644 index 6ddb32b..0000000 --- a/trace4rs/src/handle/registry.rs +++ /dev/null @@ -1,79 +0,0 @@ -#![allow(clippy::single_char_lifetime_names)] - -use derive_where::derive_where; -use tracing::{span, Event, Subscriber}; -use tracing_subscriber::{ - registry::{self, LookupSpan}, - Registry, -}; - -// type DynRegistry = T4Registry>; - -/// T4Registry exists because we need to be able to override the layer functionality. -/// Also we would otherwise need to wrap a registry in an arc to share it as much as we do. -/// -#[derive(Debug)] -#[derive_where(Default; Reg: Default)] -pub struct T4Registry { - inner: Reg, -} - -impl T4Registry { - pub fn new() -> Self { - T4Registry { - inner: tracing_subscriber::registry(), - } - } -} - -// eas: verify necessary, if not use a naked registry -impl tracing_subscriber::Layer for T4Registry {} - -// ########## DELEGATION BELOW ########### - -impl<'a, R> LookupSpan<'a> for T4Registry -where - R: LookupSpan<'a, Data = registry::Data<'a>>, -{ - type Data = registry::Data<'a>; - - fn span_data(&'a self, id: &tracing::Id) -> Option { - self.inner.span_data(id) - } - fn register_filter(&mut self) -> tracing_subscriber::filter::FilterId { - self.inner.register_filter() - } -} - -impl Subscriber for T4Registry -where - R: Subscriber, -{ - fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool { - self.inner.enabled(metadata) - } - - fn new_span(&self, span: &span::Attributes<'_>) -> span::Id { - self.inner.new_span(span) - } - - fn record(&self, span: &span::Id, values: &span::Record<'_>) { - self.inner.record(span, values); - } - - fn record_follows_from(&self, span: &span::Id, follows: &span::Id) { - self.inner.record_follows_from(span, follows); - } - - fn event(&self, event: &Event<'_>) { - self.inner.event(event); - } - - fn enter(&self, span: &span::Id) { - self.inner.enter(span); - } - - fn exit(&self, span: &span::Id) { - self.inner.exit(span); - } -} diff --git a/trace4rs/src/handle/subscriber.rs b/trace4rs/src/handle/subscriber.rs index a7f0e82..f78a89e 100644 --- a/trace4rs/src/handle/subscriber.rs +++ b/trace4rs/src/handle/subscriber.rs @@ -1,53 +1,22 @@ -use std::marker::PhantomData; +use std::fmt; use tracing::{span, Event, Level, Subscriber}; +use tracing_span_tree::SpanTree; use tracing_subscriber::filter::{Filtered, Targets}; -use tracing_subscriber::layer::{Filter, SubscriberExt}; +use tracing_subscriber::layer::SubscriberExt; +use tracing_subscriber::Registry; use tracing_subscriber::{layer::Layered, registry::LookupSpan, reload, Layer}; -use tracing_tree::HierarchicalLayer; use crate::handle::T4Layer; -use super::registry::T4Registry; - -trait T4Sub<'a, S>: Layer + Subscriber + Send + Sync + LookupSpan<'a> -where - S: Subscriber, -{ -} -impl<'a, L, I, S> T4Sub<'a, S> for Layered -where - L: Layer + Send + Sync, - I: Layer + Send + Sync, - S: Subscriber, - Layered: Subscriber + LookupSpan<'a>, -{ -} -impl<'a, L, F, Reg> T4Sub<'a, Reg> for Filtered -where - L: Layer + Send + Sync, - F: Filter + Send + Sync, - for<'s> Reg: Subscriber + LookupSpan<'s>, - for<'s> Filtered: Subscriber + LookupSpan<'s>, -{ -} - -pub type DynSubscriber -where - S: Subscriber + for<'a> LookupSpan<'a> + Send + Sync, -= Box T4Sub<'a, S, Data = >::Data>>; +type InnerLayered = Layered< + Filtered, Reg>, Reg>>, + Layered, Reg>, Reg>, +>; /// The `tracing::Subscriber` that this crate implements. -pub struct T4Subscriber< - Reg = T4Registry, - L = Layered< - Layered, Reg>, - tracing_subscriber::reload::Layer, Reg>, - Reg, - >, -> { - inner: L, - reg: PhantomData, +pub struct T4Subscriber { + inner: InnerLayered, } impl T4Subscriber { @@ -56,29 +25,17 @@ impl T4Subscriber { layers: reload::Layer, Reg>, ) -> T4Subscriber where - Reg: Layer + Subscriber + Send + Sync + for<'a> LookupSpan<'a>, + Reg: Subscriber + for<'a> LookupSpan<'a> + Send + Sync + fmt::Debug, { - let extra: Layered, Reg> = - broker.with(Self::mk_extra()); - let inner = layers.and_then(extra); - T4Subscriber { - inner, - reg: PhantomData, - } + let inner = broker.with(layers).with(Self::mk_extra()); + T4Subscriber { inner } } - pub fn mk_extra() -> Filtered + pub fn mk_extra() -> Filtered where - Reg: Subscriber + for<'s> LookupSpan<'s>, + Reg: Subscriber + for<'s> LookupSpan<'s> + fmt::Debug, { - let layer = tracing_tree::HierarchicalLayer::default() - .with_indent_lines(true) - .with_indent_amount(2) - .with_thread_names(true) - .with_thread_ids(true) - .with_verbose_exit(true) - .with_verbose_entry(true) - .with_targets(true) - .with_higher_precision(true); +d + let layer = tracing_span_tree::span_tree(); let filter = tracing_subscriber::filter::targets::Targets::new() .with_target("rasp_ffi", Level::TRACE); @@ -91,12 +48,12 @@ impl T4Subscriber { // ########## DELEGATION BELOW ########### -impl<'a, Reg, Lay> LookupSpan<'a> for T4Subscriber +impl<'a, Reg> LookupSpan<'a> for T4Subscriber where - Reg: Subscriber, - Lay: T4Sub<'a, Reg>, + Reg: Subscriber + LookupSpan<'a>, + Layered, Reg>, Reg>: Subscriber, { - type Data = Lay::Data; + type Data = >::Data; fn register_filter(&mut self) -> tracing_subscriber::filter::FilterId { self.inner.register_filter() } @@ -104,10 +61,9 @@ where self.inner.span_data(id) } } -impl Subscriber for T4Subscriber +impl Subscriber for T4Subscriber where - Reg: Subscriber, - Lay: Subscriber + Layer, + Reg: Subscriber + for<'a> LookupSpan<'a> + fmt::Debug, { fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool { Subscriber::enabled(&self.inner, metadata) @@ -133,6 +89,10 @@ where Subscriber::enter(&self.inner, span); } + fn try_close(&self, id: span::Id) -> bool { + Subscriber::try_close(&self.inner, id) + } + fn exit(&self, span: &span::Id) { Subscriber::exit(&self.inner, span); } diff --git a/trace4rs/src/test.rs b/trace4rs/src/test.rs index 41865b7..1eb4936 100644 --- a/trace4rs/src/test.rs +++ b/trace4rs/src/test.rs @@ -1,9 +1,10 @@ #![cfg(test)] -use std::{convert::TryFrom, fs, io::Read}; +use std::{fs, io::Read}; use trace4rs_config::config::{Appender, Config, Format, LevelFilter, Logger}; use tracing::Subscriber; +use tracing_subscriber::Registry; use crate::{Handle, T4Subscriber}; @@ -14,7 +15,7 @@ fn test_set_global() { let tmp_guard = tempfile::tempdir().unwrap(); let file_out = tmp_guard.path().join("file.log"); - let handle = { + let (handle, subscriber) = { let console = Appender::Console; let file = Appender::File { path: file_out.to_string_lossy().into_owned(), @@ -39,9 +40,9 @@ fn test_set_global() { appenders, }; - Handle::try_from(config).unwrap() + Handle::::from_config(&config).unwrap() }; - tracing::subscriber::set_global_default(handle.subscriber()).unwrap(); + tracing::subscriber::set_global_default(subscriber).unwrap(); each_level(); handle.flush().unwrap(); From 98923bb23f14c845c901562b8fa4275c73772ab3 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Thu, 23 Nov 2023 13:07:58 -0800 Subject: [PATCH 08/23] wip: bubble up tracing extra layer --- readme.md | 2 + trace4rs/Cargo.toml | 2 +- trace4rs/src/handle/mod.rs | 75 +++++++++++++++++++++++-------- trace4rs/src/handle/subscriber.rs | 53 +++++++++------------- trace4rs/src/lib.rs | 2 +- 5 files changed, 82 insertions(+), 52 deletions(-) diff --git a/readme.md b/readme.md index 2b9ff93..8cf5470 100644 --- a/readme.md +++ b/readme.md @@ -18,5 +18,7 @@ See for yourself with `cargo bench --features tracing-macros` ## Todo +- Need to refactor up the reload stuff so that we can bubble up the ExtLyr stuff high enough to make it useful - [ ] Allow for generic "Layers" which can be plugged from tracing ecosystem + - We need to balance this with also allowing for no heap allocation of the span-tree layer - The reason for this is that we have parts of the ecosystem that don't use FormatEvent, we will therefore need to come up with a mechanism to use them which is outside that. diff --git a/trace4rs/Cargo.toml b/trace4rs/Cargo.toml index 9b845f1..ec43805 100644 --- a/trace4rs/Cargo.toml +++ b/trace4rs/Cargo.toml @@ -42,7 +42,7 @@ utc-offset = { git = "https://github.com/estk/utc_offset" } camino = "1.1.2" rustversion = "1.0.14" derive-where = "1.2.5" -tracing-span-tree = "0.1.1" +tracing-span-tree = { path = "../../tracing-span-tree" } [dev-dependencies] criterion = "0.5.0" diff --git a/trace4rs/src/handle/mod.rs b/trace4rs/src/handle/mod.rs index d9107b2..daf0071 100644 --- a/trace4rs/src/handle/mod.rs +++ b/trace4rs/src/handle/mod.rs @@ -1,8 +1,15 @@ -use std::{fmt, sync::Arc}; +use std::{fmt, io, sync::Arc}; use derive_where::derive_where; -use tracing::Subscriber; -use tracing_subscriber::{layer::Layer, registry::LookupSpan, reload, Registry}; +use tracing::{Level, Subscriber}; +use tracing_span_tree::SpanTree; +use tracing_subscriber::{ + filter::{Filtered, Targets}, + fmt::MakeWriter, + layer::Layer, + registry::LookupSpan, + reload, Registry, +}; use crate::{config::Config, error::Result}; @@ -14,6 +21,8 @@ use inner::layer::T4Layer; pub use inner::logger::Logger; pub use subscriber::T4Subscriber; +use self::subscriber::{FilteredST, LayeredT4Reload}; + /// The reloadable handle for a `ExtraTraceLogger`, with this we can modify the /// logging configuration at runtime. #[derive_where(Clone)] @@ -21,32 +30,33 @@ pub struct Handle { reload_handle: Arc, Reg>>, } -/// Initializes the default `trace4rs` handle as the `tracing` global default. -/// -/// # Errors -/// We could fail to set the global default subscriber for `tracing`. -pub fn init_console_logger() -> Result { - let (h, t): (Handle, T4Subscriber) = Handle::new(); - tracing::subscriber::set_global_default(t)?; - Ok(h) -} - impl Handle where Reg: Subscriber + for<'s> LookupSpan<'s> + Send + Sync + Default + fmt::Debug, Logger: Layer, { + /// Used for when you need a handle, but you don't need a logger. #[must_use] pub fn unit() -> Self { - let (handle, _layer) = Handle::from_layers(T4Layer::default()); + let (handle, _layer) = Handle::from_layers_mw(T4Layer::default(), io::empty); handle } + #[must_use] + pub fn new_with_mw(w: W) -> (Handle, T4Subscriber>) + where + W: for<'a> MakeWriter<'a> + 'static, + { + let layers = T4Layer::default(); + + Handle::from_layers_mw(layers, w) + } + #[must_use] pub fn new() -> (Handle, T4Subscriber) { let layers = T4Layer::default(); - Handle::from_layers(layers) + Handle::from_layers_mw(layers, io::stderr) } /// Disable the subscriber. @@ -114,16 +124,33 @@ where Reg: Subscriber + Send + Sync + for<'s> LookupSpan<'s> + fmt::Debug, { let layers: T4Layer = T4Layer::from_config(config)?; - Ok(Self::from_layers(layers)) + Ok(Self::from_layers_mw(layers, io::stderr)) } /// Builds `Self` from `Layers` and the backing `Reg`. - fn from_layers(layers: T4Layer) -> (Handle, T4Subscriber) + fn from_layers_mw( + layers: T4Layer, + w: Wrt, + ) -> (Handle, T4Subscriber>) where Reg: Subscriber + Send + Sync + fmt::Debug, + Wrt: for<'a> MakeWriter<'a> + 'static, + { + let extra = Self::mk_extra_mw(w); + Handle::from_layers_with_extra(layers, extra) + } + /// Builds `Self` from `Layers` and the backing `Reg`. + fn from_layers_with_extra( + layers: T4Layer, + extra: ExtLyr, + ) -> (Handle, T4Subscriber) + where + Reg: Subscriber + Send + Sync + fmt::Debug, + LayeredT4Reload: Subscriber, + ExtLyr: Layer>, { let (reloadable, reload_handle) = reload::Layer::new(layers); - let trace_logger = T4Subscriber::new_extra(Reg::default(), reloadable); + let trace_logger = T4Subscriber::new_with(Reg::default(), reloadable, extra); ( Handle { @@ -132,4 +159,16 @@ where trace_logger, ) } + fn mk_extra_mw(w: Wrt) -> Filtered, Targets, R> + where + R: Subscriber + for<'a> LookupSpan<'a> + fmt::Debug, + Wrt: for<'a> MakeWriter<'a> + 'static, + { + let layer = tracing_span_tree::span_tree_with(w); + + let filter = tracing_subscriber::filter::targets::Targets::new() + .with_target("rasp_ffi", Level::TRACE); + + layer.with_filter(filter) + } } diff --git a/trace4rs/src/handle/subscriber.rs b/trace4rs/src/handle/subscriber.rs index f78a89e..9788838 100644 --- a/trace4rs/src/handle/subscriber.rs +++ b/trace4rs/src/handle/subscriber.rs @@ -1,59 +1,47 @@ -use std::fmt; +use std::{fmt, io}; -use tracing::{span, Event, Level, Subscriber}; +use tracing::{span, Event, Subscriber}; use tracing_span_tree::SpanTree; use tracing_subscriber::filter::{Filtered, Targets}; -use tracing_subscriber::layer::SubscriberExt; +use tracing_subscriber::layer::SubscriberExt as _; use tracing_subscriber::Registry; use tracing_subscriber::{layer::Layered, registry::LookupSpan, reload, Layer}; use crate::handle::T4Layer; -type InnerLayered = Layered< - Filtered, Reg>, Reg>>, - Layered, Reg>, Reg>, ->; +pub type T4Reload = reload::Layer, Reg>; +pub type LayeredT4Reload = Layered, Reg>; +pub type FilteredST = Filtered, Targets, LayeredT4Reload>; /// The `tracing::Subscriber` that this crate implements. -pub struct T4Subscriber { - inner: InnerLayered, +pub struct T4Subscriber io::Stderr>> { + inner: Layered>, } impl T4Subscriber { - pub(crate) fn new_extra( + pub(crate) fn new_with( broker: Reg, - layers: reload::Layer, Reg>, - ) -> T4Subscriber + t4_layer: T4Reload, + extra: ExtLyr, + ) -> T4Subscriber where + ExtLyr: Layer>, Reg: Subscriber + for<'a> LookupSpan<'a> + Send + Sync + fmt::Debug, { - let inner = broker.with(layers).with(Self::mk_extra()); + // let inner = t4_layer.with_subscriber(broker).with(extra); + let inner = broker.with(t4_layer).with(extra); T4Subscriber { inner } } - pub fn mk_extra() -> Filtered - where - Reg: Subscriber + for<'s> LookupSpan<'s> + fmt::Debug, - { -d - let layer = tracing_span_tree::span_tree(); - - let filter = tracing_subscriber::filter::targets::Targets::new() - .with_target("rasp_ffi", Level::TRACE); - - let filtered = layer.with_filter(filter); - - filtered - } } // ########## DELEGATION BELOW ########### -impl<'a, Reg> LookupSpan<'a> for T4Subscriber +impl<'a, Reg, ExtLyr> LookupSpan<'a> for T4Subscriber where - Reg: Subscriber + LookupSpan<'a>, - Layered, Reg>, Reg>: Subscriber, + LayeredT4Reload: Subscriber + LookupSpan<'a>, + ExtLyr: Layer> + Layer>, { - type Data = >::Data; + type Data = as LookupSpan<'a>>::Data; fn register_filter(&mut self) -> tracing_subscriber::filter::FilterId { self.inner.register_filter() } @@ -61,8 +49,9 @@ where self.inner.span_data(id) } } -impl Subscriber for T4Subscriber +impl Subscriber for T4Subscriber where + ExtLyr: Layer> + 'static, Reg: Subscriber + for<'a> LookupSpan<'a> + fmt::Debug, { fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool { diff --git a/trace4rs/src/lib.rs b/trace4rs/src/lib.rs index 4e961e7..d5e946c 100644 --- a/trace4rs/src/lib.rs +++ b/trace4rs/src/lib.rs @@ -22,5 +22,5 @@ pub mod error; mod test; pub use appenders::Appender; -pub use handle::{init_console_logger, Handle, T4Subscriber}; +pub use handle::{Handle, T4Subscriber}; pub use trace4rs_config::{config, config::Config, error::Error as ConfigError}; From 3346fd46cd6c71b4ffe9af45905433e7c9c83f2d Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Thu, 23 Nov 2023 20:40:15 -0800 Subject: [PATCH 09/23] substantial simplification --- .vscode/settings.json | 1 + readme.md | 8 +- trace4rs/src/handle/inner/formatter.rs | 31 +++-- trace4rs/src/handle/inner/layer.rs | 6 +- trace4rs/src/handle/inner/logger.rs | 55 ++++----- trace4rs/src/handle/mod.rs | 152 ++++++++++++------------- trace4rs/src/handle/subscriber.rs | 88 -------------- trace4rs/src/lib.rs | 2 +- 8 files changed, 120 insertions(+), 223 deletions(-) delete mode 100644 trace4rs/src/handle/subscriber.rs diff --git a/.vscode/settings.json b/.vscode/settings.json index 5780233..6baca56 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -5,6 +5,7 @@ "fmtorp", "fmtr", "hmap", + "Lyrd", "messageonly", "targ" ] diff --git a/readme.md b/readme.md index 8cf5470..88d38ef 100644 --- a/readme.md +++ b/readme.md @@ -18,7 +18,7 @@ See for yourself with `cargo bench --features tracing-macros` ## Todo -- Need to refactor up the reload stuff so that we can bubble up the ExtLyr stuff high enough to make it useful -- [ ] Allow for generic "Layers" which can be plugged from tracing ecosystem - - We need to balance this with also allowing for no heap allocation of the span-tree layer - - The reason for this is that we have parts of the ecosystem that don't use FormatEvent, we will therefore need to come up with a mechanism to use them which is outside that. +- address todos +- refactor impl Handles blocks for dryer Reg and ExtLyr +- add optional layer +- remove debug constraints diff --git a/trace4rs/src/handle/inner/formatter.rs b/trace4rs/src/handle/inner/formatter.rs index 82342e2..695352b 100644 --- a/trace4rs/src/handle/inner/formatter.rs +++ b/trace4rs/src/handle/inner/formatter.rs @@ -55,14 +55,14 @@ impl From for EventFormatter { } } -impl FormatEvent for EventFormatter +impl FormatEvent for EventFormatter where - S: Subscriber + for<'a> LookupSpan<'a>, + Reg: Subscriber + for<'a> LookupSpan<'a>, N: for<'w> FormatFields<'w> + 'static, { fn format_event( &self, - ctx: &FmtContext<'_, S, N>, + ctx: &FmtContext<'_, Reg, N>, writer: Writer<'_>, event: &Event<'_>, ) -> std::fmt::Result { @@ -99,8 +99,8 @@ mod fields { }); } -struct CustomValueWriter<'ctx, 'evt, Broker, N> { - ctx: &'ctx FmtContext<'ctx, Broker, N>, +struct CustomValueWriter<'ctx, 'evt, Reg, N> { + ctx: &'ctx FmtContext<'ctx, Reg, N>, event: &'evt Event<'evt>, } impl<'ctx, 'evt, Broker, N> CustomValueWriter<'ctx, 'evt, Broker, N> { @@ -117,10 +117,10 @@ impl<'ctx, 'evt, Broker, N> CustomValueWriter<'ctx, 'evt, Broker, N> { t.format_time(&mut writer) } } -impl<'ctx, 'evt, Broker, N> FieldValueWriter for CustomValueWriter<'ctx, 'evt, Broker, N> +impl<'ctx, 'evt, Reg, N> FieldValueWriter for CustomValueWriter<'ctx, 'evt, Reg, N> where - Broker: 'static, - for<'writer> FmtContext<'ctx, Broker, N>: FormatFields<'writer>, + Reg: Subscriber + for<'a> LookupSpan<'a>, + N: for<'a> FormatFields<'a> + 'static, { fn write_value(&self, mut writer: format::Writer<'_>, field: &'static str) -> fmt::Result { let normalized_meta = self.event.normalized_metadata(); @@ -145,18 +145,13 @@ where Ok(()) } } + /// EAS: Follow strat from `NORMAL_FMT` -/// move Message only and this to formatter.rs and utcoffsettime #[derive(Debug)] pub struct CustomFormatter { fmtr: trace4rs_fmtorp::Fmtr<'static>, } -// SAFETY: -// `CustomFormatter` is safe to sync -unsafe impl Sync for CustomFormatter {} -// SAFETY: -// `CustomFormatter` is safe to send -unsafe impl Send for CustomFormatter {} + impl CustomFormatter { fn new(fmt_str: impl Into>) -> Result { let fmtr = trace4rs_fmtorp::Fmtr::new(fmt_str, &fields::FIELD_SET)?; @@ -164,14 +159,14 @@ impl CustomFormatter { Ok(Self { fmtr }) } - fn format_event<'ctx, 'evt, 'w, S, N>( + fn format_event<'ctx, 'evt, 'w, Reg, N>( &self, - ctx: &FmtContext<'ctx, S, N>, + ctx: &FmtContext<'ctx, Reg, N>, writer: Writer<'w>, event: &Event<'evt>, ) -> fmt::Result where - S: Subscriber + for<'a> LookupSpan<'a>, + Reg: Subscriber + for<'a> LookupSpan<'a>, N: for<'a> FormatFields<'a> + 'static, { let value_writer = CustomValueWriter { ctx, event }; diff --git a/trace4rs/src/handle/inner/layer.rs b/trace4rs/src/handle/inner/layer.rs index ec3ae53..c71f58f 100644 --- a/trace4rs/src/handle/inner/layer.rs +++ b/trace4rs/src/handle/inner/layer.rs @@ -1,4 +1,3 @@ -use derive_where::derive_where; use tracing::{metadata::LevelFilter, Event, Subscriber}; use tracing_log::NormalizeEvent; use tracing_subscriber::{layer::Context, registry::LookupSpan, Layer, Registry}; @@ -11,7 +10,6 @@ use crate::{ error::Result, }; -#[derive_where(Debug)] pub struct T4Layer { enabled: bool, default: Logger, @@ -43,7 +41,6 @@ impl T4Layer { impl T4Layer where Reg: Subscriber + Send + Sync + for<'s> LookupSpan<'s>, - Logger: Layer, { /// The default `Layers` backed by `broker` (`INFO` and above goes to /// stdout). @@ -107,8 +104,7 @@ where impl Layer for T4Layer where - S: Subscriber, - Logger: Layer, + S: Subscriber + for<'s> LookupSpan<'s>, { fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) { if !self.enabled { diff --git a/trace4rs/src/handle/inner/logger.rs b/trace4rs/src/handle/inner/logger.rs index b23b40a..fe5f99a 100644 --- a/trace4rs/src/handle/inner/logger.rs +++ b/trace4rs/src/handle/inner/logger.rs @@ -1,5 +1,5 @@ #![allow(clippy::single_char_lifetime_names)] -use std::{fmt, io}; +use std::io; use tracing::{metadata::LevelFilter, Event, Metadata, Subscriber}; use tracing_subscriber::{ @@ -25,18 +25,10 @@ pub struct Logger { target: Option, layer: FmtLayer, } -impl fmt::Debug for Logger { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!( - f, - "Point {{level: {:?}, target: {:?}}}", - self.level, self.target - ) - } -} + impl Logger where - Reg: Subscriber + for<'a> LookupSpan<'a>, + Reg: Subscriber + for<'s> LookupSpan<'s>, { pub fn new<'a>( level: LevelFilter, @@ -44,9 +36,11 @@ where ids: impl Iterator, appenders: &Appenders, format: EventFormatter, - ) -> Logger { - let writer = Logger::::mk_writer(ids, appenders) - .unwrap_or_else(|| BoxMakeWriter::new(io::sink)); + ) -> Logger + where + Reg: Subscriber + for<'s> LookupSpan<'s>, + { + let writer = mk_writer(ids, appenders).unwrap_or_else(|| BoxMakeWriter::new(io::sink)); let fmt_layer = FmtLayer::default().event_format(format).with_ansi(false); let layer = fmt_layer.with_writer(writer); @@ -60,22 +54,6 @@ where } impl Logger { - fn mk_writer<'a>( - ids: impl Iterator, - appenders: &Appenders, - ) -> Option { - let mut acc_mw = None; - for id in ids { - if let Some(appender) = appenders.get(id).map(ToOwned::to_owned) { - acc_mw = if let Some(acc) = acc_mw.take() { - Some(BoxMakeWriter::new(MakeWriterExt::and(acc, appender))) - } else { - Some(BoxMakeWriter::new(appender)) - } - } - } - acc_mw - } fn is_enabled(&self, meta: &Metadata<'_>) -> bool { let match_level = meta.level() <= &self.level; let match_target = self @@ -100,3 +78,20 @@ where self.layer.on_event(event, ctx); } } + +fn mk_writer<'a>( + ids: impl Iterator, + appenders: &Appenders, +) -> Option { + let mut acc_mw = None; + for id in ids { + if let Some(appender) = appenders.get(id).map(ToOwned::to_owned) { + acc_mw = if let Some(acc) = acc_mw.take() { + Some(BoxMakeWriter::new(MakeWriterExt::and(acc, appender))) + } else { + Some(BoxMakeWriter::new(appender)) + } + } + } + acc_mw +} diff --git a/trace4rs/src/handle/mod.rs b/trace4rs/src/handle/mod.rs index daf0071..b17ac0a 100644 --- a/trace4rs/src/handle/mod.rs +++ b/trace4rs/src/handle/mod.rs @@ -1,4 +1,4 @@ -use std::{fmt, io, sync::Arc}; +use std::sync::Arc; use derive_where::derive_where; use tracing::{Level, Subscriber}; @@ -6,7 +6,7 @@ use tracing_span_tree::SpanTree; use tracing_subscriber::{ filter::{Filtered, Targets}, fmt::MakeWriter, - layer::Layer, + layer::{self, Layer, Layered, SubscriberExt as _}, registry::LookupSpan, reload, Registry, }; @@ -14,49 +14,105 @@ use tracing_subscriber::{ use crate::{config::Config, error::Result}; mod inner; -mod subscriber; use inner::layer::T4Layer; - pub use inner::logger::Logger; -pub use subscriber::T4Subscriber; -use self::subscriber::{FilteredST, LayeredT4Reload}; +pub type T4 = reload::Layer, Reg>; +pub type T4H = reload::Handle, Reg>; +pub type LayeredT4 = Layered, Reg>; +pub type ExtendedT4 = Layered>; + +pub type FilteredST = Filtered, Targets, LayeredT4>; + +pub fn init_with_metrics( + target: impl Into, + w: Wrt, +) -> (Handle, ExtendedT4>) +where + Wrt: for<'a> MakeWriter<'a> + 'static, + Reg: Subscriber + for<'a> LookupSpan<'a> + Default + Send + Sync, +{ + let layer = tracing_span_tree::span_tree_with(w); + let filter = Targets::new().with_target(target, Level::TRACE); + let extra = layer.with_filter(filter); + + Handle::new_with(extra) +} /// The reloadable handle for a `ExtraTraceLogger`, with this we can modify the /// logging configuration at runtime. #[derive_where(Clone)] pub struct Handle { - reload_handle: Arc, Reg>>, + reload_handle: Arc>, } impl Handle where - Reg: Subscriber + for<'s> LookupSpan<'s> + Send + Sync + Default + fmt::Debug, - Logger: Layer, + Reg: Subscriber + for<'s> LookupSpan<'s> + Send + Sync + Default, { - /// Used for when you need a handle, but you don't need a logger. + /// Used for when you need a handle, but you don't need a logger. Should only ever really be useful to satisfy the compiler. #[must_use] - pub fn unit() -> Self { - let (handle, _layer) = Handle::from_layers_mw(T4Layer::default(), io::empty); + pub fn unit() -> Handle { + let (handle, _layer) = Handle::from_layers_with(T4Layer::default(), layer::Identity::new()); handle } + /// Initialize trace4rs without an additional layer #[must_use] - pub fn new_with_mw(w: W) -> (Handle, T4Subscriber>) + pub fn new() -> (Handle, ExtendedT4) { + Handle::new_with(layer::Identity::new()) + } + + /// Initialize trace4rs with an additional layer + pub fn new_with(extra: ExtLyr) -> (Handle, ExtendedT4) where - W: for<'a> MakeWriter<'a> + 'static, + ExtLyr: Layer>, { let layers = T4Layer::default(); - Handle::from_layers_mw(layers, w) + Handle::from_layers_with(layers, extra) } - #[must_use] - pub fn new() -> (Handle, T4Subscriber) { - let layers = T4Layer::default(); + /// Initialize trace4rs from a `Config` + /// + /// # Errors + /// This could fail building the appenders in the config, for example + /// opening a file for write. + pub fn from_config(config: &Config) -> Result<(Handle, ExtendedT4)> { + let layers: T4Layer = T4Layer::from_config(config)?; + Ok(Handle::from_layers_with(layers, layer::Identity::new())) + } - Handle::from_layers_mw(layers, io::stderr) + /// Initialize trace4rs from a `Config` with an additional layer + pub fn from_config_with( + config: &Config, + extra: ExtLyr, + ) -> Result<(Handle, ExtendedT4)> + where + ExtLyr: Layer>, + { + let layers: T4Layer = T4Layer::from_config(config)?; + Ok(Handle::from_layers_with(layers, extra)) + } + + /// Builds `Self` from `Layers` and the backing `Reg`. + fn from_layers_with( + layers: T4Layer, + extra: ExtLyr, + ) -> (Handle, ExtendedT4) + where + ExtLyr: Layer>, + { + let (reloadable, reload_handle) = reload::Layer::new(layers); + let trace_logger = Reg::default().with(reloadable).with(extra); + + ( + Handle { + reload_handle: Arc::new(reload_handle), + }, + trace_logger, + ) } /// Disable the subscriber. @@ -113,62 +169,4 @@ where let ls = T4Layer::from_config(config)?; Ok(self.reload_handle.reload(ls)?) } - - /// Using the given `Registry` we configure and initialize our `Self`. - /// - /// # Errors - /// This could fail building the appenders in the config, for example - /// opening a file for write. - pub fn from_config(config: &Config) -> Result<(Handle, T4Subscriber)> - where - Reg: Subscriber + Send + Sync + for<'s> LookupSpan<'s> + fmt::Debug, - { - let layers: T4Layer = T4Layer::from_config(config)?; - Ok(Self::from_layers_mw(layers, io::stderr)) - } - - /// Builds `Self` from `Layers` and the backing `Reg`. - fn from_layers_mw( - layers: T4Layer, - w: Wrt, - ) -> (Handle, T4Subscriber>) - where - Reg: Subscriber + Send + Sync + fmt::Debug, - Wrt: for<'a> MakeWriter<'a> + 'static, - { - let extra = Self::mk_extra_mw(w); - Handle::from_layers_with_extra(layers, extra) - } - /// Builds `Self` from `Layers` and the backing `Reg`. - fn from_layers_with_extra( - layers: T4Layer, - extra: ExtLyr, - ) -> (Handle, T4Subscriber) - where - Reg: Subscriber + Send + Sync + fmt::Debug, - LayeredT4Reload: Subscriber, - ExtLyr: Layer>, - { - let (reloadable, reload_handle) = reload::Layer::new(layers); - let trace_logger = T4Subscriber::new_with(Reg::default(), reloadable, extra); - - ( - Handle { - reload_handle: Arc::new(reload_handle), - }, - trace_logger, - ) - } - fn mk_extra_mw(w: Wrt) -> Filtered, Targets, R> - where - R: Subscriber + for<'a> LookupSpan<'a> + fmt::Debug, - Wrt: for<'a> MakeWriter<'a> + 'static, - { - let layer = tracing_span_tree::span_tree_with(w); - - let filter = tracing_subscriber::filter::targets::Targets::new() - .with_target("rasp_ffi", Level::TRACE); - - layer.with_filter(filter) - } } diff --git a/trace4rs/src/handle/subscriber.rs b/trace4rs/src/handle/subscriber.rs deleted file mode 100644 index 9788838..0000000 --- a/trace4rs/src/handle/subscriber.rs +++ /dev/null @@ -1,88 +0,0 @@ -use std::{fmt, io}; - -use tracing::{span, Event, Subscriber}; -use tracing_span_tree::SpanTree; -use tracing_subscriber::filter::{Filtered, Targets}; -use tracing_subscriber::layer::SubscriberExt as _; -use tracing_subscriber::Registry; -use tracing_subscriber::{layer::Layered, registry::LookupSpan, reload, Layer}; - -use crate::handle::T4Layer; - -pub type T4Reload = reload::Layer, Reg>; -pub type LayeredT4Reload = Layered, Reg>; -pub type FilteredST = Filtered, Targets, LayeredT4Reload>; - -/// The `tracing::Subscriber` that this crate implements. -pub struct T4Subscriber io::Stderr>> { - inner: Layered>, -} - -impl T4Subscriber { - pub(crate) fn new_with( - broker: Reg, - t4_layer: T4Reload, - extra: ExtLyr, - ) -> T4Subscriber - where - ExtLyr: Layer>, - Reg: Subscriber + for<'a> LookupSpan<'a> + Send + Sync + fmt::Debug, - { - // let inner = t4_layer.with_subscriber(broker).with(extra); - let inner = broker.with(t4_layer).with(extra); - T4Subscriber { inner } - } -} - -// ########## DELEGATION BELOW ########### - -impl<'a, Reg, ExtLyr> LookupSpan<'a> for T4Subscriber -where - LayeredT4Reload: Subscriber + LookupSpan<'a>, - ExtLyr: Layer> + Layer>, -{ - type Data = as LookupSpan<'a>>::Data; - fn register_filter(&mut self) -> tracing_subscriber::filter::FilterId { - self.inner.register_filter() - } - fn span_data(&'a self, id: &span::Id) -> Option { - self.inner.span_data(id) - } -} -impl Subscriber for T4Subscriber -where - ExtLyr: Layer> + 'static, - Reg: Subscriber + for<'a> LookupSpan<'a> + fmt::Debug, -{ - fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool { - Subscriber::enabled(&self.inner, metadata) - } - - fn new_span(&self, span: &span::Attributes<'_>) -> span::Id { - Subscriber::new_span(&self.inner, span) - } - - fn record(&self, span: &span::Id, values: &span::Record<'_>) { - Subscriber::record(&self.inner, span, values); - } - - fn record_follows_from(&self, span: &span::Id, follows: &span::Id) { - Subscriber::record_follows_from(&self.inner, span, follows); - } - - fn event(&self, event: &Event<'_>) { - Subscriber::event(&self.inner, event); - } - - fn enter(&self, span: &span::Id) { - Subscriber::enter(&self.inner, span); - } - - fn try_close(&self, id: span::Id) -> bool { - Subscriber::try_close(&self.inner, id) - } - - fn exit(&self, span: &span::Id) { - Subscriber::exit(&self.inner, span); - } -} diff --git a/trace4rs/src/lib.rs b/trace4rs/src/lib.rs index d5e946c..6f340e7 100644 --- a/trace4rs/src/lib.rs +++ b/trace4rs/src/lib.rs @@ -22,5 +22,5 @@ pub mod error; mod test; pub use appenders::Appender; -pub use handle::{Handle, T4Subscriber}; +pub use handle::{init_with_metrics, Handle}; pub use trace4rs_config::{config, config::Config, error::Error as ConfigError}; From f2c2b42e6da368161bc1abd0b0c849a43feacc60 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Fri, 24 Nov 2023 10:04:36 -0800 Subject: [PATCH 10/23] cleanup --- readme.md | 5 +---- trace4rs/Cargo.toml | 7 ++----- trace4rs/src/handle/mod.rs | 22 +++++++++++++++------- 3 files changed, 18 insertions(+), 16 deletions(-) diff --git a/readme.md b/readme.md index 88d38ef..9c1f56a 100644 --- a/readme.md +++ b/readme.md @@ -18,7 +18,4 @@ See for yourself with `cargo bench --features tracing-macros` ## Todo -- address todos -- refactor impl Handles blocks for dryer Reg and ExtLyr -- add optional layer -- remove debug constraints +- add an example for metrics functionality in lieu of a pub method diff --git a/trace4rs/Cargo.toml b/trace4rs/Cargo.toml index ec43805..45c1976 100644 --- a/trace4rs/Cargo.toml +++ b/trace4rs/Cargo.toml @@ -37,12 +37,9 @@ time = { version = "0.3", features = ["formatting", "macros"] } path-absolutize = "3.0.11" trace4rs-config = { version = "0.5.1", path = "../trace4rs-config" } trace4rs-fmtorp = { version = "0.5.1", path = "../trace4rs-fmtorp" } -# utc-offset = "0.3.0" -utc-offset = { git = "https://github.com/estk/utc_offset" } +utc-offset = "0.4.0" camino = "1.1.2" -rustversion = "1.0.14" -derive-where = "1.2.5" -tracing-span-tree = { path = "../../tracing-span-tree" } +tracing-span-tree = { git = "https://github.com/estk/tracing-span-tree" } [dev-dependencies] criterion = "0.5.0" diff --git a/trace4rs/src/handle/mod.rs b/trace4rs/src/handle/mod.rs index b17ac0a..445cdf6 100644 --- a/trace4rs/src/handle/mod.rs +++ b/trace4rs/src/handle/mod.rs @@ -1,6 +1,5 @@ use std::sync::Arc; -use derive_where::derive_where; use tracing::{Level, Subscriber}; use tracing_span_tree::SpanTree; use tracing_subscriber::{ @@ -25,24 +24,25 @@ pub type ExtendedT4 = Layered>; pub type FilteredST = Filtered, Targets, LayeredT4>; +/// Init a `Handle` and `Subscriber` with span metrics collection. +/// The writer argument is where the said metrics will be written. pub fn init_with_metrics( target: impl Into, - w: Wrt, + writer: Wrt, ) -> (Handle, ExtendedT4>) where Wrt: for<'a> MakeWriter<'a> + 'static, Reg: Subscriber + for<'a> LookupSpan<'a> + Default + Send + Sync, { - let layer = tracing_span_tree::span_tree_with(w); + let layer = tracing_span_tree::span_tree_with(writer); let filter = Targets::new().with_target(target, Level::TRACE); let extra = layer.with_filter(filter); Handle::new_with(extra) } -/// The reloadable handle for a `ExtraTraceLogger`, with this we can modify the -/// logging configuration at runtime. -#[derive_where(Clone)] +/// A handle with convenience functions to reload a trace4rs `Layer`. +/// Methods to produce a handle also produce the `Subscriber` which can be passed to `tracing::set_default_subscriber` etc. pub struct Handle { reload_handle: Arc>, } @@ -96,7 +96,7 @@ where Ok(Handle::from_layers_with(layers, extra)) } - /// Builds `Self` from `Layers` and the backing `Reg`. + /// Builds `Self` from `Layers` and an ExtLyr to be layered on top. fn from_layers_with( layers: T4Layer, extra: ExtLyr, @@ -170,3 +170,11 @@ where Ok(self.reload_handle.reload(ls)?) } } + +impl Clone for Handle { + fn clone(&self) -> Self { + Self { + reload_handle: Arc::clone(&self.reload_handle), + } + } +} From aa2738de66b5c1f46aa1925cee0d85792e170da0 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Mon, 27 Nov 2023 10:48:46 -0800 Subject: [PATCH 11/23] Cleanup Cargo.tomls, renames, tests and benches working --- .github/workflows/ci.yml | 4 +- Cargo.toml | 39 ++++++++++- trace4rs-config/Cargo.toml | 10 +-- trace4rs-fmtorp/Cargo.toml | 4 +- trace4rs/Cargo.toml | 64 +++++++------------ trace4rs/benches/trace4rs_bench.rs | 39 +++++------ trace4rs/src/{handle/mod.rs => handle.rs} | 5 +- trace4rs/src/lib.rs | 1 + .../{handle/inner => subscriber}/formatter.rs | 0 .../src/{handle/inner => subscriber}/layer.rs | 0 .../{handle/inner => subscriber}/logger.rs | 0 .../src/{handle/inner => subscriber}/mod.rs | 0 trace4rs/src/test.rs | 5 +- 13 files changed, 90 insertions(+), 81 deletions(-) rename trace4rs/src/{handle/mod.rs => handle.rs} (98%) rename trace4rs/src/{handle/inner => subscriber}/formatter.rs (100%) rename trace4rs/src/{handle/inner => subscriber}/layer.rs (100%) rename trace4rs/src/{handle/inner => subscriber}/logger.rs (100%) rename trace4rs/src/{handle/inner => subscriber}/mod.rs (100%) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ba7c40c..8f3bc2a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -19,7 +19,7 @@ jobs: strategy: matrix: toolchain: - - nightly-2022-06-25 + - nightly-2023-10-25 steps: - uses: actions/checkout@v3 @@ -51,7 +51,7 @@ jobs: - stable - beta - nightly - - nightly-2022-06-25 + - nightly-2023-10-25 steps: - uses: actions/checkout@v3 diff --git a/Cargo.toml b/Cargo.toml index d883b98..523f031 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ [workspace] -resolver = "1" +resolver = "2" members = ["trace4rs", "trace4rs-config", "trace4rs-fmtorp"] [workspace.package] @@ -21,6 +21,43 @@ opt-level = 1 [profile.dev.package."*"] opt-level = 3 +[workspace.dependencies] +literally = "0.1.3" +log = "0.4.14" +once_cell = "1.8.0" +parking_lot = "0.12.0" +regex = "1.5.4" +thiserror = "1.0.29" +tracing = "0.1.0" +tracing-subscriber = { version = "0.3", features = [ + "std", + "fmt", + "time", + "local-time", + "registry", +] } +tracing-log = "0.2" +time = { version = "0.3", features = ["formatting", "macros"] } +path-absolutize = "3.0.11" +trace4rs-config = { version = "*", path = "trace4rs-config" } +trace4rs-fmtorp = { version = "*", path = "trace4rs-fmtorp" } +utc-offset = "0.4.0" +camino = "1.1.2" +tracing-span-tree = { git = "https://github.com/estk/tracing-span-tree" } +criterion = "0.5.0" +criterion-macro = "0.4.0" +log4rs = "1.0.0" +serde = "1.0.130" +serde_json = "1.0.68" +tempfile = "3.2.0" +tokio = { version = "1.13.0", features = [ + "rt", + "rt-multi-thread", + "macros", + "time", + "fs", +] } + [workspace.lints.clippy] all = "warn" # correctness, sus, style, complexity, perf pedantic = "warn" diff --git a/trace4rs-config/Cargo.toml b/trace4rs-config/Cargo.toml index 0752b04..0f23263 100644 --- a/trace4rs-config/Cargo.toml +++ b/trace4rs-config/Cargo.toml @@ -17,11 +17,11 @@ workspace = true in-order-serialization = ["serde"] [dependencies] -literally = "0.1.3" +literally.workspace = true +thiserror.workspace = true +tracing.workspace = true +serde = { workspace = true, optional = true, features = ["derive"] } schemars = { version = "0.8.3", optional = true } -serde = { version = "1.0.130", optional = true, features = ["derive"] } -thiserror = "1.0.29" -tracing = "0.1.0" [dev-dependencies] -serde_json = "1.0.89" +serde_json.workspace = true diff --git a/trace4rs-fmtorp/Cargo.toml b/trace4rs-fmtorp/Cargo.toml index df71579..2346d36 100644 --- a/trace4rs-fmtorp/Cargo.toml +++ b/trace4rs-fmtorp/Cargo.toml @@ -17,5 +17,5 @@ workspace = true [features] [dependencies] -thiserror = "1.0.33" -tracing-subscriber = "0.3.15" +thiserror.workspace = true +tracing-subscriber.workspace = true diff --git a/trace4rs/Cargo.toml b/trace4rs/Cargo.toml index 45c1976..ad88986 100644 --- a/trace4rs/Cargo.toml +++ b/trace4rs/Cargo.toml @@ -18,48 +18,32 @@ tracing-macros = [] # internal, for benches serde = ["trace4rs-config/serde"] [dependencies] -literally = "0.1.3" -log = "0.4.14" -once_cell = "1.8.0" -parking_lot = "0.12.0" -regex = "1.5.4" -thiserror = "1.0.29" -tracing = "0.1.0" -tracing-subscriber = { version = "0.3", features = [ - "std", - "fmt", - "time", - "local-time", - "registry", -] } -tracing-log = "0.2" -time = { version = "0.3", features = ["formatting", "macros"] } -path-absolutize = "3.0.11" -trace4rs-config = { version = "0.5.1", path = "../trace4rs-config" } -trace4rs-fmtorp = { version = "0.5.1", path = "../trace4rs-fmtorp" } -utc-offset = "0.4.0" -camino = "1.1.2" -tracing-span-tree = { git = "https://github.com/estk/tracing-span-tree" } +literally.workspace = true +log.workspace = true +once_cell.workspace = true +parking_lot.workspace = true +regex.workspace = true +thiserror.workspace = true +tracing.workspace = true +tracing-subscriber.workspace = true +tracing-log.workspace = true +time.workspace = true +path-absolutize.workspace = true +trace4rs-config.workspace = true +trace4rs-fmtorp.workspace = true +utc-offset.workspace = true +camino.workspace = true +tracing-span-tree.workspace = true [dev-dependencies] -criterion = "0.5.0" -criterion-macro = "0.4.0" -literally = "0.1.3" -log4rs = "1.0.0" -serde = "1.0.130" -serde_json = "1.0.68" -static_assertions = "1.1.0" -tempfile = "3.2.0" -tokio = { version = "1.13.0", features = [ - "rt", - "rt-multi-thread", - "macros", - "time", - "fs", -] } -trace4rs-config = { path = "../trace4rs-config", features = [ - "in-order-serialization", -] } +criterion.workspace = true +criterion-macro.workspace = true +log4rs.workspace = true +serde.workspace = true +serde_json.workspace = true +tempfile.workspace = true +tokio.workspace = true +trace4rs-config = { workspace = true, features = ["in-order-serialization"] } [[bench]] name = "trace4rs_bench" diff --git a/trace4rs/benches/trace4rs_bench.rs b/trace4rs/benches/trace4rs_bench.rs index 59c1f8c..ace9b5e 100644 --- a/trace4rs/benches/trace4rs_bench.rs +++ b/trace4rs/benches/trace4rs_bench.rs @@ -1,21 +1,14 @@ -#![feature(custom_test_frameworks, stmt_expr_attributes)] +#![feature(custom_test_frameworks)] #![test_runner(criterion::runner)] use std::env; -use criterion::{ - black_box, - Criterion, -}; +use criterion::{black_box, Criterion}; use trace4rs::{ - config::{ - self, - Format, - Policy, - }, - Config, - Handle, + config::{self, Format, Policy}, + Config, Handle, }; +use tracing::Subscriber; macro_rules! do_log { (target: $target:literal, $($rst:tt)*) => {{ #[cfg(not(feature = "tracing-macros"))] @@ -29,10 +22,10 @@ macro_rules! do_log { fn bench_appenders(c: &mut Criterion) { let tmp_guard = tempfile::tempdir().unwrap(); env::set_current_dir(tmp_guard.path()).unwrap(); - let handle = mk_handle(); + let (_h, s) = mk_handle(); // Create the handle - tracing::subscriber::set_global_default(handle.subscriber()).unwrap(); + tracing::subscriber::set_global_default(s).unwrap(); c.bench_function("tracing_file", |b| { b.iter(|| do_log!(target: "file", "foobar")) }); @@ -41,14 +34,14 @@ fn bench_appenders(c: &mut Criterion) { }); } -fn mk_handle() -> Handle { +fn mk_handle() -> (Handle, impl Subscriber) { let appenders = { let console = config::Appender::console(); let file = config::Appender::File { path: "file.log".to_string(), }; let rolling_file = config::Appender::RollingFile { - path: "rolling_file.log".to_string(), + path: "rolling_file.log".to_string(), policy: Policy { pattern: Some("rolling_file.log.{}".to_string()), max_size_roll_backups: 3, @@ -64,20 +57,20 @@ fn mk_handle() -> Handle { }; let default = config::Logger { - level: config::LevelFilter::INFO, + level: config::LevelFilter::INFO, appenders: literally::hset! {"console"}, - format: Format::default(), + format: Format::default(), }; let loggers = { let file_logger = config::Logger { - level: config::LevelFilter::INFO, + level: config::LevelFilter::INFO, appenders: literally::hset! {"file"}, - format: Format::default(), + format: Format::default(), }; let rolling_file_logger = config::Logger { - level: config::LevelFilter::INFO, + level: config::LevelFilter::INFO, appenders: literally::hset! {"file"}, - format: Format::default(), + format: Format::default(), }; literally::hmap! {"file" => file_logger, "rolling_file" => rolling_file_logger} }; @@ -88,5 +81,5 @@ fn mk_handle() -> Handle { appenders, }; - Handle::try_from(config).unwrap() + Handle::from_config(&config).unwrap() } diff --git a/trace4rs/src/handle/mod.rs b/trace4rs/src/handle.rs similarity index 98% rename from trace4rs/src/handle/mod.rs rename to trace4rs/src/handle.rs index 445cdf6..919392e 100644 --- a/trace4rs/src/handle/mod.rs +++ b/trace4rs/src/handle.rs @@ -12,10 +12,7 @@ use tracing_subscriber::{ use crate::{config::Config, error::Result}; -mod inner; - -use inner::layer::T4Layer; -pub use inner::logger::Logger; +use crate::subscriber::layer::T4Layer; pub type T4 = reload::Layer, Reg>; pub type T4H = reload::Handle, Reg>; diff --git a/trace4rs/src/lib.rs b/trace4rs/src/lib.rs index 6f340e7..290b142 100644 --- a/trace4rs/src/lib.rs +++ b/trace4rs/src/lib.rs @@ -16,6 +16,7 @@ mod appenders; mod env; mod handle; +mod subscriber; pub mod error; #[cfg(test)] diff --git a/trace4rs/src/handle/inner/formatter.rs b/trace4rs/src/subscriber/formatter.rs similarity index 100% rename from trace4rs/src/handle/inner/formatter.rs rename to trace4rs/src/subscriber/formatter.rs diff --git a/trace4rs/src/handle/inner/layer.rs b/trace4rs/src/subscriber/layer.rs similarity index 100% rename from trace4rs/src/handle/inner/layer.rs rename to trace4rs/src/subscriber/layer.rs diff --git a/trace4rs/src/handle/inner/logger.rs b/trace4rs/src/subscriber/logger.rs similarity index 100% rename from trace4rs/src/handle/inner/logger.rs rename to trace4rs/src/subscriber/logger.rs diff --git a/trace4rs/src/handle/inner/mod.rs b/trace4rs/src/subscriber/mod.rs similarity index 100% rename from trace4rs/src/handle/inner/mod.rs rename to trace4rs/src/subscriber/mod.rs diff --git a/trace4rs/src/test.rs b/trace4rs/src/test.rs index 1eb4936..27607d8 100644 --- a/trace4rs/src/test.rs +++ b/trace4rs/src/test.rs @@ -3,12 +3,9 @@ use std::{fs, io::Read}; use trace4rs_config::config::{Appender, Config, Format, LevelFilter, Logger}; -use tracing::Subscriber; use tracing_subscriber::Registry; -use crate::{Handle, T4Subscriber}; - -static_assertions::assert_impl_all!(T4Subscriber: Subscriber, Send, Sync); +use crate::Handle; #[test] fn test_set_global() { From 309ce8a54aaf86bdff4d0b3c3c385871b87926c4 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Mon, 27 Nov 2023 11:08:08 -0800 Subject: [PATCH 12/23] ci update --- .github/workflows/ci.yml | 29 ++++++++++++++--------------- readme.md | 4 ++++ 2 files changed, 18 insertions(+), 15 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 8f3bc2a..f2bdd75 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -21,24 +21,22 @@ jobs: toolchain: - nightly-2023-10-25 steps: - - uses: actions/checkout@v3 - - - name: Update local toolchain - run: | - rustup update ${{ matrix.toolchain }} - rustup default ${{ matrix.toolchain }} - rustup +${{ matrix.toolchain }} component add clippy rustfmt + - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@master + with: + toolchain: ${{ matrix.toolchain }} + components: "clippy, rustfmt" - name: Toolchain info run: | - cargo +${{ matrix.toolchain }} --version --verbose - cargo +${{ matrix.toolchain }} clippy --version - cargo +${{ matrix.toolchain }} fmt --version + cargo --version --verbose + cargo clippy --version + cargo fmt --version - name: Lint run: | - cargo +${{ matrix.toolchain }} fmt -- --check - cargo +${{ matrix.toolchain }} clippy -- -D warnings + cargo fmt -- --check + cargo clippy -- -D warnings cargo: name: Build & Test @@ -53,7 +51,8 @@ jobs: - nightly - nightly-2023-10-25 steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 + - uses: taiki-e/install-action@nextest - name: Update local toolchain run: | @@ -67,7 +66,7 @@ jobs: - name: Test run: | cargo +${{ matrix.toolchain }} check - cargo +${{ matrix.toolchain }} test --all ${{ matrix.features_arg }} + cargo +${{ matrix.toolchain }} nextest --all ${{ matrix.features_arg }} - name: Build run: | @@ -83,7 +82,7 @@ jobs: BENCHER_VERSION: 0.2.27 BENCHER_API_TOKEN: ${{ secrets.BENCHER_API_TOKEN }} steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Install run: | rustup update diff --git a/readme.md b/readme.md index 9c1f56a..03f7c32 100644 --- a/readme.md +++ b/readme.md @@ -15,6 +15,10 @@ performance. However, when using the `tracing` macros vs the `log` macros the appender performance is roughly 2 orders of magnitude larger. See for yourself with `cargo bench --features tracing-macros` +## Dev suggestions + +- `cargo install cargo-binstall` +- `cargo install cargo-nextest` ## Todo From 21dad73a4f30734576411966722ad1bdc0a7826b Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Mon, 27 Nov 2023 11:25:14 -0800 Subject: [PATCH 13/23] ci --- Cargo.toml | 2 ++ trace4rs/benches/log4rs_bench.rs | 16 +++------------- trace4rs/src/env/mod.rs | 5 +---- trace4rs/src/env/test.rs | 5 +---- trace4rs/src/error.rs | 4 ++-- trace4rs/tests/filter.rs | 12 ++---------- trace4rs/tests/fmt.rs | 12 ++---------- trace4rs/tests/serde.rs | 19 ++++++++----------- 8 files changed, 21 insertions(+), 54 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 523f031..d8dc766 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,3 +1,5 @@ +cargo-features = ["workspace-inheritance"] + [workspace] resolver = "2" members = ["trace4rs", "trace4rs-config", "trace4rs-fmtorp"] diff --git a/trace4rs/benches/log4rs_bench.rs b/trace4rs/benches/log4rs_bench.rs index 8cc0bf4..e83156a 100644 --- a/trace4rs/benches/log4rs_bench.rs +++ b/trace4rs/benches/log4rs_bench.rs @@ -3,28 +3,18 @@ use std::env; -use criterion::{ - black_box, - Criterion, -}; +use criterion::{black_box, Criterion}; use log::LevelFilter; use log4rs::{ append::{ console::ConsoleAppender, file::FileAppender, rolling_file::{ - policy::compound::{ - roll::fixed_window::FixedWindowRoller, - trigger::size::SizeTrigger, - }, + policy::compound::{roll::fixed_window::FixedWindowRoller, trigger::size::SizeTrigger}, RollingFileAppender, }, }, - config::{ - Appender, - Logger, - Root, - }, + config::{Appender, Logger, Root}, Handle, }; diff --git a/trace4rs/src/env/mod.rs b/trace4rs/src/env/mod.rs index 0b516ae..fb339b4 100644 --- a/trace4rs/src/env/mod.rs +++ b/trace4rs/src/env/mod.rs @@ -1,9 +1,6 @@ use std::borrow::Cow; -use camino::{ - Utf8Path, - Utf8PathBuf, -}; +use camino::{Utf8Path, Utf8PathBuf}; use regex::Captures; #[cfg(test)] diff --git a/trace4rs/src/env/test.rs b/trace4rs/src/env/test.rs index 6726da2..25a25bf 100644 --- a/trace4rs/src/env/test.rs +++ b/trace4rs/src/env/test.rs @@ -1,7 +1,4 @@ -use std::env::{ - set_var, - var, -}; +use std::env::{set_var, var}; use super::expand_env_vars; diff --git a/trace4rs/src/error.rs b/trace4rs/src/error.rs index bc3d338..5b2c899 100644 --- a/trace4rs/src/error.rs +++ b/trace4rs/src/error.rs @@ -22,14 +22,14 @@ pub enum Error { #[error("Failed to create file at '{path}': {source}")] CreateFailed { - path: Utf8PathBuf, + path: Utf8PathBuf, #[source] source: io::Error, }, #[error("Failed to get metadata for '{path}': {source}")] MetadataFailed { - path: Utf8PathBuf, + path: Utf8PathBuf, #[source] source: io::Error, }, diff --git a/trace4rs/tests/filter.rs b/trace4rs/tests/filter.rs index 57d96ab..dabe2a6 100644 --- a/trace4rs/tests/filter.rs +++ b/trace4rs/tests/filter.rs @@ -1,16 +1,8 @@ #![cfg(feature = "serde")] -use std::{ - env, - fs, - thread::sleep, - time::Duration, -}; +use std::{env, fs, thread::sleep, time::Duration}; use serde_json::json; -use trace4rs::{ - Config, - Handle, -}; +use trace4rs::{Config, Handle}; #[test] fn test_filter() { diff --git a/trace4rs/tests/fmt.rs b/trace4rs/tests/fmt.rs index d63939c..31d3371 100644 --- a/trace4rs/tests/fmt.rs +++ b/trace4rs/tests/fmt.rs @@ -1,16 +1,8 @@ #![cfg(feature = "serde")] -use std::{ - env, - fs, - thread::sleep, - time::Duration, -}; +use std::{env, fs, thread::sleep, time::Duration}; use serde_json::json; -use trace4rs::{ - Config, - Handle, -}; +use trace4rs::{Config, Handle}; #[test] fn test_custom_fmt() { diff --git a/trace4rs/tests/serde.rs b/trace4rs/tests/serde.rs index 5ef5c8a..12d972f 100644 --- a/trace4rs/tests/serde.rs +++ b/trace4rs/tests/serde.rs @@ -2,14 +2,8 @@ use std::convert::TryInto; use trace4rs::{ - config::{ - Appender, - AppenderId, - LevelFilter, - Target, - }, - Config, - Handle, + config::{Appender, AppenderId, LevelFilter, Target}, + Config, Handle, }; #[test] @@ -115,9 +109,12 @@ fn test_de() { assert_eq!(my_target.appenders.iter().next().unwrap(), file1); let file1_appender = parsed.appenders.get(file1).unwrap(); - assert_eq!(file1_appender, &Appender::File { - path: format!("{tmp_path}/foobar.log"), - }); + assert_eq!( + file1_appender, + &Appender::File { + path: format!("{tmp_path}/foobar.log"), + } + ); // now lets convert this to a Handle let _handle: crate::Handle = parsed.try_into().unwrap(); From a55f4dc05c845f45d4a1f71f81df0f67efac50ea Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Mon, 27 Nov 2023 11:31:36 -0800 Subject: [PATCH 14/23] ci updates --- .github/workflows/ci.yml | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f2bdd75..84ed529 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -27,7 +27,7 @@ jobs: toolchain: ${{ matrix.toolchain }} components: "clippy, rustfmt" - - name: Toolchain info + - name: Info run: | cargo --version --verbose cargo clippy --version @@ -52,25 +52,24 @@ jobs: - nightly-2023-10-25 steps: - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@master + with: + toolchain: ${{ matrix.toolchain }} - uses: taiki-e/install-action@nextest - - name: Update local toolchain + - name: Info run: | - rustup update ${{ matrix.toolchain }} - - - name: Toolchain info - run: | - cargo +${{ matrix.toolchain }} --version --verbose - rustc +${{ matrix.toolchain }} --version + cargo --version --verbose + rustc --version - name: Test run: | - cargo +${{ matrix.toolchain }} check - cargo +${{ matrix.toolchain }} nextest --all ${{ matrix.features_arg }} + cargo check + cargo nextest --all ${{ matrix.features_arg }} - name: Build run: | - cargo +${{ matrix.toolchain }} build ${{ matrix.features_arg }} --release + cargo build ${{ matrix.features_arg }} --release benchmark: name: Run benchmarks From 8b4f15fafb7047b781fc3d269ec648fab2fea6e3 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Mon, 27 Nov 2023 13:35:18 -0800 Subject: [PATCH 15/23] pr comments --- trace4rs/src/appenders/rolling.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/trace4rs/src/appenders/rolling.rs b/trace4rs/src/appenders/rolling.rs index 7ff69d6..dea1b65 100644 --- a/trace4rs/src/appenders/rolling.rs +++ b/trace4rs/src/appenders/rolling.rs @@ -91,7 +91,6 @@ impl FixedWindow { // holding max rolls, saturation should be fine if c.saturating_add(1) == self.count { if c == 0 { - // if self.last = Some(0) and self.count = 1: skip break 'outer; } // We skip the last file if we're at the max so it'll get overwritten. From 655bc26323c68008fb5aa8986cf0e56f1788f0ab Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Mon, 27 Nov 2023 13:42:23 -0800 Subject: [PATCH 16/23] ci --- .github/workflows/ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 84ed529..2ddaedd 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -65,11 +65,11 @@ jobs: - name: Test run: | cargo check - cargo nextest --all ${{ matrix.features_arg }} + cargo nextest run --all ${{ matrix.features_arg }} - name: Build run: | - cargo build ${{ matrix.features_arg }} --release + cargo build --release ${{ matrix.features_arg }} benchmark: name: Run benchmarks From e885ef36a7c034c14bd390eb7b0cbaa63f78dab9 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Mon, 27 Nov 2023 14:58:08 -0800 Subject: [PATCH 17/23] serde feature --- trace4rs/tests/filter.rs | 4 ++-- trace4rs/tests/fmt.rs | 4 ++-- trace4rs/tests/serde.rs | 3 +-- 3 files changed, 5 insertions(+), 6 deletions(-) diff --git a/trace4rs/tests/filter.rs b/trace4rs/tests/filter.rs index dabe2a6..23fe8ab 100644 --- a/trace4rs/tests/filter.rs +++ b/trace4rs/tests/filter.rs @@ -42,8 +42,8 @@ fn test_filter() { .unwrap(); let _rt = tokio::runtime::Runtime::new().unwrap(); - let handle = Handle::try_from(conf).unwrap(); - tracing::subscriber::set_global_default(handle.subscriber()).unwrap(); + let (_handle, s) = ::from_config(&conf).unwrap(); + tracing::subscriber::set_global_default(s).unwrap(); tracing_log::LogTracer::init().unwrap(); sleep(Duration::from_millis(100)); diff --git a/trace4rs/tests/fmt.rs b/trace4rs/tests/fmt.rs index 31d3371..ece9859 100644 --- a/trace4rs/tests/fmt.rs +++ b/trace4rs/tests/fmt.rs @@ -37,8 +37,8 @@ fn test_custom_fmt() { .unwrap(); let _rt = tokio::runtime::Runtime::new().unwrap(); - let handle = Handle::try_from(conf).unwrap(); - tracing::subscriber::set_global_default(handle.subscriber()).unwrap(); + let (_handle, s) = ::from_config(&conf).unwrap(); + tracing::subscriber::set_global_default(s).unwrap(); tracing_log::LogTracer::init().unwrap(); sleep(Duration::from_millis(100)); diff --git a/trace4rs/tests/serde.rs b/trace4rs/tests/serde.rs index 12d972f..66d1a9e 100644 --- a/trace4rs/tests/serde.rs +++ b/trace4rs/tests/serde.rs @@ -1,5 +1,4 @@ #![cfg(feature = "serde")] -use std::convert::TryInto; use trace4rs::{ config::{Appender, AppenderId, LevelFilter, Target}, @@ -117,7 +116,7 @@ fn test_de() { ); // now lets convert this to a Handle - let _handle: crate::Handle = parsed.try_into().unwrap(); + let (_handle, _s): (Handle, _) = Handle::from_config(&parsed).unwrap(); } #[test] From 38b71ded5938ebc5556f1c82ec3aec7b14d8841c Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Mon, 27 Nov 2023 15:18:18 -0800 Subject: [PATCH 18/23] ci --- .github/workflows/ci.yml | 1 + rust-toolchain.toml | 2 -- 2 files changed, 1 insertion(+), 2 deletions(-) delete mode 100644 rust-toolchain.toml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 2ddaedd..001472e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -29,6 +29,7 @@ jobs: - name: Info run: | + rustc --version cargo --version --verbose cargo clippy --version cargo fmt --version diff --git a/rust-toolchain.toml b/rust-toolchain.toml deleted file mode 100644 index 292fe49..0000000 --- a/rust-toolchain.toml +++ /dev/null @@ -1,2 +0,0 @@ -[toolchain] -channel = "stable" From 0e85c7fd3a21ccd11d86c12a9c9055cf6ffdb64d Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Mon, 27 Nov 2023 15:59:08 -0800 Subject: [PATCH 19/23] nightly fmt --- .github/workflows/ci.yml | 4 ++ .vscode/settings.json | 13 ++----- trace4rs-config/src/config.rs | 57 ++++++++++++++++++---------- trace4rs-fmtorp/src/lib.rs | 10 +++-- trace4rs/benches/log4rs_bench.rs | 16 ++++++-- trace4rs/benches/trace4rs_bench.rs | 28 +++++++++----- trace4rs/src/appenders/mod.rs | 33 ++++++++++++---- trace4rs/src/appenders/rolling.rs | 37 +++++++++++------- trace4rs/src/appenders/test.rs | 27 ++++++++++--- trace4rs/src/env/mod.rs | 5 ++- trace4rs/src/env/test.rs | 5 ++- trace4rs/src/error.rs | 4 +- trace4rs/src/handle.rs | 34 ++++++++++++----- trace4rs/src/lib.rs | 11 +++++- trace4rs/src/subscriber/formatter.rs | 31 +++++++++++---- trace4rs/src/subscriber/layer.rs | 36 +++++++++++++----- trace4rs/src/subscriber/logger.rs | 27 +++++++++---- trace4rs/src/test.rs | 21 +++++++--- trace4rs/tests/filter.rs | 12 +++++- trace4rs/tests/fmt.rs | 12 +++++- trace4rs/tests/serde.rs | 19 ++++++---- 21 files changed, 313 insertions(+), 129 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 001472e..843b6c2 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -22,6 +22,7 @@ jobs: - nightly-2023-10-25 steps: - uses: actions/checkout@v4 + - uses: streetsidesoftware/cspell-action@v5 - uses: dtolnay/rust-toolchain@master with: toolchain: ${{ matrix.toolchain }} @@ -39,6 +40,9 @@ jobs: cargo fmt -- --check cargo clippy -- -D warnings + - name: Spell + run: cspell --config ./cspell.json "**/*.{rs|md}" + cargo: name: Build & Test runs-on: ubuntu-latest diff --git a/.vscode/settings.json b/.vscode/settings.json index 6baca56..b4a2d88 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,12 +1,5 @@ { - "cSpell.words": [ - "appender", - "appenders", - "fmtorp", - "fmtr", - "hmap", - "Lyrd", - "messageonly", - "targ" - ] + "rust-analyzer.rustfmt.extraArgs": [ + "+nightly" + ], } diff --git a/trace4rs-config/src/config.rs b/trace4rs-config/src/config.rs index fffaec8..ef40561 100644 --- a/trace4rs-config/src/config.rs +++ b/trace4rs-config/src/config.rs @@ -2,7 +2,10 @@ use std::{ borrow::Cow, - collections::{HashMap, HashSet}, + collections::{ + HashMap, + HashSet, + }, result, str::FromStr, }; @@ -10,10 +13,18 @@ use std::{ #[cfg(feature = "schemars")] use schemars::JsonSchema; #[cfg(feature = "serde")] -use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use serde::{ + Deserialize, + Deserializer, + Serialize, + Serializer, +}; use tracing::level_filters; -use crate::error::{Error, Result}; +use crate::error::{ + Error, + Result, +}; /// The root configuration object containing everything necessary to build a /// `trace4rs::Handle`. @@ -23,7 +34,7 @@ use crate::error::{Error, Result}; pub struct Config { /// The default logger, which must be configured. #[cfg_attr(feature = "serde", serde(rename = "root", alias = "default"))] - pub default: Logger, + pub default: Logger, /// Appenders are assigned an id of your choice and configure actual log /// message output. #[cfg_attr( @@ -37,7 +48,7 @@ pub struct Config { feature = "in-order-serialization", serde(serialize_with = "ordered_map") )] - pub loggers: HashMap, + pub loggers: HashMap, } /// # Errors @@ -80,15 +91,18 @@ impl Default for Config { impl Config { /// A configuration for `INFO` and above to be logged to stdout. fn console_config() -> Config { - use literally::{hmap, hset}; + use literally::{ + hmap, + hset, + }; Config { - default: Logger { - level: LevelFilter::INFO, + default: Logger { + level: LevelFilter::INFO, appenders: hset! { "stdout" }, - format: Format::default(), + format: Format::default(), }, - loggers: hmap! {}, + loggers: hmap! {}, appenders: hmap! { "stdout" => Appender::Console }, @@ -135,12 +149,12 @@ pub struct Logger { serde(serialize_with = "ordered_set") )] pub appenders: HashSet, - pub level: LevelFilter, + pub level: LevelFilter, #[cfg_attr( feature = "serde", serde(default = "Format::default", skip_serializing_if = "Format::is_normal") )] - pub format: Format, + pub format: Format, } #[cfg(feature = "serde")] @@ -315,7 +329,7 @@ pub enum Appender { path: String, }, RollingFile { - path: String, + path: String, #[cfg_attr(feature = "serde", serde(rename = "rolloverPolicy"))] policy: Policy, }, @@ -424,15 +438,18 @@ impl Policy { mod test { use literally::hset; - use super::{LevelFilter, Logger}; + use super::{ + LevelFilter, + Logger, + }; use crate::config::Format; #[test] fn test_format_serde() { let lgr = Logger { appenders: hset! {}, - level: LevelFilter::OFF, - format: Format::Normal, + level: LevelFilter::OFF, + format: Format::Normal, }; let lgr_value = dbg!(serde_json::to_value(&lgr).unwrap()); assert!(lgr_value.get("format").is_none()); @@ -441,8 +458,8 @@ mod test { let lgr = Logger { appenders: hset! {}, - level: LevelFilter::OFF, - format: Format::MessageOnly, + level: LevelFilter::OFF, + format: Format::MessageOnly, }; let lgr_value = dbg!(serde_json::to_value(&lgr).unwrap()); let fmt = lgr_value.get("format").unwrap().as_str().unwrap(); @@ -452,8 +469,8 @@ mod test { let lgr = Logger { appenders: hset! {}, - level: LevelFilter::OFF, - format: Format::Custom("foobar".to_string()), + level: LevelFilter::OFF, + format: Format::Custom("foobar".to_string()), }; let lgr_value = dbg!(serde_json::to_value(&lgr).unwrap()); let fmt = lgr_value.get("format").unwrap().as_str().unwrap(); diff --git a/trace4rs-fmtorp/src/lib.rs b/trace4rs-fmtorp/src/lib.rs index ab15dc3..e63e4fc 100644 --- a/trace4rs-fmtorp/src/lib.rs +++ b/trace4rs-fmtorp/src/lib.rs @@ -1,5 +1,9 @@ use core::fmt; -use std::{borrow::Cow, collections::HashSet, ops::RangeInclusive}; +use std::{ + borrow::Cow, + collections::HashSet, + ops::RangeInclusive, +}; use tracing_subscriber::fmt::format; @@ -18,13 +22,13 @@ pub enum Error { #[derive(Debug)] pub struct Fmtr<'fmtstr> { /// The owned or static borrowed format string. - fmt_str: Cow<'fmtstr, str>, + fmt_str: Cow<'fmtstr, str>, /// The ranges indexing `fmt_str` which 1-1 index `ordered_fields`. /// # Invariants /// Ranges are strictly within bounds of fmt_str field_ranges: Vec>, /// The names of fields indexed identically to field_ranges. - field_names: Vec<&'static str>, + field_names: Vec<&'static str>, } impl<'fmtstr> Fmtr<'fmtstr> { /// Unrecognized fields should be an error diff --git a/trace4rs/benches/log4rs_bench.rs b/trace4rs/benches/log4rs_bench.rs index e83156a..8cc0bf4 100644 --- a/trace4rs/benches/log4rs_bench.rs +++ b/trace4rs/benches/log4rs_bench.rs @@ -3,18 +3,28 @@ use std::env; -use criterion::{black_box, Criterion}; +use criterion::{ + black_box, + Criterion, +}; use log::LevelFilter; use log4rs::{ append::{ console::ConsoleAppender, file::FileAppender, rolling_file::{ - policy::compound::{roll::fixed_window::FixedWindowRoller, trigger::size::SizeTrigger}, + policy::compound::{ + roll::fixed_window::FixedWindowRoller, + trigger::size::SizeTrigger, + }, RollingFileAppender, }, }, - config::{Appender, Logger, Root}, + config::{ + Appender, + Logger, + Root, + }, Handle, }; diff --git a/trace4rs/benches/trace4rs_bench.rs b/trace4rs/benches/trace4rs_bench.rs index ace9b5e..8aa7fa4 100644 --- a/trace4rs/benches/trace4rs_bench.rs +++ b/trace4rs/benches/trace4rs_bench.rs @@ -3,10 +3,18 @@ use std::env; -use criterion::{black_box, Criterion}; +use criterion::{ + black_box, + Criterion, +}; use trace4rs::{ - config::{self, Format, Policy}, - Config, Handle, + config::{ + self, + Format, + Policy, + }, + Config, + Handle, }; use tracing::Subscriber; macro_rules! do_log { @@ -41,7 +49,7 @@ fn mk_handle() -> (Handle, impl Subscriber) { path: "file.log".to_string(), }; let rolling_file = config::Appender::RollingFile { - path: "rolling_file.log".to_string(), + path: "rolling_file.log".to_string(), policy: Policy { pattern: Some("rolling_file.log.{}".to_string()), max_size_roll_backups: 3, @@ -57,20 +65,20 @@ fn mk_handle() -> (Handle, impl Subscriber) { }; let default = config::Logger { - level: config::LevelFilter::INFO, + level: config::LevelFilter::INFO, appenders: literally::hset! {"console"}, - format: Format::default(), + format: Format::default(), }; let loggers = { let file_logger = config::Logger { - level: config::LevelFilter::INFO, + level: config::LevelFilter::INFO, appenders: literally::hset! {"file"}, - format: Format::default(), + format: Format::default(), }; let rolling_file_logger = config::Logger { - level: config::LevelFilter::INFO, + level: config::LevelFilter::INFO, appenders: literally::hset! {"file"}, - format: Format::default(), + format: Format::default(), }; literally::hmap! {"file" => file_logger, "rolling_file" => rolling_file_logger} }; diff --git a/trace4rs/src/appenders/mod.rs b/trace4rs/src/appenders/mod.rs index a2450e8..cd2ac72 100644 --- a/trace4rs/src/appenders/mod.rs +++ b/trace4rs/src/appenders/mod.rs @@ -2,22 +2,38 @@ use std::{ collections::HashMap, convert::TryFrom, - fs::{self}, - io::{self, LineWriter, Write}, + fs::{ + self, + }, + io::{ + self, + LineWriter, + Write, + }, ops::Deref, path::Path, sync::Arc, }; -use camino::{Utf8Path, Utf8PathBuf}; +use camino::{ + Utf8Path, + Utf8PathBuf, +}; use parking_lot::Mutex; use path_absolutize::Absolutize; use tracing_subscriber::fmt::MakeWriter; use crate::{ - config::{self, AppenderId, Policy}, + config::{ + self, + AppenderId, + Policy, + }, env::try_expand_env_vars, - error::{Error, Result}, + error::{ + Error, + Result, + }, }; mod rolling; @@ -155,7 +171,10 @@ impl Appender { count: usize, size: &str, ) -> Result { - use rolling::{Roller, Trigger}; + use rolling::{ + Roller, + Trigger, + }; let abs_path = { let ps = path_str.as_ref(); let cp = Utf8Path::new(ps); @@ -280,7 +299,7 @@ impl io::Write for Console { /// An appender which writes to a file. #[derive(Debug)] pub struct File { - path: Utf8PathBuf, + path: Utf8PathBuf, writer: LineWriter, } impl File { diff --git a/trace4rs/src/appenders/rolling.rs b/trace4rs/src/appenders/rolling.rs index dea1b65..4a5c46f 100644 --- a/trace4rs/src/appenders/rolling.rs +++ b/trace4rs/src/appenders/rolling.rs @@ -1,13 +1,24 @@ use std::{ - cmp, fs, - io::{self, LineWriter, Write}, + cmp, + fs, + io::{ + self, + LineWriter, + Write, + }, }; -use camino::{Utf8Path, Utf8PathBuf}; +use camino::{ + Utf8Path, + Utf8PathBuf, +}; use crate::{ env::try_expand_env_vars, - error::{Error, Result}, + error::{ + Error, + Result, + }, }; /// `LogFileMeta` allows us to keep track of an estimated length for a given @@ -58,8 +69,8 @@ impl Trigger { #[derive(Clone, Debug)] pub struct FixedWindow { /// invariant last < count - last: Option, - count: usize, + last: Option, + count: usize, pattern: String, } impl FixedWindow { @@ -164,13 +175,13 @@ impl Roller { /// backups or by deletion. #[derive(Debug)] pub struct Rolling { - path: Utf8PathBuf, + path: Utf8PathBuf, /// Writer will always be some except when it is being rolled or if there /// was an error initing a new writer after abandonment of the previous. - writer: Option>, - meta: LogFileMeta, + writer: Option>, + meta: LogFileMeta, trigger: Trigger, - roller: Roller, + roller: Roller, } impl Rolling { const DEFAULT_FILE_NAME: &'static str = "log"; @@ -189,14 +200,14 @@ impl Rolling { let expanded_path = try_expand_env_vars(p.as_ref()); let (writer, meta) = { let writer = Self::new_writer(&expanded_path).map_err(|e| Error::CreateFailed { - path: expanded_path.clone().into_owned(), + path: expanded_path.clone().into_owned(), source: e, })?; let meta = writer .get_ref() .metadata() .map_err(|e| Error::MetadataFailed { - path: expanded_path.clone().into_owned(), + path: expanded_path.clone().into_owned(), source: e, })?; (writer, LogFileMeta::from_meta(&meta)) @@ -266,7 +277,7 @@ impl Rolling { /// pattern: "{filename}.{}". /// /// ```ignore - /// + /// /// make_qualified_pattern(Path::from("./foo/bar.log"), None); // -> "./foo/bar.log.{}" /// make_qualified_pattern(Path::from("./foo/bar.log"), Some("bar_roll.{}")); // -> "./foo/bar_roll.{}" /// ``` diff --git a/trace4rs/src/appenders/test.rs b/trace4rs/src/appenders/test.rs index cb2a873..375b044 100644 --- a/trace4rs/src/appenders/test.rs +++ b/trace4rs/src/appenders/test.rs @@ -1,10 +1,27 @@ -use std::{fs, io::Write, path::Component, sync::Arc}; - -use camino::{Utf8Component, Utf8Path, Utf8PathBuf}; +use std::{ + fs, + io::Write, + path::Component, + sync::Arc, +}; + +use camino::{ + Utf8Component, + Utf8Path, + Utf8PathBuf, +}; use parking_lot::Mutex; -use super::rolling::{self, Roller, Rolling, Trigger}; -use crate::{appenders::rolling::FixedWindow, Appender}; +use super::rolling::{ + self, + Roller, + Rolling, + Trigger, +}; +use crate::{ + appenders::rolling::FixedWindow, + Appender, +}; fn get_appender(path: &Utf8Path, pattern: &Option) -> Appender { Appender::new_rolling(path.as_str(), pattern.as_deref(), 2, "10 B").unwrap() diff --git a/trace4rs/src/env/mod.rs b/trace4rs/src/env/mod.rs index fb339b4..0b516ae 100644 --- a/trace4rs/src/env/mod.rs +++ b/trace4rs/src/env/mod.rs @@ -1,6 +1,9 @@ use std::borrow::Cow; -use camino::{Utf8Path, Utf8PathBuf}; +use camino::{ + Utf8Path, + Utf8PathBuf, +}; use regex::Captures; #[cfg(test)] diff --git a/trace4rs/src/env/test.rs b/trace4rs/src/env/test.rs index 25a25bf..6726da2 100644 --- a/trace4rs/src/env/test.rs +++ b/trace4rs/src/env/test.rs @@ -1,4 +1,7 @@ -use std::env::{set_var, var}; +use std::env::{ + set_var, + var, +}; use super::expand_env_vars; diff --git a/trace4rs/src/error.rs b/trace4rs/src/error.rs index 5b2c899..bc3d338 100644 --- a/trace4rs/src/error.rs +++ b/trace4rs/src/error.rs @@ -22,14 +22,14 @@ pub enum Error { #[error("Failed to create file at '{path}': {source}")] CreateFailed { - path: Utf8PathBuf, + path: Utf8PathBuf, #[source] source: io::Error, }, #[error("Failed to get metadata for '{path}': {source}")] MetadataFailed { - path: Utf8PathBuf, + path: Utf8PathBuf, #[source] source: io::Error, }, diff --git a/trace4rs/src/handle.rs b/trace4rs/src/handle.rs index 919392e..f81a92d 100644 --- a/trace4rs/src/handle.rs +++ b/trace4rs/src/handle.rs @@ -1,18 +1,32 @@ use std::sync::Arc; -use tracing::{Level, Subscriber}; +use tracing::{ + Level, + Subscriber, +}; use tracing_span_tree::SpanTree; use tracing_subscriber::{ - filter::{Filtered, Targets}, + filter::{ + Filtered, + Targets, + }, fmt::MakeWriter, - layer::{self, Layer, Layered, SubscriberExt as _}, + layer::{ + self, + Layer, + Layered, + SubscriberExt as _, + }, registry::LookupSpan, - reload, Registry, + reload, + Registry, }; -use crate::{config::Config, error::Result}; - -use crate::subscriber::layer::T4Layer; +use crate::{ + config::Config, + error::Result, + subscriber::layer::T4Layer, +}; pub type T4 = reload::Layer, Reg>; pub type T4H = reload::Handle, Reg>; @@ -39,7 +53,8 @@ where } /// A handle with convenience functions to reload a trace4rs `Layer`. -/// Methods to produce a handle also produce the `Subscriber` which can be passed to `tracing::set_default_subscriber` etc. +/// Methods to produce a handle also produce the `Subscriber` which can be +/// passed to `tracing::set_default_subscriber` etc. pub struct Handle { reload_handle: Arc>, } @@ -48,7 +63,8 @@ impl Handle where Reg: Subscriber + for<'s> LookupSpan<'s> + Send + Sync + Default, { - /// Used for when you need a handle, but you don't need a logger. Should only ever really be useful to satisfy the compiler. + /// Used for when you need a handle, but you don't need a logger. Should + /// only ever really be useful to satisfy the compiler. #[must_use] pub fn unit() -> Handle { let (handle, _layer) = Handle::from_layers_with(T4Layer::default(), layer::Identity::new()); diff --git a/trace4rs/src/lib.rs b/trace4rs/src/lib.rs index 290b142..8260f79 100644 --- a/trace4rs/src/lib.rs +++ b/trace4rs/src/lib.rs @@ -23,5 +23,12 @@ pub mod error; mod test; pub use appenders::Appender; -pub use handle::{init_with_metrics, Handle}; -pub use trace4rs_config::{config, config::Config, error::Error as ConfigError}; +pub use handle::{ + init_with_metrics, + Handle, +}; +pub use trace4rs_config::{ + config, + config::Config, + error::Error as ConfigError, +}; diff --git a/trace4rs/src/subscriber/formatter.rs b/trace4rs/src/subscriber/formatter.rs index 695352b..d779175 100644 --- a/trace4rs/src/subscriber/formatter.rs +++ b/trace4rs/src/subscriber/formatter.rs @@ -1,19 +1,34 @@ -use std::{borrow::Cow, fmt}; +use std::{ + borrow::Cow, + fmt, +}; -use crate::config::Format as ConfigFormat; use once_cell::sync::Lazy; use trace4rs_fmtorp::FieldValueWriter; -use tracing::{field::Visit, Event, Subscriber}; +use tracing::{ + field::Visit, + Event, + Subscriber, +}; use tracing_log::NormalizeEvent; use tracing_subscriber::{ fmt::{ - format::{self, Format, Full, Writer}, + format::{ + self, + Format, + Full, + Writer, + }, time::FormatTime, - FmtContext, FormatEvent, FormatFields, + FmtContext, + FormatEvent, + FormatFields, }, registry::LookupSpan, }; +use crate::config::Format as ConfigFormat; + const TIME_FORMAT: time::format_description::well_known::Rfc3339 = time::format_description::well_known::Rfc3339; @@ -100,7 +115,7 @@ mod fields { } struct CustomValueWriter<'ctx, 'evt, Reg, N> { - ctx: &'ctx FmtContext<'ctx, Reg, N>, + ctx: &'ctx FmtContext<'ctx, Reg, N>, event: &'evt Event<'evt>, } impl<'ctx, 'evt, Broker, N> CustomValueWriter<'ctx, 'evt, Broker, N> { @@ -177,8 +192,8 @@ impl CustomFormatter { const MESSAGE_FIELD_NAME: &str = "message"; struct SingleFieldVisitor<'w> { - newline: bool, - writer: Writer<'w>, + newline: bool, + writer: Writer<'w>, field_name: Cow<'static, str>, } impl<'w> SingleFieldVisitor<'w> { diff --git a/trace4rs/src/subscriber/layer.rs b/trace4rs/src/subscriber/layer.rs index c71f58f..50c6ccd 100644 --- a/trace4rs/src/subscriber/layer.rs +++ b/trace4rs/src/subscriber/layer.rs @@ -1,19 +1,36 @@ -use tracing::{metadata::LevelFilter, Event, Subscriber}; +use tracing::{ + metadata::LevelFilter, + Event, + Subscriber, +}; use tracing_log::NormalizeEvent; -use tracing_subscriber::{layer::Context, registry::LookupSpan, Layer, Registry}; +use tracing_subscriber::{ + layer::Context, + registry::LookupSpan, + Layer, + Registry, +}; -use super::formatter::EventFormatter; -use super::logger::Logger; +use super::{ + formatter::EventFormatter, + logger::Logger, +}; use crate::{ - appenders::{Appender, Appenders}, - config::{AppenderId, Config}, + appenders::{ + Appender, + Appenders, + }, + config::{ + AppenderId, + Config, + }, error::Result, }; pub struct T4Layer { - enabled: bool, - default: Logger, - loggers: Vec>, + enabled: bool, + default: Logger, + loggers: Vec>, appenders: Appenders, } @@ -27,6 +44,7 @@ impl T4Layer { pub fn appenders(&self) -> &Appenders { &self.appenders } + /// Disable this subscriber. pub fn disable(&mut self) { self.enabled = false; diff --git a/trace4rs/src/subscriber/logger.rs b/trace4rs/src/subscriber/logger.rs index fe5f99a..9c50484 100644 --- a/trace4rs/src/subscriber/logger.rs +++ b/trace4rs/src/subscriber/logger.rs @@ -1,29 +1,40 @@ #![allow(clippy::single_char_lifetime_names)] use std::io; -use tracing::{metadata::LevelFilter, Event, Metadata, Subscriber}; +use tracing::{ + metadata::LevelFilter, + Event, + Metadata, + Subscriber, +}; use tracing_subscriber::{ fmt::{ format::DefaultFields, - writer::{BoxMakeWriter, MakeWriterExt}, + writer::{ + BoxMakeWriter, + MakeWriterExt, + }, Layer as FmtLayer, }, layer::Context, registry::LookupSpan, - Layer, Registry, + Layer, + Registry, }; +use super::formatter::EventFormatter; use crate::{ appenders::Appenders, - config::{AppenderId, Target}, + config::{ + AppenderId, + Target, + }, }; -use super::formatter::EventFormatter; - pub struct Logger { - level: LevelFilter, + level: LevelFilter, target: Option, - layer: FmtLayer, + layer: FmtLayer, } impl Logger diff --git a/trace4rs/src/test.rs b/trace4rs/src/test.rs index 27607d8..b2372a0 100644 --- a/trace4rs/src/test.rs +++ b/trace4rs/src/test.rs @@ -1,8 +1,17 @@ #![cfg(test)] -use std::{fs, io::Read}; +use std::{ + fs, + io::Read, +}; -use trace4rs_config::config::{Appender, Config, Format, LevelFilter, Logger}; +use trace4rs_config::config::{ + Appender, + Config, + Format, + LevelFilter, + Logger, +}; use tracing_subscriber::Registry; use crate::Handle; @@ -22,14 +31,14 @@ fn test_set_global() { "file" => file, }; let default = Logger { - level: LevelFilter::WARN, + level: LevelFilter::WARN, appenders: literally::hset! {"console"}, - format: Format::default(), + format: Format::default(), }; let l1 = Logger { - level: LevelFilter::INFO, + level: LevelFilter::INFO, appenders: literally::hset! {"file"}, - format: Format::default(), + format: Format::default(), }; let config = Config { default, diff --git a/trace4rs/tests/filter.rs b/trace4rs/tests/filter.rs index 23fe8ab..04c8c9d 100644 --- a/trace4rs/tests/filter.rs +++ b/trace4rs/tests/filter.rs @@ -1,8 +1,16 @@ #![cfg(feature = "serde")] -use std::{env, fs, thread::sleep, time::Duration}; +use std::{ + env, + fs, + thread::sleep, + time::Duration, +}; use serde_json::json; -use trace4rs::{Config, Handle}; +use trace4rs::{ + Config, + Handle, +}; #[test] fn test_filter() { diff --git a/trace4rs/tests/fmt.rs b/trace4rs/tests/fmt.rs index ece9859..33a096a 100644 --- a/trace4rs/tests/fmt.rs +++ b/trace4rs/tests/fmt.rs @@ -1,8 +1,16 @@ #![cfg(feature = "serde")] -use std::{env, fs, thread::sleep, time::Duration}; +use std::{ + env, + fs, + thread::sleep, + time::Duration, +}; use serde_json::json; -use trace4rs::{Config, Handle}; +use trace4rs::{ + Config, + Handle, +}; #[test] fn test_custom_fmt() { diff --git a/trace4rs/tests/serde.rs b/trace4rs/tests/serde.rs index 66d1a9e..d55def0 100644 --- a/trace4rs/tests/serde.rs +++ b/trace4rs/tests/serde.rs @@ -1,8 +1,14 @@ #![cfg(feature = "serde")] use trace4rs::{ - config::{Appender, AppenderId, LevelFilter, Target}, - Config, Handle, + config::{ + Appender, + AppenderId, + LevelFilter, + Target, + }, + Config, + Handle, }; #[test] @@ -108,12 +114,9 @@ fn test_de() { assert_eq!(my_target.appenders.iter().next().unwrap(), file1); let file1_appender = parsed.appenders.get(file1).unwrap(); - assert_eq!( - file1_appender, - &Appender::File { - path: format!("{tmp_path}/foobar.log"), - } - ); + assert_eq!(file1_appender, &Appender::File { + path: format!("{tmp_path}/foobar.log"), + }); // now lets convert this to a Handle let (_handle, _s): (Handle, _) = Handle::from_config(&parsed).unwrap(); From 4d3d85bb10cf8e8909f412c51da71141472fd012 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Mon, 27 Nov 2023 16:07:41 -0800 Subject: [PATCH 20/23] spell --- .github/workflows/ci.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 843b6c2..bc9e599 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -23,6 +23,9 @@ jobs: steps: - uses: actions/checkout@v4 - uses: streetsidesoftware/cspell-action@v5 + with: + files: | + "**/*.{rs,md}" - uses: dtolnay/rust-toolchain@master with: toolchain: ${{ matrix.toolchain }} @@ -40,9 +43,6 @@ jobs: cargo fmt -- --check cargo clippy -- -D warnings - - name: Spell - run: cspell --config ./cspell.json "**/*.{rs|md}" - cargo: name: Build & Test runs-on: ubuntu-latest From 84c134b954c1e109fc76c72b27d8116bcd8323f2 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Mon, 27 Nov 2023 19:08:52 -0800 Subject: [PATCH 21/23] cspell, clippy --- Cargo.toml | 5 +++-- cspell.json | 13 +++++++++++++ trace4rs/src/handle.rs | 6 +++++- trace4rs/src/subscriber/formatter.rs | 8 ++++---- 4 files changed, 25 insertions(+), 7 deletions(-) create mode 100644 cspell.json diff --git a/Cargo.toml b/Cargo.toml index d8dc766..bf78cd2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -61,9 +61,10 @@ tokio = { version = "1.13.0", features = [ ] } [workspace.lints.clippy] -all = "warn" # correctness, sus, style, complexity, perf +all = "warn" # correctness, sus, style, complexity, perf pedantic = "warn" cargo = "warn" +module_name_repetitions = { priority = 1, level = "allow" } assertions_on_result_states = "warn" arithmetic_side_effects = "warn" create_dir = "warn" @@ -74,7 +75,7 @@ filetype_is_file = "warn" format_push_string = "warn" indexing_slicing = "warn" lossy_float_literal = "warn" -mem_forget = "warn" # Use ManuallyDrop +mem_forget = "warn" # Use ManuallyDrop missing_assert_message = "warn" missing_asserts_for_indexing = "warn" multiple_inherent_impl = "warn" diff --git a/cspell.json b/cspell.json new file mode 100644 index 0000000..d878189 --- /dev/null +++ b/cspell.json @@ -0,0 +1,13 @@ +{ + "words": [ + "appender", + "appenders", + "fmtorp", + "fmtr", + "fmtstr", + "hmap", + "Lyrd", + "messageonly", + "targ" + ] +} diff --git a/trace4rs/src/handle.rs b/trace4rs/src/handle.rs index f81a92d..d06c585 100644 --- a/trace4rs/src/handle.rs +++ b/trace4rs/src/handle.rs @@ -98,6 +98,10 @@ where } /// Initialize trace4rs from a `Config` with an additional layer + /// + /// # Errors + /// + /// - `Error::Config`: Failure to interpret the Config object pub fn from_config_with( config: &Config, extra: ExtLyr, @@ -109,7 +113,7 @@ where Ok(Handle::from_layers_with(layers, extra)) } - /// Builds `Self` from `Layers` and an ExtLyr to be layered on top. + /// Builds `Self` from `Layers` and an `ExtLyr` to be layered on top. fn from_layers_with( layers: T4Layer, extra: ExtLyr, diff --git a/trace4rs/src/subscriber/formatter.rs b/trace4rs/src/subscriber/formatter.rs index d779175..c9e12d0 100644 --- a/trace4rs/src/subscriber/formatter.rs +++ b/trace4rs/src/subscriber/formatter.rs @@ -39,7 +39,7 @@ static NORMAL_FMT: Lazy> = pub enum EventFormatter { Normal, MessageOnly, - Custom(CustomFormatter), + Custom(FmtorpFormatter), } impl Default for EventFormatter { @@ -54,7 +54,7 @@ impl From for EventFormatter { ConfigFormat::Normal => Self::Normal, ConfigFormat::MessageOnly => Self::MessageOnly, ConfigFormat::Custom(s) => { - match CustomFormatter::new(s) { + match FmtorpFormatter::new(s) { Ok(c) => Self::Custom(c), #[allow(clippy::print_stderr)] // necessary error surfacing Err(e) => { @@ -163,11 +163,11 @@ where /// EAS: Follow strat from `NORMAL_FMT` #[derive(Debug)] -pub struct CustomFormatter { +pub struct FmtorpFormatter { fmtr: trace4rs_fmtorp::Fmtr<'static>, } -impl CustomFormatter { +impl FmtorpFormatter { fn new(fmt_str: impl Into>) -> Result { let fmtr = trace4rs_fmtorp::Fmtr::new(fmt_str, &fields::FIELD_SET)?; From d8f3d9b18bb32b41d4bbfe7f114c04f8ef53032a Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Mon, 27 Nov 2023 19:30:23 -0800 Subject: [PATCH 22/23] cspell --- .github/workflows/ci.yml | 3 --- Cargo.toml | 2 +- cspell.json | 13 ------------ cspell.yml | 43 ++++++++++++++++++++++++++++++++++++++ readme.md | 2 ++ rustfmt.toml | 2 +- trace4rs-fmtorp/src/lib.rs | 3 ++- 7 files changed, 49 insertions(+), 19 deletions(-) delete mode 100644 cspell.json create mode 100644 cspell.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index bc9e599..7a523c9 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -23,9 +23,6 @@ jobs: steps: - uses: actions/checkout@v4 - uses: streetsidesoftware/cspell-action@v5 - with: - files: | - "**/*.{rs,md}" - uses: dtolnay/rust-toolchain@master with: toolchain: ${{ matrix.toolchain }} diff --git a/Cargo.toml b/Cargo.toml index bf78cd2..904337a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -61,7 +61,7 @@ tokio = { version = "1.13.0", features = [ ] } [workspace.lints.clippy] -all = "warn" # correctness, sus, style, complexity, perf +all = "warn" pedantic = "warn" cargo = "warn" module_name_repetitions = { priority = 1, level = "allow" } diff --git a/cspell.json b/cspell.json deleted file mode 100644 index d878189..0000000 --- a/cspell.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "words": [ - "appender", - "appenders", - "fmtorp", - "fmtr", - "fmtstr", - "hmap", - "Lyrd", - "messageonly", - "targ" - ] -} diff --git a/cspell.yml b/cspell.yml new file mode 100644 index 0000000..f443ab6 --- /dev/null +++ b/cspell.yml @@ -0,0 +1,43 @@ +allowCompoundWords: true +languageSettings: + - languageId: rust + ignoreRegExpList: + - rust-string_binary + - rust-string_raw + - rust-string +patterns: + - name: rust-string + pattern: /(")[^\1]*?\1/g + - name: rust-string-binary + pattern: /\bbr?(").*?\1/gi + - name: rust-string-raw + pattern: /\bu?r#(").*?\1#/gi +dictionaries: + - rust + - cpp + - c + - bash + - python +ignorePaths: + - Cargo.lock + - target +minWordLength: 5 +userWords: + - appender + - appenders + - fmtorp + - fmtr + - fmtstr + - hmap + - hset + - Lyrd + - messageonly + - schemars + - strt + - targ + - thiserror + - strat + - replacen + - stabilized + - Meester + - unseparated diff --git a/readme.md b/readme.md index 03f7c32..e95ea18 100644 --- a/readme.md +++ b/readme.md @@ -22,4 +22,6 @@ See for yourself with `cargo bench --features tracing-macros` ## Todo +- verify cspell working - add an example for metrics functionality in lieu of a pub method +- remove custom_test_frameworks usage diff --git a/rustfmt.toml b/rustfmt.toml index 6643955..f0669d0 100644 --- a/rustfmt.toml +++ b/rustfmt.toml @@ -5,7 +5,7 @@ use_field_init_shorthand = true use_try_shorthand = true match_block_trailing_comma = true -# Nightly options -- once stablilized these will likely get a default of true +# Nightly options -- once stabilized these will likely get a default of true enum_discrim_align_threshold = 10 format_code_in_doc_comments = true # format_generated_files = true diff --git a/trace4rs-fmtorp/src/lib.rs b/trace4rs-fmtorp/src/lib.rs index e63e4fc..6e853bc 100644 --- a/trace4rs-fmtorp/src/lib.rs +++ b/trace4rs-fmtorp/src/lib.rs @@ -123,7 +123,8 @@ impl<'fmtstr> Fmtr<'fmtstr> { #[allow(clippy::indexing_slicing)] write!(writer.by_ref(), "{}", &self.fmt_str[last..*range.start()])?; - // unwrap ok since idxs coming from same vec + // unseparated + // unwrap ok since indexes coming from same vec #[allow(clippy::unwrap_used)] let field = self.field_from_id(i).unwrap(); From 57c08c960cbc336f63e8a980a55f52b17daffe12 Mon Sep 17 00:00:00 2001 From: Evan Simmons Date: Mon, 27 Nov 2023 19:31:55 -0800 Subject: [PATCH 23/23] spell --- cspell.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/cspell.yml b/cspell.yml index f443ab6..e712715 100644 --- a/cspell.yml +++ b/cspell.yml @@ -41,3 +41,6 @@ userWords: - stabilized - Meester - unseparated + - dtolnay + - rustc + - taiki