#tracing #assertions #predicate


Capturing tracing spans and events, e.g. for testing

2 unstable releases

0.2.0-beta.1 Mar 3, 2024
0.1.0 Dec 9, 2022

#74 in Testing

Download history 161/week @ 2024-01-03 339/week @ 2024-01-10 313/week @ 2024-01-17 116/week @ 2024-01-24 116/week @ 2024-01-31 123/week @ 2024-02-07 167/week @ 2024-02-14 120/week @ 2024-02-21 491/week @ 2024-02-28 295/week @ 2024-03-06 701/week @ 2024-03-13 2248/week @ 2024-03-20 2082/week @ 2024-03-27 2895/week @ 2024-04-03 2303/week @ 2024-04-10 1477/week @ 2024-04-17

9,264 downloads per month
Used in term-transcript



Capturing Tracing Spans and Events

Build Status License: MIT OR Apache-2.0 rust 1.70+ required

Documentation: Docs.rs crate docs (main)

This crate provides a tracing Layer to capture tracing spans and events as they occur. The captured spans and events can then be used for testing assertions (e.g., "Did a span with a specific name / target / … occur? What were its fields? Was the span closed? How many times the span was entered?" and so on).

The crate supports both straightforward assertions on the captured data, and more fluent assertions based on predicates.


Add this to your Crate.toml:

tracing-capture = "0.2.0-beta.1"

Capturing spans for test assertions

use tracing::Level;
use tracing_subscriber::layer::SubscriberExt;
use tracing_capture::{CaptureLayer, SharedStorage};

let subscriber = tracing_subscriber::fmt()
// Add the capturing layer.
let storage = SharedStorage::default();
let subscriber = subscriber.with(CaptureLayer::new(&storage));

// Capture tracing information.
tracing::subscriber::with_default(subscriber, || {
    tracing::info_span!("test", num = 42_i64).in_scope(|| {
        tracing::warn!("I feel disturbance in the Force...");

// Inspect the only captured span.
let storage = storage.lock();
assert_eq!(storage.all_spans().len(), 1);
let span = storage.all_spans().next().unwrap();
assert_eq!(span["num"], 42_i64);
assert_eq!(span.stats().entered, 1);

Predicate-based assertions

use predicates::str::contains;
use tracing::Level;
use tracing_subscriber::{layer::SubscriberExt, Registry};
use tracing_capture::{predicates::*, CaptureLayer, SharedStorage};

let storage = SharedStorage::default();
let subscriber = Registry::default().with(CaptureLayer::new(&storage));
tracing::subscriber::with_default(subscriber, || {
    tracing::info_span!("test_spans").in_scope(|| {
        tracing::warn!(result = 42_i64, "computed");

let storage = storage.lock();
let predicate = level(Level::WARN)
    & message(contains("compute"))
    & field("result", 42_i64);
// Checks that there is a single event satisfying `predicate`.
// ...and that none of spans satisfy similar predicate.

Alternatives / similar tools

  • tracing-test is a lower-level alternative.
  • tracing-fluent-assertions is more similar in intended goals, but differs significantly in API design; the assertions need to be declared before the capture.


Licensed under either of Apache License, Version 2.0 or MIT license at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in tracing-toolbox by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.


~48K SLoC