tracing-bunyan-formatter

tracing-bunyan-formatter provides two [Layer]s implementation to be used on top of a [tracing] [Subscriber]: - [JsonStorageLayer], to attach contextual information to spans for ease of consumption by downstream [Layer]s, via [JsonStorage] and [Span]'s extensions; - [BunyanFormattingLayer], which emits a bunyan-compatible formatted record upon entering a span, existing a span and event creation.

Important: each span will inherit all fields and properties attached to its parent - this is currently not the behaviour provided by tracing_subscriber::fmt::Layer.

Example

```rust use tracingbunyanformatter::{BunyanFormattingLayer, JsonStorageLayer}; use tracing::instrument; use tracing::info; use tracingsubscriber::Registry; use tracingsubscriber::layer::SubscriberExt;

[instrument]

pub fn aunitofwork(firstparameter: u64) { for i in 0..2 { asubunitofwork(i); } info!(excited = "true", "Tracing is quite cool!"); }

[instrument]

pub fn asubunitofwork(sub_parameter: u64) { info!("Events have the full context of their parent span!"); }

fn main() { let formattinglayer = BunyanFormattingLayer::new("tracingdemo".into(), std::io::stdout); let subscriber = Registry::default() .with(JsonStorageLayer) .with(formattinglayer); tracing::subscriber::setglobal_default(subscriber).unwrap();

info!("Orphan event without a parent span");
a_unit_of_work(2);

} ```

Console output

If you pipe the output in the bunyan CLI:

As a pure-Rust alternative check out the bunyan crate. It includes a CLI binary with similar functionality to the original bunyan CLI written in JavaScript.

Implementation strategy

The layered approach we have pursued is not necessarily the most efficient, but it makes it easier to separate different concerns and re-use common logic across multiple [Layer]s.

While the current crate has no ambition to provide any sort of general purpose framework on top of [tracing-subscriber]'s [Layer] trait, the information collected by [JsonStorageLayer] can be leveraged via its public API by other downstream layers outside of this crate whose main concern is formatting. It significantly lowers the amount of complexity you have to deal with if you are interested in implementing your own formatter, for whatever reason or purpose.

You can also add another enrichment layer following the [JsonStorageLayer] to collect additional information about each span and store it in [JsonStorage]. We could have pursued this compositional approach to add elapsed_milliseconds to each span instead of baking it in [JsonStorage] itself.

Optional features

You can enable the arbitrary_precision feature to handle numbers of arbitrary size losslessly. Be aware of a known issue with untagged deserialization.

valuable

The tracing crate has an unstable feature valuable to enable recording custom composite types like structs and enums. Custom types must implement the valuable crate's Valuable trait, which can be derived with a macro.

To use tracing and tracing-bunyan-formatter with valuable, you must set the following configuration in your binary (as of the current crate versions on 2023-03-29):

1. Enable the feature flag valuable for the tracing dependency.

2. Add the --cfg tracing_unstable arguments to your rustc flags (see tracing's documentation on this). This can be done in a few ways:

   1. Adding the arguments to your binary package's .cargo/config.toml under build.rustflags. See the cargo config reference documentation).

      Example:

      toml [build] rustflags = "--cfg tracing_unstable"

   2. Adding the arguments to the RUSTFLAGS environment variable when you run cargo. See the cargo environment variable docs).

      Example: sh RUSTFLAGS="--cfg tracing_unstable" cargo build

3. Enable the feature flag valuable for the tracing-bunyan-formatter dependency.

4. Add dependency valuable.
5. Optional: if you want to derive the Valuable trait for your custom types, enable the feature flag derive for the valuable dependency.

See more details in the example in examples/valuable.rs.

Testing

Just run cargo test.

To run extra tests with the valuable feature enabled, run:

```sh RUSTFLAGS='--cfg tracingunstable' \ cargo test --target-dir target/debugvaluable --features "valuable valuable/derive"

RUSTFLAGS='--cfg tracingunstable' \ cargo run --example valuable --target-dir target/debugvaluable --features "valuable valuable/derive" ```