Struct ConsoleLayer 

pub struct ConsoleLayer<W, F = DefaultStatusFactory, S = DefaultStatus> { /* private fields */ }

A tracing-subscriber layer that formats and prints events to the console.

This layer is responsible for the hierarchical and colorful output, including span timings, status icons, and error propagation. It keeps track of the state of each span and formats messages accordingly.

Implementations

impl<W> ConsoleLayer<W>

pub fn with_writer(make_writer: W) -> Self

Creates a new ConsoleLayer that writes to a custom writer.

This allows for capturing output in tests or redirecting it to a file or other sink.

impl<W, F, S> ConsoleLayer<W, F, S>

pub fn with_status<CustomF, CustomS>( self, status_factory: CustomF, ) -> ConsoleLayer<W, CustomF, CustomS>

where CustomF: StatusFactory<CustomS>, CustomS: Status,

Creates a new ConsoleLayer with a custom status factory.

pub fn with_colors(self, colors: ColorScheme) -> Self

Sets a custom color scheme for the console output.

This allows you to customize the colors used for different elements in the output, such as status icons, tree structure, and messages.

Example

use tracing_scribe::{ConsoleLayer, ColorScheme};
use owo_colors::colors;

let colors = ColorScheme::default()
    .with_success_color(colors::BrightGreen)
    .with_error_color(colors::BrightRed);

let layer = ConsoleLayer::default().with_colors(colors);

Trait Implementations

impl<W: Debug, F: Debug, S: Debug> Debug for ConsoleLayer<W, F, S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ConsoleLayer<fn() -> Stderr>

fn default() -> Self

Creates a new ConsoleLayer that writes to io::stderr.

This is the default constructor and the most common way to create a ConsoleLayer.

impl<S, W, F, St> Layer<S> for ConsoleLayer<W, F, St>

where S: Subscriber + for<'lookup> LookupSpan<'lookup>, W: for<'writer> MakeWriter<'writer> + 'static + Send + Sync, F: StatusFactory<St> + 'static, St: Status + 'static,

fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>)

Called when a new span is created.

This method is called by the tracing framework whenever a new span is created. We use this to extract any relevant fields from the span and attach them to the span’s extensions for later use. This allows us to access fields like extra when the span is entered or closed.

fn on_enter(&self, id: &Id, ctx: Context<'_, S>)

Called when a span is entered.

This is triggered when the tracing instrumentation context is entered. We record the Instant of entry to calculate the span’s duration later. It then prints the formatted header for the span, indicating that a new block of execution has started.

fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>)

Called when an event is dispatched.

This method is the core of the event logging logic. It receives all tracing events and decides how to display them.

• It uses the FieldVisitor to extract relevant data like the message, status, and error details.
• It checks if the event represents a failure (i.e., has a Level::ERROR).
• If an event is a failure, it propagates the failed state to all parent spans.
• It formats and prints the event message, but only for events created with the console! macro or for events that represent an error. This is to avoid printing standard tracing events that are not intended for this layer.

fn on_close(&self, id: Id, ctx: Context<'_, S>)

Called when a span is closed.

When a span’s context is exited, this method is called. It calculates the total duration the span was active by comparing the current Instant with the one stored in on_enter.

It then determines the final status of the span (success or failure) based on whether any errors were reported within it. Finally, it prints the formatted footer for the span, including its total duration and final status.

fn on_register_dispatch(&self, subscriber: &Dispatch)

Performs late initialization when installing this layer as a Subscriber.

fn on_layer(&mut self, subscriber: &mut S)

Performs late initialization when attaching a Layer to a Subscriber.

fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest

Registers a new callsite with this layer, returning whether or not the layer is interested in being notified about the callsite, similarly to Subscriber::register_callsite.

fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool

Returns true if this layer is interested in a span or event with the given metadata in the current Context, similarly to Subscriber::enabled.

fn on_record(&self, _span: &Id, _values: &Record<'_>, _ctx: Context<'_, S>)

Notifies this layer that a span with the given Id recorded the given values.

fn on_follows_from(&self, _span: &Id, _follows: &Id, _ctx: Context<'_, S>)

Notifies this layer that a span with the ID span recorded that it follows from the span with the ID follows.

fn event_enabled(&self, _event: &Event<'_>, _ctx: Context<'_, S>) -> bool

Called before on_event, to determine if on_event should be called.

fn on_exit(&self, _id: &Id, _ctx: Context<'_, S>)

Notifies this layer that the span with the given ID was exited.

fn on_id_change(&self, _old: &Id, _new: &Id, _ctx: Context<'_, S>)

Notifies this layer that a span ID has been cloned, and that the subscriber returned a different ID.

fn and_then<L>(self, layer: L) -> Layered<L, Self, S>

where L: Layer<S>, Self: Sized,

Composes this layer around the given Layer, returning a Layered struct implementing Layer.

fn with_subscriber(self, inner: S) -> Layered<Self, S>

where Self: Sized,

Composes this Layer with the given Subscriber, returning a Layered struct that implements Subscriber.

fn with_filter<F>(self, filter: F) -> Filtered<Self, F, S>

where Self: Sized, F: Filter<S>,

Combines self with a Filter, returning a Filtered layer.

fn boxed(self) -> Box<dyn Layer<S> + Sync + Send>

where Self: Sized + Layer<S> + Send + Sync + 'static, S: Subscriber,

Erases the type of this Layer, returning a Boxed dyn Layer trait object.