Rust Tracing

Span

• Logical grouping of related events that can be used to track the flow of execution across threads.
• Spans can be nested

use tracing::{debug, error, info, span, warn, Level};

fn main() {
    tracing_subscriber::fmt::init();

    for file in std::env::args() {
        let span = span!(Level::INFO, "file", fname = file.as_str();
        let _guard = span.enter();

        info!("opening the file");
        let file = std::fs::File::open(file).unwrap();
        info!("reading file contents");
        let mut bytes = vec![];
        file.read(&mut bytes).unwrap();
        info!("parsing file contents");
        // ...
        info!("done with file");
    }
}

Event

• Represents a single point in time in the execution of a program.

Registry

1. Purpose of Registry: The Registry is a core component in the tracing-subscriber crate. Its main purpose is to act as a central store for span data and metadata, without actually recording traces itself.

2. Functionality:

   • Stores span metadata
   • Records relationships between spans
   • Tracks which spans are active and which are closed
   • Provides this information to other layers

3. Role in the Layer system: The Registry serves as the foundation for the Layer system in tracing-subscriber. It implements the Subscriber trait, handling the complex tasks of managing span data, allowing other layers to focus on specific functionalities.

4. Advantages:

   • Separation of concerns: The Registry handles core span management, while other layers can focus on specific tasks like filtering, formatting, or exporting.
   • Reduced duplication: Developers can create new layers that add specific capabilities without reimplementing span management.
   • Flexibility: Users can combine multiple layers to create a custom processing pipeline for their tracing needs.

5. Usage: To use the Registry, you typically create it and then wrap it with other layers. Here’s a basic example:

   use tracing_subscriber::{Registry, EnvFilter, fmt, prelude::*};
   
   // Create a Registry
   let registry = Registry::default();
   
   // Add layers
   let subscriber = registry
       .with(EnvFilter::from_default_env())
       .with(fmt::layer());
   
   // Set the subscriber as global default
   tracing::subscriber::set_global_default(subscriber)
       .expect("Failed to set subscriber");
   

6. Extensibility: The Registry’s design allows for easy extension of tracing functionality. You can create custom layers that interact with the Registry to implement specific behaviors or integrations.

7. Performance: By centralizing span management in the Registry, the tracing system can be more efficient, as layers don’t need to duplicate this functionality.

Would you like me to explain any specific aspect of the Registry in more detail or perhaps show you a more complex example of how it’s used in a tracing setup?

Subscriber

How to set it

• with_default: It sets the current subscriber as the default for current thread. If no such subscriber is set, it will use the global default.
• There’s only ever one subscriber per thread.

Required methods for Subscriber

• enabled: Returns whether a span with the given metadata would be enabled.