From 5048b86a3a83e9e8dcec4112d03523690590f63a Mon Sep 17 00:00:00 2001 From: Hayden Stainsby Date: Thu, 10 Nov 2022 22:39:40 +0100 Subject: [PATCH 01/34] mock: differentiate between mocks and expectations (#2373) The `tracing-mock` crate provides a mock collector (and a subscriber for use by the tests in the `tracing-subscriber` crate) which is able to make assertions about what diagnostics are emitted. These assertions are defined by structs that match on events, span, and their fields and metadata. The structs that matched these objects have been called, up until now, mocks, however this terminology may be misleading, as the created objects don't mock anything. There were two different names for similar functionality with `only()` and `done()` on fields and collectors/subscribers respectively. Using a single name for these may make it easier to onboard onto `tracing-mock`. To reduce confusion, these structs have been split into two categories: mocks and expectations. Additionally, the `done()` function on the `Collector` and `Subscriber` mocks has been replaced with `only()`. This matches the similar function for `ExpectedField`, and may be more intuitive. The mocks replace some component in the tracing ecosystem when a library is under test. The expectations define the assertions we wish to make about traces received by the mocks. Mocks (per module): * collector - `MockCollector`, no change * subscriber - `MockSubscriber`, renamed from `ExpectSubscriber` Expectations (per module): * event - `ExpectedEvent`, renamed from `MockEvent` * span - `ExpectedSpan`, renamed from `MockSpan` * field - `ExpectedField` and `ExpectedFields`, renamed from `MockField` and `Expected`. Also `ExpectedValue` renamed from `MockValue`. * metadata - `ExpectedMetadata`, renamed from `Expected` Refs: #539 --- tracing-attributes/tests/async_fn.rs | 92 ++--- tracing-attributes/tests/destructuring.rs | 54 +-- tracing-attributes/tests/err.rs | 101 +++-- tracing-attributes/tests/fields.rs | 50 +-- tracing-attributes/tests/follows_from.rs | 26 +- tracing-attributes/tests/instrument.rs | 54 +-- tracing-attributes/tests/levels.rs | 96 ++--- tracing-attributes/tests/names.rs | 24 +- tracing-attributes/tests/parents.rs | 14 +- tracing-attributes/tests/ret.rs | 92 ++--- tracing-attributes/tests/targets.rs | 40 +- tracing-futures/src/lib.rs | 104 +++--- tracing-futures/tests/std_future.rs | 54 +-- tracing-mock/src/event.rs | 40 +- tracing-mock/src/expectation.rs | 22 +- tracing-mock/src/field.rs | 88 ++--- tracing-mock/src/layer.rs | 69 ++-- tracing-mock/src/metadata.rs | 19 +- tracing-mock/src/span.rs | 38 +- tracing-mock/src/subscriber.rs | 32 +- ...d_layer_filters_dont_break_other_layers.rs | 20 +- tracing-subscriber/tests/env_filter/main.rs | 152 ++++---- .../tests/env_filter/per_layer.rs | 74 ++-- tracing-subscriber/tests/field_filter.rs | 48 +-- tracing-subscriber/tests/filter_log.rs | 8 +- ...d_layer_filters_dont_break_other_layers.rs | 26 +- .../layer_filter_interests_are_cached.rs | 6 +- .../tests/layer_filters/boxed.rs | 2 +- .../tests/layer_filters/combinators.rs | 2 +- .../tests/layer_filters/filter_scopes.rs | 92 ++--- .../tests/layer_filters/main.rs | 72 ++-- .../tests/layer_filters/per_event.rs | 8 +- .../tests/layer_filters/targets.rs | 2 +- .../tests/layer_filters/trees.rs | 85 +++-- tracing-subscriber/tests/layer_filters/vec.rs | 42 +-- .../multiple_layer_filter_interests_cached.rs | 24 +- tracing-subscriber/tests/same_len_filters.rs | 26 +- ...d_layer_filters_dont_break_other_layers.rs | 20 +- tracing-subscriber/tests/utils.rs | 4 +- .../vec_subscriber_filter_interests_cached.rs | 31 +- tracing/tests/enabled.rs | 4 +- tracing/tests/event.rs | 166 +++++---- tracing/tests/filters_dont_leak.rs | 12 +- tracing/tests/instrument.rs | 22 +- tracing/tests/max_level_hint.rs | 8 +- tracing/tests/multiple_max_level_hints.rs | 18 +- tracing/tests/no_subscriber.rs | 11 +- tracing/tests/scoped_clobbers_default.rs | 4 +- tracing/tests/span.rs | 344 +++++++++--------- tracing/tests/subscriber.rs | 28 +- 50 files changed, 1276 insertions(+), 1194 deletions(-) diff --git a/tracing-attributes/tests/async_fn.rs b/tracing-attributes/tests/async_fn.rs index d6d874ffd7..924d46bed6 100644 --- a/tracing-attributes/tests/async_fn.rs +++ b/tracing-attributes/tests/async_fn.rs @@ -84,16 +84,16 @@ fn repro_1831_2() -> impl Future> { #[test] fn async_fn_only_enters_for_polls() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("test_async_fn")) - .enter(span::mock().named("test_async_fn")) - .event(event::mock().with_fields(field::mock("awaiting").with_value(&true))) - .exit(span::mock().named("test_async_fn")) - .enter(span::mock().named("test_async_fn")) - .exit(span::mock().named("test_async_fn")) - .enter(span::mock().named("test_async_fn")) - .exit(span::mock().named("test_async_fn")) - .drop_span(span::mock().named("test_async_fn")) - .done() + .new_span(span::expect().named("test_async_fn")) + .enter(span::expect().named("test_async_fn")) + .event(event::expect().with_fields(field::expect("awaiting").with_value(&true))) + .exit(span::expect().named("test_async_fn")) + .enter(span::expect().named("test_async_fn")) + .exit(span::expect().named("test_async_fn")) + .enter(span::expect().named("test_async_fn")) + .exit(span::expect().named("test_async_fn")) + .drop_span(span::expect().named("test_async_fn")) + .only() .run_with_handle(); with_default(subscriber, || { block_on_future(async { test_async_fn(2).await }).unwrap(); @@ -113,14 +113,14 @@ fn async_fn_nested() { tracing::trace!(nested = true); } - let span = span::mock().named("test_async_fns_nested"); - let span2 = span::mock().named("test_async_fns_nested_other"); + let span = span::expect().named("test_async_fns_nested"); + let span2 = span::expect().named("test_async_fns_nested_other"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .new_span(span2.clone()) .enter(span2.clone()) - .event(event::mock().with_fields(field::mock("nested").with_value(&true))) + .event(event::expect().with_fields(field::expect("nested").with_value(&true))) .exit(span2.clone()) .enter(span2.clone()) .exit(span2.clone()) @@ -129,7 +129,7 @@ fn async_fn_nested() { .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -191,26 +191,26 @@ fn async_fn_with_async_trait() { } } - let span = span::mock().named("foo"); - let span2 = span::mock().named("bar"); - let span3 = span::mock().named("baz"); + let span = span::expect().named("foo"); + let span2 = span::expect().named("bar"); + let span3 = span::expect().named("baz"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::mock("self")) - .with_field(field::mock("v")), + .with_field(field::expect("self")) + .with_field(field::expect("v")), ) .enter(span.clone()) .new_span(span3.clone()) .enter(span3.clone()) - .event(event::mock().with_fields(field::mock("val").with_value(&2u64))) + .event(event::expect().with_fields(field::expect("val").with_value(&2u64))) .exit(span3.clone()) .enter(span3.clone()) .exit(span3.clone()) .drop_span(span3) - .new_span(span2.clone().with_field(field::mock("self"))) + .new_span(span2.clone().with_field(field::expect("self"))) .enter(span2.clone()) - .event(event::mock().with_fields(field::mock("val").with_value(&5u64))) + .event(event::expect().with_fields(field::expect("val").with_value(&5u64))) .exit(span2.clone()) .enter(span2.clone()) .exit(span2.clone()) @@ -219,7 +219,7 @@ fn async_fn_with_async_trait() { .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -255,15 +255,15 @@ fn async_fn_with_async_trait_and_fields_expressions() { async fn call(&mut self, _v: usize) {} } - let span = span::mock().named("call"); + let span = span::expect().named("call"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("_v") + field::expect("_v") .with_value(&5usize) - .and(field::mock("test").with_value(&tracing::field::debug(10))) - .and(field::mock("val").with_value(&42u64)) - .and(field::mock("val2").with_value(&42u64)), + .and(field::expect("test").with_value(&tracing::field::debug(10))) + .and(field::expect("val").with_value(&42u64)) + .and(field::expect("val2").with_value(&42u64)), ), ) .enter(span.clone()) @@ -271,7 +271,7 @@ fn async_fn_with_async_trait_and_fields_expressions() { .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -322,27 +322,27 @@ fn async_fn_with_async_trait_and_fields_expressions_with_generic_parameter() { async fn call_with_mut_self(&mut self) {} } - //let span = span::mock().named("call"); - let span2 = span::mock().named("call_with_self"); - let span3 = span::mock().named("call_with_mut_self"); - let span4 = span::mock().named("sync_fun"); + //let span = span::expect().named("call"); + let span2 = span::expect().named("call_with_self"); + let span3 = span::expect().named("call_with_mut_self"); + let span4 = span::expect().named("sync_fun"); let (subscriber, handle) = subscriber::mock() /*.new_span(span.clone() .with_field( - field::mock("Self").with_value(&"TestImpler"))) + field::expect("Self").with_value(&"TestImpler"))) .enter(span.clone()) .exit(span.clone()) .drop_span(span)*/ .new_span( span2 .clone() - .with_field(field::mock("Self").with_value(&std::any::type_name::())), + .with_field(field::expect("Self").with_value(&std::any::type_name::())), ) .enter(span2.clone()) .new_span( span4 .clone() - .with_field(field::mock("Self").with_value(&std::any::type_name::())), + .with_field(field::expect("Self").with_value(&std::any::type_name::())), ) .enter(span4.clone()) .exit(span4.clone()) @@ -355,14 +355,14 @@ fn async_fn_with_async_trait_and_fields_expressions_with_generic_parameter() { .new_span( span3 .clone() - .with_field(field::mock("Self").with_value(&std::any::type_name::())), + .with_field(field::expect("Self").with_value(&std::any::type_name::())), ) .enter(span3.clone()) .exit(span3.clone()) .enter(span3.clone()) .exit(span3.clone()) .drop_span(span3) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -397,7 +397,7 @@ fn out_of_scope_fields() { } } - let span = span::mock().named("call"); + let span = span::expect().named("call"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) @@ -405,7 +405,7 @@ fn out_of_scope_fields() { .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -430,8 +430,8 @@ fn manual_impl_future() { } } - let span = span::mock().named("manual_impl_future"); - let poll_event = || event::mock().with_fields(field::mock("poll").with_value(&true)); + let span = span::expect().named("manual_impl_future"); + let poll_event = || event::expect().with_fields(field::expect("poll").with_value(&true)); let (subscriber, handle) = subscriber::mock() // await manual_impl_future @@ -442,7 +442,7 @@ fn manual_impl_future() { .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -463,8 +463,8 @@ fn manual_box_pin() { }) } - let span = span::mock().named("manual_box_pin"); - let poll_event = || event::mock().with_fields(field::mock("poll").with_value(&true)); + let span = span::expect().named("manual_box_pin"); + let poll_event = || event::expect().with_fields(field::expect("poll").with_value(&true)); let (subscriber, handle) = subscriber::mock() // await manual_box_pin @@ -475,7 +475,7 @@ fn manual_box_pin() { .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-attributes/tests/destructuring.rs b/tracing-attributes/tests/destructuring.rs index 09cf1ad534..6adbe501c3 100644 --- a/tracing-attributes/tests/destructuring.rs +++ b/tracing-attributes/tests/destructuring.rs @@ -7,21 +7,21 @@ fn destructure_tuples() { #[instrument] fn my_fn((arg1, arg2): (usize, usize)) {} - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -36,23 +36,23 @@ fn destructure_nested_tuples() { #[instrument] fn my_fn(((arg1, arg2), (arg3, arg4)): ((usize, usize), (usize, usize))) {} - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) - .and(field::mock("arg3").with_value(&format_args!("3"))) - .and(field::mock("arg4").with_value(&format_args!("4"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg3").with_value(&format_args!("3"))) + .and(field::expect("arg4").with_value(&format_args!("4"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -67,17 +67,17 @@ fn destructure_refs() { #[instrument] fn my_fn(&arg1: &usize) {} - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::mock("arg1").with_value(&1usize).only()), + .with_field(field::expect("arg1").with_value(&1usize).only()), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -94,21 +94,21 @@ fn destructure_tuple_structs() { #[instrument] fn my_fn(Foo(arg1, arg2): Foo) {} - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -135,21 +135,21 @@ fn destructure_structs() { let _ = (arg1, arg2); } - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -180,23 +180,23 @@ fn destructure_everything() { let _ = (arg1, arg2, arg3, arg4); } - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) - .and(field::mock("arg3").with_value(&format_args!("3"))) - .and(field::mock("arg4").with_value(&format_args!("4"))) + .and(field::expect("arg2").with_value(&format_args!("2"))) + .and(field::expect("arg3").with_value(&format_args!("3"))) + .and(field::expect("arg4").with_value(&format_args!("4"))) .only(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-attributes/tests/err.rs b/tracing-attributes/tests/err.rs index 485dd11961..23b28804af 100644 --- a/tracing-attributes/tests/err.rs +++ b/tracing-attributes/tests/err.rs @@ -21,19 +21,40 @@ fn err_suspicious_else() -> Result { #[test] fn test() { - let span = span::mock().named("err"); + let span = span::expect().named("err"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err().ok()); handle.assert_finished(); } +#[instrument(err)] +fn err_early_return() -> Result { + u8::try_from(1234)?; + Ok(5) +} + +#[test] +fn test_early_return() { + let span = span::expect().named("err_early_return"); + let (subscriber, handle) = subscriber::mock() + .new_span(span.clone()) + .enter(span.clone()) + .event(event::expect().at_level(Level::ERROR)) + .exit(span.clone()) + .drop_span(span) + .only() + .run_with_handle(); + with_default(subscriber, || err_early_return().ok()); + handle.assert_finished(); +} + #[instrument(err)] async fn err_async(polls: usize) -> Result { let future = PollN::new_ok(polls); @@ -44,23 +65,23 @@ async fn err_async(polls: usize) -> Result { #[test] fn test_async() { - let span = span::mock().named("err_async"); + let span = span::expect().named("err_async"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("awaiting").with_value(&true)) + event::expect() + .with_fields(field::expect("awaiting").with_value(&true)) .at_level(Level::TRACE), ) .exit(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR)) .exit(span.clone()) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { block_on_future(async { err_async(2).await }).ok(); @@ -76,14 +97,14 @@ fn err_mut(out: &mut u8) -> Result<(), TryFromIntError> { #[test] fn test_mut() { - let span = span::mock().named("err_mut"); + let span = span::expect().named("err_mut"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err_mut(&mut 0).ok()); handle.assert_finished(); @@ -100,23 +121,23 @@ async fn err_mut_async(polls: usize, out: &mut u8) -> Result<(), TryFromIntError #[test] fn test_mut_async() { - let span = span::mock().named("err_mut_async"); + let span = span::expect().named("err_mut_async"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("awaiting").with_value(&true)) + event::expect() + .with_fields(field::expect("awaiting").with_value(&true)) .at_level(Level::TRACE), ) .exit(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR)) .exit(span.clone()) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { block_on_future(async { err_mut_async(2, &mut 0).await }).ok(); @@ -133,17 +154,17 @@ fn impl_trait_return_type() { Ok(0..x) } - let span = span::mock().named("returns_impl_trait"); + let span = span::expect().named("returns_impl_trait"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::mock("x").with_value(&10usize).only()), + .with_field(field::expect("x").with_value(&10usize).only()), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -162,13 +183,13 @@ fn err_dbg() -> Result { #[test] fn test_err_dbg() { - let span = span::mock().named("err_dbg"); + let span = span::expect().named("err_dbg"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock().at_level(Level::ERROR).with_fields( - field::mock("error") + event::expect().at_level(Level::ERROR).with_fields( + field::expect("error") // use the actual error value that will be emitted, so // that this test doesn't break if the standard library // changes the `fmt::Debug` output from the error type @@ -178,7 +199,7 @@ fn test_err_dbg() { ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err_dbg().ok()); handle.assert_finished(); @@ -186,20 +207,20 @@ fn test_err_dbg() { #[test] fn test_err_display_default() { - let span = span::mock().named("err"); + let span = span::expect().named("err"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock().at_level(Level::ERROR).with_fields( - field::mock("error") + event::expect().at_level(Level::ERROR).with_fields( + field::expect("error") // by default, errors will be emitted with their display values .with_value(&tracing::field::display(u8::try_from(1234).unwrap_err())), ), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err().ok()); handle.assert_finished(); @@ -208,19 +229,19 @@ fn test_err_display_default() { #[test] fn test_err_custom_target() { let filter: EnvFilter = "my_target=error".parse().expect("filter should parse"); - let span = span::mock().named("error_span").with_target("my_target"); + let span = span::expect().named("error_span").with_target("my_target"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() + event::expect() .at_level(Level::ERROR) .with_target("my_target"), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -243,14 +264,14 @@ fn err_info() -> Result { #[test] fn test_err_info() { - let span = span::mock().named("err_info"); + let span = span::expect().named("err_info"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::INFO)) + .event(event::expect().at_level(Level::INFO)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err_info().ok()); handle.assert_finished(); @@ -263,13 +284,13 @@ fn err_dbg_info() -> Result { #[test] fn test_err_dbg_info() { - let span = span::mock().named("err_dbg_info"); + let span = span::expect().named("err_dbg_info"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock().at_level(Level::INFO).with_fields( - field::mock("error") + event::expect().at_level(Level::INFO).with_fields( + field::expect("error") // use the actual error value that will be emitted, so // that this test doesn't break if the standard library // changes the `fmt::Debug` output from the error type @@ -279,7 +300,7 @@ fn test_err_dbg_info() { ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err_dbg_info().ok()); handle.assert_finished(); @@ -292,14 +313,14 @@ fn err_warn_info() -> Result { #[test] fn test_err_warn_info() { - let span = span::mock().named("err_warn_info").at_level(Level::WARN); + let span = span::expect().named("err_warn_info").at_level(Level::WARN); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::INFO)) + .event(event::expect().at_level(Level::INFO)) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || err_warn_info().ok()); handle.assert_finished(); diff --git a/tracing-attributes/tests/fields.rs b/tracing-attributes/tests/fields.rs index c178fbb3d3..5911b393b7 100644 --- a/tracing-attributes/tests/fields.rs +++ b/tracing-attributes/tests/fields.rs @@ -1,6 +1,6 @@ use tracing::subscriber::with_default; use tracing_attributes::instrument; -use tracing_mock::field::mock; +use tracing_mock::field::expect; use tracing_mock::span::NewSpan; use tracing_mock::*; @@ -48,11 +48,11 @@ impl HasField { #[test] fn fields() { - let span = span::mock().with_field( - mock("foo") + let span = span::expect().with_field( + expect("foo") .with_value(&"bar") - .and(mock("dsa").with_value(&true)) - .and(mock("num").with_value(&1)) + .and(expect("dsa").with_value(&true)) + .and(expect("num").with_value(&1)) .only(), ); run_test(span, || { @@ -62,10 +62,10 @@ fn fields() { #[test] fn expr_field() { - let span = span::mock().with_field( - mock("s") + let span = span::expect().with_field( + expect("s") .with_value(&"hello world") - .and(mock("len").with_value(&"hello world".len())) + .and(expect("len").with_value(&"hello world".len())) .only(), ); run_test(span, || { @@ -75,11 +75,11 @@ fn expr_field() { #[test] fn two_expr_fields() { - let span = span::mock().with_field( - mock("s") + let span = span::expect().with_field( + expect("s") .with_value(&"hello world") - .and(mock("s.len").with_value(&"hello world".len())) - .and(mock("s.is_empty").with_value(&false)) + .and(expect("s.len").with_value(&"hello world".len())) + .and(expect("s.is_empty").with_value(&false)) .only(), ); run_test(span, || { @@ -89,19 +89,19 @@ fn two_expr_fields() { #[test] fn clashy_expr_field() { - let span = span::mock().with_field( + let span = span::expect().with_field( // Overriding the `s` field should record `s` as a `Display` value, // rather than as a `Debug` value. - mock("s") + expect("s") .with_value(&tracing::field::display("hello world")) - .and(mock("s.len").with_value(&"hello world".len())) + .and(expect("s.len").with_value(&"hello world".len())) .only(), ); run_test(span, || { fn_clashy_expr_field("hello world"); }); - let span = span::mock().with_field(mock("s").with_value(&"s").only()); + let span = span::expect().with_field(expect("s").with_value(&"s").only()); run_test(span, || { fn_clashy_expr_field2("hello world"); }); @@ -109,7 +109,7 @@ fn clashy_expr_field() { #[test] fn self_expr_field() { - let span = span::mock().with_field(mock("my_field").with_value(&"hello world").only()); + let span = span::expect().with_field(expect("my_field").with_value(&"hello world").only()); run_test(span, || { let has_field = HasField { my_field: "hello world", @@ -120,10 +120,10 @@ fn self_expr_field() { #[test] fn parameters_with_fields() { - let span = span::mock().with_field( - mock("foo") + let span = span::expect().with_field( + expect("foo") .with_value(&"bar") - .and(mock("param").with_value(&1u32)) + .and(expect("param").with_value(&1u32)) .only(), ); run_test(span, || { @@ -133,7 +133,7 @@ fn parameters_with_fields() { #[test] fn empty_field() { - let span = span::mock().with_field(mock("foo").with_value(&"bar").only()); + let span = span::expect().with_field(expect("foo").with_value(&"bar").only()); run_test(span, || { fn_empty_field(); }); @@ -141,7 +141,7 @@ fn empty_field() { #[test] fn string_field() { - let span = span::mock().with_field(mock("s").with_value(&"hello world").only()); + let span = span::expect().with_field(expect("s").with_value(&"hello world").only()); run_test(span, || { fn_string(String::from("hello world")); }); @@ -150,9 +150,9 @@ fn string_field() { fn run_test T, T>(span: NewSpan, fun: F) { let (subscriber, handle) = subscriber::mock() .new_span(span) - .enter(span::mock()) - .exit(span::mock()) - .done() + .enter(span::expect()) + .exit(span::expect()) + .only() .run_with_handle(); with_default(subscriber, fun); diff --git a/tracing-attributes/tests/follows_from.rs b/tracing-attributes/tests/follows_from.rs index a589409ded..4295442865 100644 --- a/tracing-attributes/tests/follows_from.rs +++ b/tracing-attributes/tests/follows_from.rs @@ -13,10 +13,10 @@ fn follows_from_current() {} #[test] fn follows_from_sync_test() { - let cause_a = span::mock().named("cause_a"); - let cause_b = span::mock().named("cause_b"); - let cause_c = span::mock().named("cause_c"); - let consequence = span::mock().named("with_follows_from_sync"); + let cause_a = span::expect().named("cause_a"); + let cause_b = span::expect().named("cause_b"); + let cause_c = span::expect().named("cause_c"); + let consequence = span::expect().named("with_follows_from_sync"); let (subscriber, handle) = subscriber::mock() .new_span(cause_a.clone()) @@ -28,7 +28,7 @@ fn follows_from_sync_test() { .follows_from(consequence.clone(), cause_c) .enter(consequence.clone()) .exit(consequence) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -44,10 +44,10 @@ fn follows_from_sync_test() { #[test] fn follows_from_async_test() { - let cause_a = span::mock().named("cause_a"); - let cause_b = span::mock().named("cause_b"); - let cause_c = span::mock().named("cause_c"); - let consequence = span::mock().named("with_follows_from_async"); + let cause_a = span::expect().named("cause_a"); + let cause_b = span::expect().named("cause_b"); + let cause_c = span::expect().named("cause_c"); + let consequence = span::expect().named("with_follows_from_async"); let (subscriber, handle) = subscriber::mock() .new_span(cause_a.clone()) @@ -61,7 +61,7 @@ fn follows_from_async_test() { .exit(consequence.clone()) .enter(consequence.clone()) .exit(consequence) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -79,8 +79,8 @@ fn follows_from_async_test() { #[test] fn follows_from_current_test() { - let cause = span::mock().named("cause"); - let consequence = span::mock().named("follows_from_current"); + let cause = span::expect().named("cause"); + let consequence = span::expect().named("follows_from_current"); let (subscriber, handle) = subscriber::mock() .new_span(cause.clone()) @@ -90,7 +90,7 @@ fn follows_from_current_test() { .enter(consequence.clone()) .exit(consequence) .exit(cause) - .done() + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-attributes/tests/instrument.rs b/tracing-attributes/tests/instrument.rs index b215b8455d..41b853c8e0 100644 --- a/tracing-attributes/tests/instrument.rs +++ b/tracing-attributes/tests/instrument.rs @@ -20,11 +20,11 @@ fn override_everything() { #[instrument(level = Level::DEBUG, target = "my_target")] fn my_other_fn() {} - let span = span::mock() + let span = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::mock() + let span2 = span::expect() .named("my_other_fn") .at_level(Level::DEBUG) .with_target("my_target"); @@ -37,7 +37,7 @@ fn override_everything() { .enter(span2.clone()) .exit(span2.clone()) .drop_span(span2) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -53,21 +53,21 @@ fn fields() { #[instrument(target = "my_target", level = "debug")] fn my_fn(arg1: usize, arg2: bool) {} - let span = span::mock() + let span = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::mock() + let span2 = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&2usize) - .and(field::mock("arg2").with_value(&false)) + .and(field::expect("arg2").with_value(&false)) .only(), ), ) @@ -76,16 +76,16 @@ fn fields() { .drop_span(span) .new_span( span2.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&3usize) - .and(field::mock("arg2").with_value(&true)) + .and(field::expect("arg2").with_value(&true)) .only(), ), ) .enter(span2.clone()) .exit(span2.clone()) .drop_span(span2) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -106,17 +106,17 @@ fn skip() { #[instrument(target = "my_target", level = "debug", skip_all)] fn my_fn2(_arg1: usize, _arg2: UnDebug, _arg3: UnDebug) {} - let span = span::mock() + let span = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::mock() + let span2 = span::expect() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span3 = span::mock() + let span3 = span::expect() .named("my_fn2") .at_level(Level::DEBUG) .with_target("my_target"); @@ -124,7 +124,7 @@ fn skip() { let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::mock("arg1").with_value(&2usize).only()), + .with_field(field::expect("arg1").with_value(&2usize).only()), ) .enter(span.clone()) .exit(span.clone()) @@ -132,7 +132,7 @@ fn skip() { .new_span( span2 .clone() - .with_field(field::mock("arg1").with_value(&3usize).only()), + .with_field(field::expect("arg1").with_value(&3usize).only()), ) .enter(span2.clone()) .exit(span2.clone()) @@ -141,7 +141,7 @@ fn skip() { .enter(span3.clone()) .exit(span3.clone()) .drop_span(span3) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -165,20 +165,20 @@ fn generics() { { } - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + field::expect("arg1") .with_value(&format_args!("Foo")) - .and(field::mock("arg2").with_value(&format_args!("false"))), + .and(field::expect("arg2").with_value(&format_args!("false"))), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -198,20 +198,20 @@ fn methods() { fn my_fn(&self, arg1: usize) {} } - let span = span::mock().named("my_fn"); + let span = span::expect().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("self") + field::expect("self") .with_value(&format_args!("Foo")) - .and(field::mock("arg1").with_value(&42usize)), + .and(field::expect("arg1").with_value(&42usize)), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -229,17 +229,17 @@ fn impl_trait_return_type() { 0..x } - let span = span::mock().named("returns_impl_trait"); + let span = span::expect().named("returns_impl_trait"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::mock("x").with_value(&10usize).only()), + .with_field(field::expect("x").with_value(&10usize).only()), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-attributes/tests/levels.rs b/tracing-attributes/tests/levels.rs index 94fc7e85a2..b4bb1bd907 100644 --- a/tracing-attributes/tests/levels.rs +++ b/tracing-attributes/tests/levels.rs @@ -20,22 +20,22 @@ fn named_levels() { #[instrument(level = "eRrOr")] fn error() {} let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("trace").at_level(Level::TRACE)) - .enter(span::mock().named("trace").at_level(Level::TRACE)) - .exit(span::mock().named("trace").at_level(Level::TRACE)) - .new_span(span::mock().named("debug").at_level(Level::DEBUG)) - .enter(span::mock().named("debug").at_level(Level::DEBUG)) - .exit(span::mock().named("debug").at_level(Level::DEBUG)) - .new_span(span::mock().named("info").at_level(Level::INFO)) - .enter(span::mock().named("info").at_level(Level::INFO)) - .exit(span::mock().named("info").at_level(Level::INFO)) - .new_span(span::mock().named("warn").at_level(Level::WARN)) - .enter(span::mock().named("warn").at_level(Level::WARN)) - .exit(span::mock().named("warn").at_level(Level::WARN)) - .new_span(span::mock().named("error").at_level(Level::ERROR)) - .enter(span::mock().named("error").at_level(Level::ERROR)) - .exit(span::mock().named("error").at_level(Level::ERROR)) - .done() + .new_span(span::expect().named("trace").at_level(Level::TRACE)) + .enter(span::expect().named("trace").at_level(Level::TRACE)) + .exit(span::expect().named("trace").at_level(Level::TRACE)) + .new_span(span::expect().named("debug").at_level(Level::DEBUG)) + .enter(span::expect().named("debug").at_level(Level::DEBUG)) + .exit(span::expect().named("debug").at_level(Level::DEBUG)) + .new_span(span::expect().named("info").at_level(Level::INFO)) + .enter(span::expect().named("info").at_level(Level::INFO)) + .exit(span::expect().named("info").at_level(Level::INFO)) + .new_span(span::expect().named("warn").at_level(Level::WARN)) + .enter(span::expect().named("warn").at_level(Level::WARN)) + .exit(span::expect().named("warn").at_level(Level::WARN)) + .new_span(span::expect().named("error").at_level(Level::ERROR)) + .enter(span::expect().named("error").at_level(Level::ERROR)) + .exit(span::expect().named("error").at_level(Level::ERROR)) + .only() .run_with_handle(); with_default(subscriber, || { @@ -66,22 +66,22 @@ fn numeric_levels() { #[instrument(level = 5)] fn error() {} let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("trace").at_level(Level::TRACE)) - .enter(span::mock().named("trace").at_level(Level::TRACE)) - .exit(span::mock().named("trace").at_level(Level::TRACE)) - .new_span(span::mock().named("debug").at_level(Level::DEBUG)) - .enter(span::mock().named("debug").at_level(Level::DEBUG)) - .exit(span::mock().named("debug").at_level(Level::DEBUG)) - .new_span(span::mock().named("info").at_level(Level::INFO)) - .enter(span::mock().named("info").at_level(Level::INFO)) - .exit(span::mock().named("info").at_level(Level::INFO)) - .new_span(span::mock().named("warn").at_level(Level::WARN)) - .enter(span::mock().named("warn").at_level(Level::WARN)) - .exit(span::mock().named("warn").at_level(Level::WARN)) - .new_span(span::mock().named("error").at_level(Level::ERROR)) - .enter(span::mock().named("error").at_level(Level::ERROR)) - .exit(span::mock().named("error").at_level(Level::ERROR)) - .done() + .new_span(span::expect().named("trace").at_level(Level::TRACE)) + .enter(span::expect().named("trace").at_level(Level::TRACE)) + .exit(span::expect().named("trace").at_level(Level::TRACE)) + .new_span(span::expect().named("debug").at_level(Level::DEBUG)) + .enter(span::expect().named("debug").at_level(Level::DEBUG)) + .exit(span::expect().named("debug").at_level(Level::DEBUG)) + .new_span(span::expect().named("info").at_level(Level::INFO)) + .enter(span::expect().named("info").at_level(Level::INFO)) + .exit(span::expect().named("info").at_level(Level::INFO)) + .new_span(span::expect().named("warn").at_level(Level::WARN)) + .enter(span::expect().named("warn").at_level(Level::WARN)) + .exit(span::expect().named("warn").at_level(Level::WARN)) + .new_span(span::expect().named("error").at_level(Level::ERROR)) + .enter(span::expect().named("error").at_level(Level::ERROR)) + .exit(span::expect().named("error").at_level(Level::ERROR)) + .only() .run_with_handle(); with_default(subscriber, || { @@ -112,22 +112,22 @@ fn enum_levels() { #[instrument(level = Level::ERROR)] fn error() {} let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("trace").at_level(Level::TRACE)) - .enter(span::mock().named("trace").at_level(Level::TRACE)) - .exit(span::mock().named("trace").at_level(Level::TRACE)) - .new_span(span::mock().named("debug").at_level(Level::DEBUG)) - .enter(span::mock().named("debug").at_level(Level::DEBUG)) - .exit(span::mock().named("debug").at_level(Level::DEBUG)) - .new_span(span::mock().named("info").at_level(Level::INFO)) - .enter(span::mock().named("info").at_level(Level::INFO)) - .exit(span::mock().named("info").at_level(Level::INFO)) - .new_span(span::mock().named("warn").at_level(Level::WARN)) - .enter(span::mock().named("warn").at_level(Level::WARN)) - .exit(span::mock().named("warn").at_level(Level::WARN)) - .new_span(span::mock().named("error").at_level(Level::ERROR)) - .enter(span::mock().named("error").at_level(Level::ERROR)) - .exit(span::mock().named("error").at_level(Level::ERROR)) - .done() + .new_span(span::expect().named("trace").at_level(Level::TRACE)) + .enter(span::expect().named("trace").at_level(Level::TRACE)) + .exit(span::expect().named("trace").at_level(Level::TRACE)) + .new_span(span::expect().named("debug").at_level(Level::DEBUG)) + .enter(span::expect().named("debug").at_level(Level::DEBUG)) + .exit(span::expect().named("debug").at_level(Level::DEBUG)) + .new_span(span::expect().named("info").at_level(Level::INFO)) + .enter(span::expect().named("info").at_level(Level::INFO)) + .exit(span::expect().named("info").at_level(Level::INFO)) + .new_span(span::expect().named("warn").at_level(Level::WARN)) + .enter(span::expect().named("warn").at_level(Level::WARN)) + .exit(span::expect().named("warn").at_level(Level::WARN)) + .new_span(span::expect().named("error").at_level(Level::ERROR)) + .enter(span::expect().named("error").at_level(Level::ERROR)) + .exit(span::expect().named("error").at_level(Level::ERROR)) + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-attributes/tests/names.rs b/tracing-attributes/tests/names.rs index d97dece9a1..6161c68053 100644 --- a/tracing-attributes/tests/names.rs +++ b/tracing-attributes/tests/names.rs @@ -17,10 +17,10 @@ fn custom_name_no_equals() {} #[test] fn default_name_test() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("default_name")) - .enter(span::mock().named("default_name")) - .exit(span::mock().named("default_name")) - .done() + .new_span(span::expect().named("default_name")) + .enter(span::expect().named("default_name")) + .exit(span::expect().named("default_name")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -33,10 +33,10 @@ fn default_name_test() { #[test] fn custom_name_test() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("my_name")) - .enter(span::mock().named("my_name")) - .exit(span::mock().named("my_name")) - .done() + .new_span(span::expect().named("my_name")) + .enter(span::expect().named("my_name")) + .exit(span::expect().named("my_name")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -49,10 +49,10 @@ fn custom_name_test() { #[test] fn custom_name_no_equals_test() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("my_other_name")) - .enter(span::mock().named("my_other_name")) - .exit(span::mock().named("my_other_name")) - .done() + .new_span(span::expect().named("my_other_name")) + .enter(span::expect().named("my_other_name")) + .exit(span::expect().named("my_other_name")) + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-attributes/tests/parents.rs b/tracing-attributes/tests/parents.rs index 7069b98ea5..d3069f3063 100644 --- a/tracing-attributes/tests/parents.rs +++ b/tracing-attributes/tests/parents.rs @@ -14,8 +14,8 @@ where #[test] fn default_parent_test() { - let contextual_parent = span::mock().named("contextual_parent"); - let child = span::mock().named("with_default_parent"); + let contextual_parent = span::expect().named("contextual_parent"); + let child = span::expect().named("with_default_parent"); let (subscriber, handle) = subscriber::mock() .new_span( @@ -42,7 +42,7 @@ fn default_parent_test() { .enter(child.clone()) .exit(child) .exit(contextual_parent) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -60,9 +60,9 @@ fn default_parent_test() { #[test] fn explicit_parent_test() { - let contextual_parent = span::mock().named("contextual_parent"); - let explicit_parent = span::mock().named("explicit_parent"); - let child = span::mock().named("with_explicit_parent"); + let contextual_parent = span::expect().named("contextual_parent"); + let explicit_parent = span::expect().named("explicit_parent"); + let child = span::expect().named("with_explicit_parent"); let (subscriber, handle) = subscriber::mock() .new_span( @@ -86,7 +86,7 @@ fn explicit_parent_test() { .enter(child.clone()) .exit(child) .exit(contextual_parent) - .done() + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-attributes/tests/ret.rs b/tracing-attributes/tests/ret.rs index f56c80baaf..40275df3fd 100644 --- a/tracing-attributes/tests/ret.rs +++ b/tracing-attributes/tests/ret.rs @@ -19,18 +19,18 @@ fn ret_with_target() -> i32 { #[test] fn test() { - let span = span::mock().named("ret"); + let span = span::expect().named("ret"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, ret); @@ -40,7 +40,7 @@ fn test() { #[test] fn test_custom_target() { let filter: EnvFilter = "my_target=info".parse().expect("filter should parse"); - let span = span::mock() + let span = span::expect() .named("ret_with_target") .with_target("my_target"); @@ -48,14 +48,14 @@ fn test_custom_target() { .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO) .with_target("my_target"), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -71,18 +71,18 @@ fn ret_warn() -> i32 { #[test] fn test_warn() { - let span = span::mock().named("ret_warn"); + let span = span::expect().named("ret_warn"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::WARN), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, ret_warn); @@ -98,23 +98,23 @@ fn ret_mut(a: &mut i32) -> i32 { #[test] fn test_mut() { - let span = span::mock().named("ret_mut"); + let span = span::expect().named("ret_mut"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("a").with_value(&tracing::field::display(2))) + event::expect() + .with_fields(field::expect("a").with_value(&tracing::field::display(2))) .at_level(Level::INFO), ) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(2))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(2))) .at_level(Level::INFO), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || ret_mut(&mut 1)); @@ -128,20 +128,20 @@ async fn ret_async() -> i32 { #[test] fn test_async() { - let span = span::mock().named("ret_async"); + let span = span::expect().named("ret_async"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || block_on_future(async { ret_async().await })); @@ -155,18 +155,18 @@ fn ret_impl_type() -> impl Copy { #[test] fn test_impl_type() { - let span = span::mock().named("ret_impl_type"); + let span = span::expect().named("ret_impl_type"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, ret_impl_type); @@ -180,18 +180,18 @@ fn ret_display() -> i32 { #[test] fn test_dbg() { - let span = span::mock().named("ret_display"); + let span = span::expect().named("ret_display"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::display(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::display(42))) .at_level(Level::INFO), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, ret_display); @@ -205,14 +205,14 @@ fn ret_and_err() -> Result { #[test] fn test_ret_and_err() { - let span = span::mock().named("ret_and_err"); + let span = span::expect().named("ret_and_err"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() + event::expect() .with_fields( - field::mock("error") + field::expect("error") .with_value(&tracing::field::display(u8::try_from(1234).unwrap_err())) .only(), ) @@ -220,7 +220,7 @@ fn test_ret_and_err() { ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || ret_and_err().ok()); @@ -234,14 +234,14 @@ fn ret_and_ok() -> Result { #[test] fn test_ret_and_ok() { - let span = span::mock().named("ret_and_ok"); + let span = span::expect().named("ret_and_ok"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() + event::expect() .with_fields( - field::mock("return") + field::expect("return") .with_value(&tracing::field::debug(u8::try_from(123).unwrap())) .only(), ) @@ -249,7 +249,7 @@ fn test_ret_and_ok() { ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || ret_and_ok().ok()); @@ -263,18 +263,18 @@ fn ret_warn_info() -> i32 { #[test] fn test_warn_info() { - let span = span::mock().named("ret_warn_info").at_level(Level::WARN); + let span = span::expect().named("ret_warn_info").at_level(Level::WARN); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, ret_warn_info); @@ -288,18 +288,18 @@ fn ret_dbg_warn() -> i32 { #[test] fn test_dbg_warn() { - let span = span::mock().named("ret_dbg_warn").at_level(Level::INFO); + let span = span::expect().named("ret_dbg_warn").at_level(Level::INFO); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() - .with_fields(field::mock("return").with_value(&tracing::field::debug(42))) + event::expect() + .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) .at_level(Level::WARN), ) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, ret_dbg_warn); diff --git a/tracing-attributes/tests/targets.rs b/tracing-attributes/tests/targets.rs index 363f628f31..3a545ebff9 100644 --- a/tracing-attributes/tests/targets.rs +++ b/tracing-attributes/tests/targets.rs @@ -24,36 +24,36 @@ mod my_mod { fn default_targets() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock() + span::expect() .named("default_target") .with_target(module_path!()), ) .enter( - span::mock() + span::expect() .named("default_target") .with_target(module_path!()), ) .exit( - span::mock() + span::expect() .named("default_target") .with_target(module_path!()), ) .new_span( - span::mock() + span::expect() .named("default_target") .with_target(my_mod::MODULE_PATH), ) .enter( - span::mock() + span::expect() .named("default_target") .with_target(my_mod::MODULE_PATH), ) .exit( - span::mock() + span::expect() .named("default_target") .with_target(my_mod::MODULE_PATH), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -67,25 +67,37 @@ fn default_targets() { #[test] fn custom_targets() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("custom_target").with_target("my_target")) - .enter(span::mock().named("custom_target").with_target("my_target")) - .exit(span::mock().named("custom_target").with_target("my_target")) .new_span( - span::mock() + span::expect() + .named("custom_target") + .with_target("my_target"), + ) + .enter( + span::expect() + .named("custom_target") + .with_target("my_target"), + ) + .exit( + span::expect() + .named("custom_target") + .with_target("my_target"), + ) + .new_span( + span::expect() .named("custom_target") .with_target("my_other_target"), ) .enter( - span::mock() + span::expect() .named("custom_target") .with_target("my_other_target"), ) .exit( - span::mock() + span::expect() .named("custom_target") .with_target("my_other_target"), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/tracing-futures/src/lib.rs b/tracing-futures/src/lib.rs index 8065175d28..2795d87253 100644 --- a/tracing-futures/src/lib.rs +++ b/tracing-futures/src/lib.rs @@ -634,14 +634,14 @@ mod tests { #[test] fn future_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { PollN::new_ok(2) @@ -655,14 +655,14 @@ mod tests { #[test] fn future_error_ends_span() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { PollN::new_err(2) @@ -677,17 +677,17 @@ mod tests { #[test] fn stream_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); with_default(subscriber, || { stream::iter_ok::<_, ()>(&[1, 2, 3]) @@ -702,15 +702,15 @@ mod tests { // #[test] // fn span_follows_future_onto_threadpool() { // let (subscriber, handle) = subscriber::mock() - // .enter(span::mock().named("a")) - // .enter(span::mock().named("b")) - // .exit(span::mock().named("b")) - // .enter(span::mock().named("b")) - // .exit(span::mock().named("b")) - // .drop_span(span::mock().named("b")) - // .exit(span::mock().named("a")) - // .drop_span(span::mock().named("a")) - // .done() + // .enter(span::expect().named("a")) + // .enter(span::expect().named("b")) + // .exit(span::expect().named("b")) + // .enter(span::expect().named("b")) + // .exit(span::expect().named("b")) + // .drop_span(span::expect().named("b")) + // .exit(span::expect().named("a")) + // .drop_span(span::expect().named("a")) + // .only() // .run_with_handle(); // let mut runtime = tokio::runtime::Runtime::new().unwrap(); // with_default(subscriber, || { @@ -740,15 +740,15 @@ mod tests { #[test] fn stream_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); with_default(subscriber, || { Instrument::instrument(stream::iter(&[1, 2, 3]), tracing::trace_span!("foo")) @@ -762,13 +762,13 @@ mod tests { #[test] fn sink_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); with_default(subscriber, || { Instrument::instrument(sink::drain(), tracing::trace_span!("foo")) diff --git a/tracing-futures/tests/std_future.rs b/tracing-futures/tests/std_future.rs index 8bc31149c7..71f888ce0b 100644 --- a/tracing-futures/tests/std_future.rs +++ b/tracing-futures/tests/std_future.rs @@ -8,14 +8,14 @@ use tracing_mock::*; #[test] fn enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { let future = PollN::new_ok(2).instrument(tracing::span!(Level::TRACE, "foo")); @@ -27,14 +27,14 @@ fn enter_exit_is_reasonable() { #[test] fn error_ends_span() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { let future = PollN::new_err(2).instrument(tracing::span!(Level::TRACE, "foo")); @@ -66,17 +66,17 @@ fn span_on_drop() { } let subscriber = subscriber::mock() - .enter(span::mock().named("foo")) - .event(event::mock().at_level(Level::INFO)) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .enter(span::mock().named("bar")) - .event(event::mock().at_level(Level::INFO)) - .exit(span::mock().named("bar")) - .drop_span(span::mock().named("bar")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect().at_level(Level::INFO)) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .enter(span::expect().named("bar")) + .event(event::expect().at_level(Level::INFO)) + .exit(span::expect().named("bar")) + .drop_span(span::expect().named("bar")) + .only() .run(); with_default(subscriber, || { diff --git a/tracing-mock/src/event.rs b/tracing-mock/src/event.rs index 9e57864964..cd3bef76a3 100644 --- a/tracing-mock/src/event.rs +++ b/tracing-mock/src/event.rs @@ -1,5 +1,5 @@ #![allow(missing_docs)] -use super::{field, metadata, span, Parent}; +use super::{field, metadata::ExpectedMetadata, span, Parent}; use std::fmt; @@ -8,30 +8,30 @@ use std::fmt; /// This is intended for use with the mock subscriber API in the /// `subscriber` module. #[derive(Default, Eq, PartialEq)] -pub struct MockEvent { - pub fields: Option, - in_spans: Vec, - pub(crate) parent: Option, - metadata: metadata::Expect, +pub struct ExpectedEvent { + fields: Option, + parent: Option, + in_spans: Vec, + metadata: ExpectedMetadata, } -pub fn mock() -> MockEvent { - MockEvent { +pub fn expect() -> ExpectedEvent { + ExpectedEvent { ..Default::default() } } -pub fn msg(message: impl fmt::Display) -> MockEvent { - mock().with_fields(field::msg(message)) +pub fn msg(message: impl fmt::Display) -> ExpectedEvent { + expect().with_fields(field::msg(message)) } -impl MockEvent { +impl ExpectedEvent { pub fn named(self, name: I) -> Self where I: Into, { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { name: Some(name.into()), ..self.metadata }, @@ -41,7 +41,7 @@ impl MockEvent { pub fn with_fields(self, fields: I) -> Self where - I: Into, + I: Into, { Self { fields: Some(fields.into()), @@ -51,7 +51,7 @@ impl MockEvent { pub fn at_level(self, level: tracing::Level) -> Self { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { level: Some(level), ..self.metadata }, @@ -64,7 +64,7 @@ impl MockEvent { I: Into, { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { target: Some(target.into()), ..self.metadata }, @@ -72,7 +72,7 @@ impl MockEvent { } } - pub fn with_explicit_parent(self, parent: Option<&str>) -> MockEvent { + pub fn with_explicit_parent(self, parent: Option<&str>) -> ExpectedEvent { let parent = match parent { Some(name) => Parent::Explicit(name.into()), None => Parent::ExplicitRoot, @@ -117,25 +117,25 @@ impl MockEvent { } } - pub fn in_scope(self, spans: impl IntoIterator) -> Self { + pub fn in_scope(self, spans: impl IntoIterator) -> Self { Self { in_spans: spans.into_iter().collect(), ..self } } - pub fn scope_mut(&mut self) -> &mut [span::MockSpan] { + pub fn scope_mut(&mut self) -> &mut [span::ExpectedSpan] { &mut self.in_spans[..] } } -impl fmt::Display for MockEvent { +impl fmt::Display for ExpectedEvent { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "an event{}", self.metadata) } } -impl fmt::Debug for MockEvent { +impl fmt::Debug for ExpectedEvent { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut s = f.debug_struct("MockEvent"); diff --git a/tracing-mock/src/expectation.rs b/tracing-mock/src/expectation.rs index 0328754fc8..cd48728ae7 100644 --- a/tracing-mock/src/expectation.rs +++ b/tracing-mock/src/expectation.rs @@ -1,21 +1,21 @@ use crate::{ - event::MockEvent, - field, - span::{MockSpan, NewSpan}, + event::ExpectedEvent, + field::ExpectedFields, + span::{ExpectedSpan, NewSpan}, }; #[derive(Debug, Eq, PartialEq)] pub(crate) enum Expect { - Event(MockEvent), + Event(ExpectedEvent), FollowsFrom { - consequence: MockSpan, - cause: MockSpan, + consequence: ExpectedSpan, + cause: ExpectedSpan, }, - Enter(MockSpan), - Exit(MockSpan), - CloneSpan(MockSpan), - DropSpan(MockSpan), - Visit(MockSpan, field::Expect), + Enter(ExpectedSpan), + Exit(ExpectedSpan), + CloneSpan(ExpectedSpan), + DropSpan(ExpectedSpan), + Visit(ExpectedSpan, ExpectedFields), NewSpan(NewSpan), Nothing, } diff --git a/tracing-mock/src/field.rs b/tracing-mock/src/field.rs index bdf22aba1d..be3f9c47cf 100644 --- a/tracing-mock/src/field.rs +++ b/tracing-mock/src/field.rs @@ -8,19 +8,19 @@ use tracing::{ use std::{collections::HashMap, fmt}; #[derive(Default, Debug, Eq, PartialEq)] -pub struct Expect { - fields: HashMap, +pub struct ExpectedFields { + fields: HashMap, only: bool, } #[derive(Debug)] -pub struct MockField { +pub struct ExpectedField { name: String, - value: MockValue, + value: ExpectedValue, } #[derive(Debug)] -pub enum MockValue { +pub enum ExpectedValue { F64(f64), I64(i64), U64(u64), @@ -30,11 +30,11 @@ pub enum MockValue { Any, } -impl Eq for MockValue {} +impl Eq for ExpectedValue {} -impl PartialEq for MockValue { +impl PartialEq for ExpectedValue { fn eq(&self, other: &Self) -> bool { - use MockValue::*; + use ExpectedValue::*; match (self, other) { (F64(a), F64(b)) => { @@ -55,34 +55,34 @@ impl PartialEq for MockValue { } } -pub fn mock(name: K) -> MockField +pub fn expect(name: K) -> ExpectedField where String: From, { - MockField { + ExpectedField { name: name.into(), - value: MockValue::Any, + value: ExpectedValue::Any, } } -pub fn msg(message: impl fmt::Display) -> MockField { - MockField { +pub fn msg(message: impl fmt::Display) -> ExpectedField { + ExpectedField { name: "message".to_string(), - value: MockValue::Debug(message.to_string()), + value: ExpectedValue::Debug(message.to_string()), } } -impl MockField { +impl ExpectedField { /// Expect a field with the given name and value. pub fn with_value(self, value: &dyn Value) -> Self { Self { - value: MockValue::from(value), + value: ExpectedValue::from(value), ..self } } - pub fn and(self, other: MockField) -> Expect { - Expect { + pub fn and(self, other: ExpectedField) -> ExpectedFields { + ExpectedFields { fields: HashMap::new(), only: false, } @@ -90,8 +90,8 @@ impl MockField { .and(other) } - pub fn only(self) -> Expect { - Expect { + pub fn only(self) -> ExpectedFields { + ExpectedFields { fields: HashMap::new(), only: true, } @@ -99,9 +99,9 @@ impl MockField { } } -impl From for Expect { - fn from(field: MockField) -> Self { - Expect { +impl From for ExpectedFields { + fn from(field: ExpectedField) -> Self { + ExpectedFields { fields: HashMap::new(), only: false, } @@ -109,8 +109,8 @@ impl From for Expect { } } -impl Expect { - pub fn and(mut self, field: MockField) -> Self { +impl ExpectedFields { + pub fn and(mut self, field: ExpectedField) -> Self { self.fields.insert(field.name, field.value); self } @@ -129,7 +129,7 @@ impl Expect { ) { let value = value.into(); match self.fields.remove(name) { - Some(MockValue::Any) => {} + Some(ExpectedValue::Any) => {} Some(expected) => assert!( expected == value, "\n[{}] expected `{}` to contain:\n\t`{}{}`\nbut got:\n\t`{}{}`", @@ -161,22 +161,22 @@ impl Expect { } } -impl fmt::Display for MockValue { +impl fmt::Display for ExpectedValue { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { - MockValue::F64(v) => write!(f, "f64 = {:?}", v), - MockValue::I64(v) => write!(f, "i64 = {:?}", v), - MockValue::U64(v) => write!(f, "u64 = {:?}", v), - MockValue::Bool(v) => write!(f, "bool = {:?}", v), - MockValue::Str(v) => write!(f, "&str = {:?}", v), - MockValue::Debug(v) => write!(f, "&fmt::Debug = {:?}", v), - MockValue::Any => write!(f, "_ = _"), + ExpectedValue::F64(v) => write!(f, "f64 = {:?}", v), + ExpectedValue::I64(v) => write!(f, "i64 = {:?}", v), + ExpectedValue::U64(v) => write!(f, "u64 = {:?}", v), + ExpectedValue::Bool(v) => write!(f, "bool = {:?}", v), + ExpectedValue::Str(v) => write!(f, "&str = {:?}", v), + ExpectedValue::Debug(v) => write!(f, "&fmt::Debug = {:?}", v), + ExpectedValue::Any => write!(f, "_ = _"), } } } pub struct CheckVisitor<'a> { - expect: &'a mut Expect, + expect: &'a mut ExpectedFields, ctx: &'a str, subscriber_name: &'a str, } @@ -229,35 +229,35 @@ impl<'a> CheckVisitor<'a> { } } -impl<'a> From<&'a dyn Value> for MockValue { +impl<'a> From<&'a dyn Value> for ExpectedValue { fn from(value: &'a dyn Value) -> Self { struct MockValueBuilder { - value: Option, + value: Option, } impl Visit for MockValueBuilder { fn record_f64(&mut self, _: &Field, value: f64) { - self.value = Some(MockValue::F64(value)); + self.value = Some(ExpectedValue::F64(value)); } fn record_i64(&mut self, _: &Field, value: i64) { - self.value = Some(MockValue::I64(value)); + self.value = Some(ExpectedValue::I64(value)); } fn record_u64(&mut self, _: &Field, value: u64) { - self.value = Some(MockValue::U64(value)); + self.value = Some(ExpectedValue::U64(value)); } fn record_bool(&mut self, _: &Field, value: bool) { - self.value = Some(MockValue::Bool(value)); + self.value = Some(ExpectedValue::Bool(value)); } fn record_str(&mut self, _: &Field, value: &str) { - self.value = Some(MockValue::Str(value.to_owned())); + self.value = Some(ExpectedValue::Str(value.to_owned())); } fn record_debug(&mut self, _: &Field, value: &dyn fmt::Debug) { - self.value = Some(MockValue::Debug(format!("{:?}", value))); + self.value = Some(ExpectedValue::Debug(format!("{:?}", value))); } } @@ -274,7 +274,7 @@ impl<'a> From<&'a dyn Value> for MockValue { } } -impl fmt::Display for Expect { +impl fmt::Display for ExpectedFields { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "fields ")?; let entries = self diff --git a/tracing-mock/src/layer.rs b/tracing-mock/src/layer.rs index 0a0a02005d..85509ab075 100644 --- a/tracing-mock/src/layer.rs +++ b/tracing-mock/src/layer.rs @@ -1,7 +1,9 @@ +#![allow(missing_docs, dead_code)] use crate::{ - event::MockEvent, + event::ExpectedEvent, expectation::Expect, - span::{MockSpan, NewSpan}, + field::ExpectedFields, + span::{ExpectedSpan, NewSpan}, subscriber::MockHandle, }; use tracing_core::{ @@ -19,7 +21,6 @@ use std::{ sync::{Arc, Mutex}, }; -#[must_use] pub fn mock() -> MockLayerBuilder { MockLayerBuilder { expected: Default::default(), @@ -30,7 +31,6 @@ pub fn mock() -> MockLayerBuilder { } } -#[must_use] pub fn named(name: impl std::fmt::Display) -> MockLayerBuilder { mock().named(name) } @@ -47,6 +47,19 @@ pub struct MockLayer { } impl MockLayerBuilder { + /// Overrides the name printed by the mock layer's debugging output. + /// + /// The debugging output is displayed if the test panics, or if the test is + /// run with `--nocapture`. + /// + /// By default, the mock layer's name is the name of the test + /// (*technically*, the name of the thread where it was created, which is + /// the name of the test unless tests are run with `--test-threads=1`). + /// When a test has only one mock layer, this is sufficient. However, + /// some tests may include multiple layers, in order to test + /// interactions between multiple layers. In that case, it can be + /// helpful to give each layer a separate name to distinguish where the + /// debugging output comes from. pub fn named(mut self, name: impl fmt::Display) -> Self { use std::fmt::Write; if !self.name.is_empty() { @@ -57,31 +70,39 @@ impl MockLayerBuilder { self } - pub fn event(mut self, event: MockEvent) -> Self { + pub fn enter(mut self, span: ExpectedSpan) -> Self { + self.expected.push_back(Expect::Enter(span)); + self + } + + pub fn event(mut self, event: ExpectedEvent) -> Self { self.expected.push_back(Expect::Event(event)); self } - pub fn new_span(mut self, new_span: I) -> Self - where - I: Into, - { - self.expected.push_back(Expect::NewSpan(new_span.into())); + pub fn exit(mut self, span: ExpectedSpan) -> Self { + self.expected.push_back(Expect::Exit(span)); self } - pub fn enter(mut self, span: MockSpan) -> Self { - self.expected.push_back(Expect::Enter(span)); + pub fn only(mut self) -> Self { + self.expected.push_back(Expect::Nothing); self } - pub fn exit(mut self, span: MockSpan) -> Self { - self.expected.push_back(Expect::Exit(span)); + pub fn record(mut self, span: ExpectedSpan, fields: I) -> Self + where + I: Into, + { + self.expected.push_back(Expect::Visit(span, fields.into())); self } - pub fn done(mut self) -> Self { - self.expected.push_back(Expect::Nothing); + pub fn new_span(mut self, new_span: I) -> Self + where + I: Into, + { + self.expected.push_back(Expect::NewSpan(new_span.into())); self } @@ -96,19 +117,19 @@ impl MockLayerBuilder { pub fn run_with_handle(self) -> (MockLayer, MockHandle) { let expected = Arc::new(Mutex::new(self.expected)); let handle = MockHandle::new(expected.clone(), self.name.clone()); - let subscriber = MockLayer { + let layer = MockLayer { expected, name: self.name, current: Mutex::new(Vec::new()), }; - (subscriber, handle) + (layer, handle) } } impl MockLayer { fn check_span_ref<'spans, S>( &self, - expected: &MockSpan, + expected: &ExpectedSpan, actual: &SpanRef<'spans, S>, what_happened: impl fmt::Display, ) where @@ -238,11 +259,7 @@ where } fn on_follows_from(&self, _span: &Id, _follows: &Id, _: Context<'_, C>) { - unimplemented!( - "so far, we don't have any tests that need an `on_follows_from` \ - implementation.\nif you just wrote one that does, feel free to \ - implement it!" - ); + // TODO: it should be possible to expect spans to follow from other spans } fn on_new_span(&self, span: &Attributes<'_>, id: &Id, cx: Context<'_, C>) { @@ -360,13 +377,13 @@ where } fn on_id_change(&self, _old: &Id, _new: &Id, _ctx: Context<'_, C>) { - panic!("well-behaved subscribers should never do this to us, lol"); + panic!("well-behaved Layers should never do this to us, lol"); } } impl fmt::Debug for MockLayer { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let mut s = f.debug_struct("MockLayer"); + let mut s = f.debug_struct("Expectlayer"); s.field("name", &self.name); if let Ok(expected) = self.expected.try_lock() { diff --git a/tracing-mock/src/metadata.rs b/tracing-mock/src/metadata.rs index 8c4c3a9c89..49347434fe 100644 --- a/tracing-mock/src/metadata.rs +++ b/tracing-mock/src/metadata.rs @@ -2,14 +2,19 @@ use std::fmt; use tracing::Metadata; #[derive(Clone, Debug, Eq, PartialEq, Default)] -pub struct Expect { - pub name: Option, - pub level: Option, - pub target: Option, +pub(crate) struct ExpectedMetadata { + pub(crate) name: Option, + pub(crate) level: Option, + pub(crate) target: Option, } -impl Expect { - pub fn check(&self, actual: &Metadata<'_>, ctx: fmt::Arguments<'_>, subscriber_name: &str) { +impl ExpectedMetadata { + pub(crate) fn check( + &self, + actual: &Metadata<'_>, + ctx: fmt::Arguments<'_>, + subscriber_name: &str, + ) { if let Some(ref expected_name) = self.name { let name = actual.name(); assert!( @@ -48,7 +53,7 @@ impl Expect { } } -impl fmt::Display for Expect { +impl fmt::Display for ExpectedMetadata { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if let Some(ref name) = self.name { write!(f, " named `{}`", name)?; diff --git a/tracing-mock/src/span.rs b/tracing-mock/src/span.rs index a55aaabc93..35cab3ebb9 100644 --- a/tracing-mock/src/span.rs +++ b/tracing-mock/src/span.rs @@ -1,5 +1,5 @@ #![allow(missing_docs)] -use super::{field, metadata, Parent}; +use super::{field::ExpectedFields, metadata::ExpectedMetadata, Parent}; use std::fmt; /// A mock span. @@ -7,37 +7,37 @@ use std::fmt; /// This is intended for use with the mock subscriber API in the /// `subscriber` module. #[derive(Clone, Default, Eq, PartialEq)] -pub struct MockSpan { - pub(crate) metadata: metadata::Expect, +pub struct ExpectedSpan { + pub(crate) metadata: ExpectedMetadata, } #[derive(Default, Eq, PartialEq)] pub struct NewSpan { - pub(crate) span: MockSpan, - pub(crate) fields: field::Expect, + pub(crate) span: ExpectedSpan, + pub(crate) fields: ExpectedFields, pub(crate) parent: Option, } -pub fn mock() -> MockSpan { - MockSpan { +pub fn expect() -> ExpectedSpan { + ExpectedSpan { ..Default::default() } } -pub fn named(name: I) -> MockSpan +pub fn named(name: I) -> ExpectedSpan where I: Into, { - mock().named(name) + expect().named(name) } -impl MockSpan { +impl ExpectedSpan { pub fn named(self, name: I) -> Self where I: Into, { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { name: Some(name.into()), ..self.metadata }, @@ -46,7 +46,7 @@ impl MockSpan { pub fn at_level(self, level: tracing::Level) -> Self { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { level: Some(level), ..self.metadata }, @@ -58,7 +58,7 @@ impl MockSpan { I: Into, { Self { - metadata: metadata::Expect { + metadata: ExpectedMetadata { target: Some(target.into()), ..self.metadata }, @@ -103,7 +103,7 @@ impl MockSpan { pub fn with_field(self, fields: I) -> NewSpan where - I: Into, + I: Into, { NewSpan { span: self, @@ -113,7 +113,7 @@ impl MockSpan { } } -impl fmt::Debug for MockSpan { +impl fmt::Debug for ExpectedSpan { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut s = f.debug_struct("MockSpan"); @@ -133,7 +133,7 @@ impl fmt::Debug for MockSpan { } } -impl fmt::Display for MockSpan { +impl fmt::Display for ExpectedSpan { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if self.metadata.name.is_some() { write!(f, "a span{}", self.metadata) @@ -143,8 +143,8 @@ impl fmt::Display for MockSpan { } } -impl From for NewSpan { - fn from(span: MockSpan) -> Self { +impl From for NewSpan { + fn from(span: ExpectedSpan) -> Self { Self { span, ..Default::default() @@ -177,7 +177,7 @@ impl NewSpan { pub fn with_field(self, fields: I) -> NewSpan where - I: Into, + I: Into, { NewSpan { fields: fields.into(), diff --git a/tracing-mock/src/subscriber.rs b/tracing-mock/src/subscriber.rs index 9a73da28c2..3049993fe8 100644 --- a/tracing-mock/src/subscriber.rs +++ b/tracing-mock/src/subscriber.rs @@ -1,9 +1,9 @@ #![allow(missing_docs)] -use super::{ - event::MockEvent, +use crate::{ + event::ExpectedEvent, expectation::Expect, - field as mock_field, - span::{MockSpan, NewSpan}, + field::ExpectedFields, + span::{ExpectedSpan, NewSpan}, }; use std::{ collections::{HashMap, VecDeque}, @@ -82,46 +82,46 @@ where } } - pub fn enter(mut self, span: MockSpan) -> Self { + pub fn enter(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::Enter(span)); self } - pub fn follows_from(mut self, consequence: MockSpan, cause: MockSpan) -> Self { + pub fn follows_from(mut self, consequence: ExpectedSpan, cause: ExpectedSpan) -> Self { self.expected .push_back(Expect::FollowsFrom { consequence, cause }); self } - pub fn event(mut self, event: MockEvent) -> Self { + pub fn event(mut self, event: ExpectedEvent) -> Self { self.expected.push_back(Expect::Event(event)); self } - pub fn exit(mut self, span: MockSpan) -> Self { + pub fn exit(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::Exit(span)); self } - pub fn clone_span(mut self, span: MockSpan) -> Self { + pub fn clone_span(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::CloneSpan(span)); self } #[allow(deprecated)] - pub fn drop_span(mut self, span: MockSpan) -> Self { + pub fn drop_span(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::DropSpan(span)); self } - pub fn done(mut self) -> Self { + pub fn only(mut self) -> Self { self.expected.push_back(Expect::Nothing); self } - pub fn record(mut self, span: MockSpan, fields: I) -> Self + pub fn record(mut self, span: ExpectedSpan, fields: I) -> Self where - I: Into, + I: Into, { self.expected.push_back(Expect::Visit(span, fields.into())); self @@ -194,9 +194,7 @@ where Interest::never() } } - fn max_level_hint(&self) -> Option { - println!("[{}] max_level_hint -> {:?}", self.name, self.max_level); self.max_level } @@ -309,8 +307,8 @@ where id.clone(), SpanState { name: meta.name(), - meta, refs: 1, + meta, }, ); id @@ -473,7 +471,7 @@ impl MockHandle { } impl Expect { - pub(crate) fn bad(&self, name: impl AsRef, what: fmt::Arguments<'_>) { + pub fn bad(&self, name: impl AsRef, what: fmt::Arguments<'_>) { let name = name.as_ref(); match self { Expect::Event(e) => panic!( diff --git a/tracing-subscriber/tests/cached_layer_filters_dont_break_other_layers.rs b/tracing-subscriber/tests/cached_layer_filters_dont_break_other_layers.rs index 5b40b60aa3..478b6e9b20 100644 --- a/tracing-subscriber/tests/cached_layer_filters_dont_break_other_layers.rs +++ b/tracing-subscriber/tests/cached_layer_filters_dont_break_other_layers.rs @@ -107,20 +107,20 @@ fn filter() -> LevelFilter { fn unfiltered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } fn filtered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } diff --git a/tracing-subscriber/tests/env_filter/main.rs b/tracing-subscriber/tests/env_filter/main.rs index ef984a68a9..2ec008dd68 100644 --- a/tracing-subscriber/tests/env_filter/main.rs +++ b/tracing-subscriber/tests/env_filter/main.rs @@ -13,10 +13,10 @@ use tracing_subscriber::{ fn level_filter_event() { let filter: EnvFilter = "info".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -38,18 +38,18 @@ fn same_name_spans() { .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .new_span( - span::mock() + span::expect() .named("foo") .at_level(Level::TRACE) - .with_field(field::mock("bar")), + .with_field(field::expect("bar")), ) .new_span( - span::mock() + span::expect() .named("foo") .at_level(Level::TRACE) - .with_field(field::mock("baz")), + .with_field(field::expect("baz")), ) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); with_default(subscriber, || { @@ -64,12 +64,12 @@ fn same_name_spans() { fn level_filter_event_with_target() { let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) - .event(event::mock().at_level(Level::WARN).with_target("stuff")) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::ERROR).with_target("stuff")) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) + .event(event::expect().at_level(Level::WARN).with_target("stuff")) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -98,14 +98,14 @@ fn level_filter_event_with_target_and_span_global() { let (subscriber, handle) = subscriber::mock() .enter(cool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) .exit(cool_span) .enter(uncool_span.clone()) .exit(uncool_span) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -133,12 +133,12 @@ fn not_order_dependent() { let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) - .event(event::mock().at_level(Level::WARN).with_target("stuff")) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::ERROR).with_target("stuff")) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) + .event(event::expect().at_level(Level::WARN).with_target("stuff")) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -167,9 +167,9 @@ fn add_directive_enables_event() { filter = filter.add_directive("hello=trace".parse().expect("directive should parse")); let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO).with_target("hello")) - .event(event::mock().at_level(Level::TRACE).with_target("hello")) - .done() + .event(event::expect().at_level(Level::INFO).with_target("hello")) + .event(event::expect().at_level(Level::TRACE).with_target("hello")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -187,19 +187,19 @@ fn span_name_filter_is_dynamic() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .enter(span::named("cool_span")) - .event(event::mock().at_level(Level::DEBUG)) - .enter(span::named("uncool_span")) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::DEBUG)) - .exit(span::named("uncool_span")) - .exit(span::named("cool_span")) - .enter(span::named("uncool_span")) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .exit(span::named("uncool_span")) - .done() + .event(event::expect().at_level(Level::INFO)) + .enter(span::expect().named("cool_span")) + .event(event::expect().at_level(Level::DEBUG)) + .enter(span::expect().named("uncool_span")) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::DEBUG)) + .exit(span::expect().named("uncool_span")) + .exit(span::expect().named("cool_span")) + .enter(span::expect().named("uncool_span")) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .exit(span::expect().named("uncool_span")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -245,10 +245,10 @@ mod per_layer_filter { fn level_filter_event() { let filter: EnvFilter = "info".parse().expect("filter should parse"); let (layer, handle) = layer::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -271,18 +271,18 @@ mod per_layer_filter { .expect("filter should parse"); let (layer, handle) = layer::mock() .new_span( - span::mock() + span::expect() .named("foo") .at_level(Level::TRACE) - .with_field(field::mock("bar")), + .with_field(field::expect("bar")), ) .new_span( - span::mock() + span::expect() .named("foo") .at_level(Level::TRACE) - .with_field(field::mock("baz")), + .with_field(field::expect("baz")), ) - .done() + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -299,12 +299,12 @@ mod per_layer_filter { fn level_filter_event_with_target() { let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse"); let (layer, handle) = layer::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) - .event(event::mock().at_level(Level::WARN).with_target("stuff")) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::ERROR).with_target("stuff")) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) + .event(event::expect().at_level(Level::WARN).with_target("stuff")) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -333,12 +333,12 @@ mod per_layer_filter { let (layer, handle) = layer::mock() .enter(cool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) .exit(cool_span) - .done() + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -366,12 +366,12 @@ mod per_layer_filter { let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse"); let (layer, finished) = layer::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) - .event(event::mock().at_level(Level::WARN).with_target("stuff")) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::ERROR).with_target("stuff")) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) + .event(event::expect().at_level(Level::WARN).with_target("stuff")) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -401,9 +401,9 @@ mod per_layer_filter { filter = filter.add_directive("hello=trace".parse().expect("directive should parse")); let (layer, finished) = layer::mock() - .event(event::mock().at_level(Level::INFO).with_target("hello")) - .event(event::mock().at_level(Level::TRACE).with_target("hello")) - .done() + .event(event::expect().at_level(Level::INFO).with_target("hello")) + .event(event::expect().at_level(Level::TRACE).with_target("hello")) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -424,21 +424,21 @@ mod per_layer_filter { let cool_span = span::named("cool_span"); let uncool_span = span::named("uncool_span"); let (layer, finished) = layer::mock() - .event(event::mock().at_level(Level::INFO)) + .event(event::expect().at_level(Level::INFO)) .enter(cool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) .enter(uncool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![uncool_span.clone()]), ) @@ -446,17 +446,17 @@ mod per_layer_filter { .exit(cool_span) .enter(uncool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::mock() + event::expect() .at_level(Level::ERROR) .in_scope(vec![uncool_span.clone()]), ) .exit(uncool_span) - .done() + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -497,12 +497,12 @@ mod per_layer_filter { let (layer, handle) = layer::named("layer1") .enter(span.clone()) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![span.clone()]), ) .exit(span) - .done() + .only() .run_with_handle(); (layer.with_filter(filter), handle) }; @@ -513,12 +513,12 @@ mod per_layer_filter { let (layer, handle) = layer::named("layer2") .enter(span.clone()) .event( - event::mock() + event::expect() .at_level(Level::INFO) .in_scope(vec![span.clone()]), ) .exit(span) - .done() + .only() .run_with_handle(); (layer.with_filter(filter), handle) }; diff --git a/tracing-subscriber/tests/env_filter/per_layer.rs b/tracing-subscriber/tests/env_filter/per_layer.rs index 4b143b8bfd..587d34fb77 100644 --- a/tracing-subscriber/tests/env_filter/per_layer.rs +++ b/tracing-subscriber/tests/env_filter/per_layer.rs @@ -8,10 +8,10 @@ use tracing_mock::{event, field, layer, span}; fn level_filter_event() { let filter: EnvFilter = "info".parse().expect("filter should parse"); let (layer, handle) = layer::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -34,18 +34,18 @@ fn same_name_spans() { .expect("filter should parse"); let (layer, handle) = layer::mock() .new_span( - span::mock() + span::expect() .named("foo") .at_level(Level::TRACE) - .with_field(field::mock("bar")), + .with_field(field::expect("bar")), ) .new_span( - span::mock() + span::expect() .named("foo") .at_level(Level::TRACE) - .with_field(field::mock("baz")), + .with_field(field::expect("baz")), ) - .done() + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -62,12 +62,12 @@ fn same_name_spans() { fn level_filter_event_with_target() { let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse"); let (layer, handle) = layer::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) - .event(event::mock().at_level(Level::WARN).with_target("stuff")) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::ERROR).with_target("stuff")) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) + .event(event::expect().at_level(Level::WARN).with_target("stuff")) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -96,12 +96,12 @@ fn level_filter_event_with_target_and_span() { let (layer, handle) = layer::mock() .enter(cool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) .exit(cool_span) - .done() + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -129,12 +129,12 @@ fn not_order_dependent() { let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse"); let (layer, finished) = layer::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) - .event(event::mock().at_level(Level::WARN).with_target("stuff")) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::ERROR).with_target("stuff")) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) + .event(event::expect().at_level(Level::WARN).with_target("stuff")) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -164,9 +164,9 @@ fn add_directive_enables_event() { filter = filter.add_directive("hello=trace".parse().expect("directive should parse")); let (layer, finished) = layer::mock() - .event(event::mock().at_level(Level::INFO).with_target("hello")) - .event(event::mock().at_level(Level::TRACE).with_target("hello")) - .done() + .event(event::expect().at_level(Level::INFO).with_target("hello")) + .event(event::expect().at_level(Level::TRACE).with_target("hello")) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -187,21 +187,21 @@ fn span_name_filter_is_dynamic() { let cool_span = span::named("cool_span"); let uncool_span = span::named("uncool_span"); let (layer, finished) = layer::mock() - .event(event::mock().at_level(Level::INFO)) + .event(event::expect().at_level(Level::INFO)) .enter(cool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) .enter(uncool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![uncool_span.clone()]), ) @@ -209,17 +209,17 @@ fn span_name_filter_is_dynamic() { .exit(cool_span) .enter(uncool_span.clone()) .event( - event::mock() + event::expect() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::mock() + event::expect() .at_level(Level::ERROR) .in_scope(vec![uncool_span.clone()]), ) .exit(uncool_span) - .done() + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -260,12 +260,12 @@ fn multiple_dynamic_filters() { let (layer, handle) = layer::named("layer1") .enter(span.clone()) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) .in_scope(vec![span.clone()]), ) .exit(span) - .done() + .only() .run_with_handle(); (layer.with_filter(filter), handle) }; @@ -276,12 +276,12 @@ fn multiple_dynamic_filters() { let (layer, handle) = layer::named("layer2") .enter(span.clone()) .event( - event::mock() + event::expect() .at_level(Level::INFO) .in_scope(vec![span.clone()]), ) .exit(span) - .done() + .only() .run_with_handle(); (layer.with_filter(filter), handle) }; diff --git a/tracing-subscriber/tests/field_filter.rs b/tracing-subscriber/tests/field_filter.rs index 385d024f65..5d41ec028b 100644 --- a/tracing-subscriber/tests/field_filter.rs +++ b/tracing-subscriber/tests/field_filter.rs @@ -10,16 +10,16 @@ fn field_filter_events() { let filter: EnvFilter = "[{thing}]=debug".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .event( - event::mock() + event::expect() .at_level(Level::INFO) - .with_fields(field::mock("thing")), + .with_fields(field::expect("thing")), ) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) - .with_fields(field::mock("thing")), + .with_fields(field::expect("thing")), ) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -41,23 +41,23 @@ fn field_filter_spans() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .enter(span::mock().named("span1")) + .enter(span::expect().named("span1")) .event( - event::mock() + event::expect() .at_level(Level::INFO) - .with_fields(field::mock("something")), + .with_fields(field::expect("something")), ) - .exit(span::mock().named("span1")) - .enter(span::mock().named("span2")) - .exit(span::mock().named("span2")) - .enter(span::mock().named("span3")) + .exit(span::expect().named("span1")) + .enter(span::expect().named("span2")) + .exit(span::expect().named("span2")) + .enter(span::expect().named("span3")) .event( - event::mock() + event::expect() .at_level(Level::DEBUG) - .with_fields(field::mock("something")), + .with_fields(field::expect("something")), ) - .exit(span::mock().named("span3")) - .done() + .exit(span::expect().named("span3")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -84,16 +84,16 @@ fn record_after_created() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .enter(span::mock().named("span")) - .exit(span::mock().named("span")) + .enter(span::expect().named("span")) + .exit(span::expect().named("span")) .record( - span::mock().named("span"), - field::mock("enabled").with_value(&true), + span::expect().named("span"), + field::expect("enabled").with_value(&true), ) - .enter(span::mock().named("span")) - .event(event::mock().at_level(Level::DEBUG)) - .exit(span::mock().named("span")) - .done() + .enter(span::expect().named("span")) + .event(event::expect().at_level(Level::DEBUG)) + .exit(span::expect().named("span")) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); diff --git a/tracing-subscriber/tests/filter_log.rs b/tracing-subscriber/tests/filter_log.rs index 8d57ed600b..9810684e56 100644 --- a/tracing-subscriber/tests/filter_log.rs +++ b/tracing-subscriber/tests/filter_log.rs @@ -36,10 +36,10 @@ fn log_is_enabled() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); // Note: we have to set the global default in order to set the `log` max diff --git a/tracing-subscriber/tests/hinted_layer_filters_dont_break_other_layers.rs b/tracing-subscriber/tests/hinted_layer_filters_dont_break_other_layers.rs index 4e5ee4e050..bbb68bd87a 100644 --- a/tracing-subscriber/tests/hinted_layer_filters_dont_break_other_layers.rs +++ b/tracing-subscriber/tests/hinted_layer_filters_dont_break_other_layers.rs @@ -1,9 +1,9 @@ #![cfg(feature = "registry")] use tracing::{Level, Metadata, Subscriber}; use tracing_mock::{ - event, - layer::{self, MockLayer}, - subscriber, + event, layer, + layer::MockLayer, + subscriber::{self}, }; use tracing_subscriber::{filter::DynFilterFn, layer::Context, prelude::*}; @@ -115,20 +115,20 @@ fn filter() -> DynFilterFn { fn unfiltered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } fn filtered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } diff --git a/tracing-subscriber/tests/layer_filter_interests_are_cached.rs b/tracing-subscriber/tests/layer_filter_interests_are_cached.rs index 67e8ba763c..c5f86c3cc9 100644 --- a/tracing-subscriber/tests/layer_filter_interests_are_cached.rs +++ b/tracing-subscriber/tests/layer_filter_interests_are_cached.rs @@ -21,9 +21,9 @@ fn layer_filter_interests_are_cached() { }); let (expect, handle) = layer::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let subscriber = tracing_subscriber::registry().with(expect.with_filter(filter)); diff --git a/tracing-subscriber/tests/layer_filters/boxed.rs b/tracing-subscriber/tests/layer_filters/boxed.rs index b02331a6c3..96566a5441 100644 --- a/tracing-subscriber/tests/layer_filters/boxed.rs +++ b/tracing-subscriber/tests/layer_filters/boxed.rs @@ -3,7 +3,7 @@ use tracing_mock::layer::MockLayer; use tracing_subscriber::{filter, prelude::*, Layer}; fn layer() -> (MockLayer, subscriber::MockHandle) { - layer::mock().done().run_with_handle() + layer::mock().only().run_with_handle() } fn filter() -> filter::DynFilterFn { diff --git a/tracing-subscriber/tests/layer_filters/combinators.rs b/tracing-subscriber/tests/layer_filters/combinators.rs index 6052a2d00c..c5ea3b5151 100644 --- a/tracing-subscriber/tests/layer_filters/combinators.rs +++ b/tracing-subscriber/tests/layer_filters/combinators.rs @@ -12,7 +12,7 @@ fn and() { .at_level(tracing::Level::INFO) .with_target("interesting_target"), ) - .done() + .only() .run_with_handle(); // Enables spans and events with targets starting with `interesting_target`: diff --git a/tracing-subscriber/tests/layer_filters/filter_scopes.rs b/tracing-subscriber/tests/layer_filters/filter_scopes.rs index d5608a8965..b3957e9a30 100644 --- a/tracing-subscriber/tests/layer_filters/filter_scopes.rs +++ b/tracing-subscriber/tests/layer_filters/filter_scopes.rs @@ -4,46 +4,46 @@ use tracing_mock::layer::MockLayer; #[test] fn filters_span_scopes() { let (debug_layer, debug_handle) = layer::named("debug") - .enter(span::mock().at_level(Level::DEBUG)) - .enter(span::mock().at_level(Level::INFO)) - .enter(span::mock().at_level(Level::WARN)) - .enter(span::mock().at_level(Level::ERROR)) + .enter(span::expect().at_level(Level::DEBUG)) + .enter(span::expect().at_level(Level::INFO)) + .enter(span::expect().at_level(Level::WARN)) + .enter(span::expect().at_level(Level::ERROR)) .event(event::msg("hello world").in_scope(vec![ - span::mock().at_level(Level::ERROR), - span::mock().at_level(Level::WARN), - span::mock().at_level(Level::INFO), - span::mock().at_level(Level::DEBUG), + span::expect().at_level(Level::ERROR), + span::expect().at_level(Level::WARN), + span::expect().at_level(Level::INFO), + span::expect().at_level(Level::DEBUG), ])) - .exit(span::mock().at_level(Level::ERROR)) - .exit(span::mock().at_level(Level::WARN)) - .exit(span::mock().at_level(Level::INFO)) - .exit(span::mock().at_level(Level::DEBUG)) - .done() + .exit(span::expect().at_level(Level::ERROR)) + .exit(span::expect().at_level(Level::WARN)) + .exit(span::expect().at_level(Level::INFO)) + .exit(span::expect().at_level(Level::DEBUG)) + .only() .run_with_handle(); let (info_layer, info_handle) = layer::named("info") - .enter(span::mock().at_level(Level::INFO)) - .enter(span::mock().at_level(Level::WARN)) - .enter(span::mock().at_level(Level::ERROR)) + .enter(span::expect().at_level(Level::INFO)) + .enter(span::expect().at_level(Level::WARN)) + .enter(span::expect().at_level(Level::ERROR)) .event(event::msg("hello world").in_scope(vec![ - span::mock().at_level(Level::ERROR), - span::mock().at_level(Level::WARN), - span::mock().at_level(Level::INFO), + span::expect().at_level(Level::ERROR), + span::expect().at_level(Level::WARN), + span::expect().at_level(Level::INFO), ])) - .exit(span::mock().at_level(Level::ERROR)) - .exit(span::mock().at_level(Level::WARN)) - .exit(span::mock().at_level(Level::INFO)) - .done() + .exit(span::expect().at_level(Level::ERROR)) + .exit(span::expect().at_level(Level::WARN)) + .exit(span::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let (warn_layer, warn_handle) = layer::named("warn") - .enter(span::mock().at_level(Level::WARN)) - .enter(span::mock().at_level(Level::ERROR)) + .enter(span::expect().at_level(Level::WARN)) + .enter(span::expect().at_level(Level::ERROR)) .event(event::msg("hello world").in_scope(vec![ - span::mock().at_level(Level::ERROR), - span::mock().at_level(Level::WARN), + span::expect().at_level(Level::ERROR), + span::expect().at_level(Level::WARN), ])) - .exit(span::mock().at_level(Level::ERROR)) - .exit(span::mock().at_level(Level::WARN)) - .done() + .exit(span::expect().at_level(Level::ERROR)) + .exit(span::expect().at_level(Level::WARN)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -70,38 +70,38 @@ fn filters_span_scopes() { fn filters_interleaved_span_scopes() { fn target_layer(target: &'static str) -> (MockLayer, subscriber::MockHandle) { layer::named(format!("target_{}", target)) - .enter(span::mock().with_target(target)) - .enter(span::mock().with_target(target)) + .enter(span::expect().with_target(target)) + .enter(span::expect().with_target(target)) .event(event::msg("hello world").in_scope(vec![ - span::mock().with_target(target), - span::mock().with_target(target), + span::expect().with_target(target), + span::expect().with_target(target), ])) .event( event::msg("hello to my target") .in_scope(vec![ - span::mock().with_target(target), - span::mock().with_target(target), + span::expect().with_target(target), + span::expect().with_target(target), ]) .with_target(target), ) - .exit(span::mock().with_target(target)) - .exit(span::mock().with_target(target)) - .done() + .exit(span::expect().with_target(target)) + .exit(span::expect().with_target(target)) + .only() .run_with_handle() } let (a_layer, a_handle) = target_layer("a"); let (b_layer, b_handle) = target_layer("b"); let (all_layer, all_handle) = layer::named("all") - .enter(span::mock().with_target("b")) - .enter(span::mock().with_target("a")) + .enter(span::expect().with_target("b")) + .enter(span::expect().with_target("a")) .event(event::msg("hello world").in_scope(vec![ - span::mock().with_target("a"), - span::mock().with_target("b"), + span::expect().with_target("a"), + span::expect().with_target("b"), ])) - .exit(span::mock().with_target("a")) - .exit(span::mock().with_target("b")) - .done() + .exit(span::expect().with_target("a")) + .exit(span::expect().with_target("b")) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() diff --git a/tracing-subscriber/tests/layer_filters/main.rs b/tracing-subscriber/tests/layer_filters/main.rs index fed74038c7..5b8812f713 100644 --- a/tracing-subscriber/tests/layer_filters/main.rs +++ b/tracing-subscriber/tests/layer_filters/main.rs @@ -12,23 +12,23 @@ use tracing_mock::{event, layer, span, subscriber}; use tracing_subscriber::{filter, prelude::*, Layer}; #[test] -fn basic_layer_filters() { +fn basic_subscriber_filters() { let (trace_layer, trace_handle) = layer::named("trace") - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let (debug_layer, debug_handle) = layer::named("debug") - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let (info_layer, info_handle) = layer::named("info") - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -47,23 +47,23 @@ fn basic_layer_filters() { } #[test] -fn basic_layer_filters_spans() { +fn basic_subscriber_filters_spans() { let (trace_layer, trace_handle) = layer::named("trace") - .new_span(span::mock().at_level(Level::TRACE)) - .new_span(span::mock().at_level(Level::DEBUG)) - .new_span(span::mock().at_level(Level::INFO)) - .done() + .new_span(span::expect().at_level(Level::TRACE)) + .new_span(span::expect().at_level(Level::DEBUG)) + .new_span(span::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let (debug_layer, debug_handle) = layer::named("debug") - .new_span(span::mock().at_level(Level::DEBUG)) - .new_span(span::mock().at_level(Level::INFO)) - .done() + .new_span(span::expect().at_level(Level::DEBUG)) + .new_span(span::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let (info_layer, info_handle) = layer::named("info") - .new_span(span::mock().at_level(Level::INFO)) - .done() + .new_span(span::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -82,12 +82,12 @@ fn basic_layer_filters_spans() { } #[test] -fn global_filters_layers_still_work() { +fn global_filters_subscribers_still_work() { let (expect, handle) = layer::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -107,9 +107,9 @@ fn global_filters_layers_still_work() { #[test] fn global_filter_interests_are_cached() { let (expect, handle) = layer::mock() - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -133,12 +133,12 @@ fn global_filter_interests_are_cached() { } #[test] -fn global_filters_affect_layer_filters() { +fn global_filters_affect_subscriber_filters() { let (expect, handle) = layer::named("debug") - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() @@ -160,17 +160,17 @@ fn filter_fn() { let (all, all_handle) = layer::named("all_targets") .event(event::msg("hello foo")) .event(event::msg("hello bar")) - .done() + .only() .run_with_handle(); let (foo, foo_handle) = layer::named("foo_target") .event(event::msg("hello foo")) - .done() + .only() .run_with_handle(); let (bar, bar_handle) = layer::named("bar_target") .event(event::msg("hello bar")) - .done() + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() diff --git a/tracing-subscriber/tests/layer_filters/per_event.rs b/tracing-subscriber/tests/layer_filters/per_event.rs index 3a28d94f08..9eb9855426 100644 --- a/tracing-subscriber/tests/layer_filters/per_event.rs +++ b/tracing-subscriber/tests/layer_filters/per_event.rs @@ -40,11 +40,11 @@ impl Filter for FilterEvent { } #[test] -fn per_subscriber_event_field_filtering() { +fn per_layer_event_field_filtering() { let (expect, handle) = layer::mock() - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let _subscriber = tracing_subscriber::registry() diff --git a/tracing-subscriber/tests/layer_filters/targets.rs b/tracing-subscriber/tests/layer_filters/targets.rs index c8133044b1..56f6448822 100644 --- a/tracing-subscriber/tests/layer_filters/targets.rs +++ b/tracing-subscriber/tests/layer_filters/targets.rs @@ -39,7 +39,7 @@ fn inner_layer_short_circuits() { let (layer, handle) = layer::mock() .event(event::msg("hello world")) - .done() + .only() .run_with_handle(); let filter = Targets::new().with_target("magic_target", LevelFilter::DEBUG); diff --git a/tracing-subscriber/tests/layer_filters/trees.rs b/tracing-subscriber/tests/layer_filters/trees.rs index 02830122ca..1418fc40fa 100644 --- a/tracing-subscriber/tests/layer_filters/trees.rs +++ b/tracing-subscriber/tests/layer_filters/trees.rs @@ -4,34 +4,46 @@ use tracing_mock::layer::MockLayer; #[test] fn basic_trees() { let (with_target, with_target_handle) = layer::named("info_with_target") - .event(event::mock().at_level(Level::INFO).with_target("my_target")) - .done() + .event( + event::expect() + .at_level(Level::INFO) + .with_target("my_target"), + ) + .only() .run_with_handle(); let (info, info_handle) = layer::named("info") .event( - event::mock() + event::expect() .at_level(Level::INFO) .with_target(module_path!()), ) - .event(event::mock().at_level(Level::INFO).with_target("my_target")) - .done() + .event( + event::expect() + .at_level(Level::INFO) + .with_target("my_target"), + ) + .only() .run_with_handle(); let (all, all_handle) = layer::named("all") .event( - event::mock() + event::expect() .at_level(Level::INFO) .with_target(module_path!()), ) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::INFO).with_target("my_target")) + .event(event::expect().at_level(Level::TRACE)) + .event( + event::expect() + .at_level(Level::INFO) + .with_target("my_target"), + ) .event( - event::mock() + event::expect() .at_level(Level::TRACE) .with_target("my_target"), ) - .done() + .only() .run_with_handle(); let info_tree = info @@ -57,41 +69,40 @@ fn basic_trees() { fn filter_span_scopes() { fn target_layer(target: &'static str) -> (MockLayer, subscriber::MockHandle) { layer::named(format!("target_{}", target)) - .enter(span::mock().with_target(target).at_level(Level::INFO)) - .event( - event::msg("hello world") - .in_scope(vec![span::mock().with_target(target).at_level(Level::INFO)]), - ) - .exit(span::mock().with_target(target).at_level(Level::INFO)) - .done() + .enter(span::expect().with_target(target).at_level(Level::INFO)) + .event(event::msg("hello world").in_scope(vec![ + span::expect().with_target(target).at_level(Level::INFO), + ])) + .exit(span::expect().with_target(target).at_level(Level::INFO)) + .only() .run_with_handle() } let (a_layer, a_handle) = target_layer("a"); let (b_layer, b_handle) = target_layer("b"); let (info_layer, info_handle) = layer::named("info") - .enter(span::mock().with_target("b").at_level(Level::INFO)) - .enter(span::mock().with_target("a").at_level(Level::INFO)) + .enter(span::expect().with_target("b").at_level(Level::INFO)) + .enter(span::expect().with_target("a").at_level(Level::INFO)) .event(event::msg("hello world").in_scope(vec![ - span::mock().with_target("a").at_level(Level::INFO), - span::mock().with_target("b").at_level(Level::INFO), + span::expect().with_target("a").at_level(Level::INFO), + span::expect().with_target("b").at_level(Level::INFO), ])) - .exit(span::mock().with_target("a").at_level(Level::INFO)) - .exit(span::mock().with_target("b").at_level(Level::INFO)) - .done() + .exit(span::expect().with_target("a").at_level(Level::INFO)) + .exit(span::expect().with_target("b").at_level(Level::INFO)) + .only() .run_with_handle(); let full_scope = vec![ - span::mock().with_target("b").at_level(Level::TRACE), - span::mock().with_target("a").at_level(Level::INFO), - span::mock().with_target("b").at_level(Level::INFO), - span::mock().with_target("a").at_level(Level::TRACE), + span::expect().with_target("b").at_level(Level::TRACE), + span::expect().with_target("a").at_level(Level::INFO), + span::expect().with_target("b").at_level(Level::INFO), + span::expect().with_target("a").at_level(Level::TRACE), ]; let (all_layer, all_handle) = layer::named("all") - .enter(span::mock().with_target("a").at_level(Level::TRACE)) - .enter(span::mock().with_target("b").at_level(Level::INFO)) - .enter(span::mock().with_target("a").at_level(Level::INFO)) - .enter(span::mock().with_target("b").at_level(Level::TRACE)) + .enter(span::expect().with_target("a").at_level(Level::TRACE)) + .enter(span::expect().with_target("b").at_level(Level::INFO)) + .enter(span::expect().with_target("a").at_level(Level::INFO)) + .enter(span::expect().with_target("b").at_level(Level::TRACE)) .event(event::msg("hello world").in_scope(full_scope.clone())) .event( event::msg("hello to my target") @@ -103,11 +114,11 @@ fn filter_span_scopes() { .with_target("b") .in_scope(full_scope), ) - .exit(span::mock().with_target("b").at_level(Level::TRACE)) - .exit(span::mock().with_target("a").at_level(Level::INFO)) - .exit(span::mock().with_target("b").at_level(Level::INFO)) - .exit(span::mock().with_target("a").at_level(Level::TRACE)) - .done() + .exit(span::expect().with_target("b").at_level(Level::TRACE)) + .exit(span::expect().with_target("a").at_level(Level::INFO)) + .exit(span::expect().with_target("b").at_level(Level::INFO)) + .exit(span::expect().with_target("a").at_level(Level::TRACE)) + .only() .run_with_handle(); let a_layer = a_layer.with_filter(filter::filter_fn(|meta| { diff --git a/tracing-subscriber/tests/layer_filters/vec.rs b/tracing-subscriber/tests/layer_filters/vec.rs index dbe3674785..884ec60a95 100644 --- a/tracing-subscriber/tests/layer_filters/vec.rs +++ b/tracing-subscriber/tests/layer_filters/vec.rs @@ -1,27 +1,27 @@ use super::*; use tracing::Subscriber; -use tracing_mock::layer::{self, MockLayer}; +use tracing_mock::layer::MockLayer; #[test] fn with_filters_unboxed() { let (trace_layer, trace_handle) = layer::named("trace") - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let trace_layer = trace_layer.with_filter(LevelFilter::TRACE); let (debug_layer, debug_handle) = layer::named("debug") - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let debug_layer = debug_layer.with_filter(LevelFilter::DEBUG); let (info_layer, info_handle) = layer::named("info") - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let info_layer = info_layer.with_filter(LevelFilter::INFO); @@ -41,23 +41,23 @@ fn with_filters_unboxed() { #[test] fn with_filters_boxed() { let (unfiltered_layer, unfiltered_handle) = layer::named("unfiltered") - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let unfiltered_layer = unfiltered_layer.boxed(); let (debug_layer, debug_handle) = layer::named("debug") - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let debug_layer = debug_layer.with_filter(LevelFilter::DEBUG).boxed(); let (target_layer, target_handle) = layer::named("target") - .event(event::mock().at_level(Level::INFO)) - .done() + .event(event::expect().at_level(Level::INFO)) + .only() .run_with_handle(); let target_layer = target_layer .with_filter(filter::filter_fn(|meta| meta.target() == "my_target")) @@ -116,6 +116,6 @@ fn all_filtered_max_level_hint() { #[test] fn empty_vec() { // Just a None means everything is off - let subscriber = tracing_subscriber::registry().with(Vec::::new()); - assert_eq!(subscriber.max_level_hint(), Some(LevelFilter::OFF)); + let collector = tracing_subscriber::registry().with(Vec::::new()); + assert_eq!(collector.max_level_hint(), Some(LevelFilter::OFF)); } diff --git a/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs b/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs index 13e1a94a3e..6f9ee0c310 100644 --- a/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs +++ b/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs @@ -23,13 +23,13 @@ fn multiple_layer_filter_interests_are_cached() { let seen_info = seen_info2; let (info_layer, info_handle) = layer::named("info") - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let info_layer = info_layer.with_filter(filter); @@ -47,11 +47,11 @@ fn multiple_layer_filter_interests_are_cached() { let seen_warn = seen_warn2; let (warn_layer, warn_handle) = layer::named("warn") - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let warn_layer = warn_layer.with_filter(filter); diff --git a/tracing-subscriber/tests/same_len_filters.rs b/tracing-subscriber/tests/same_len_filters.rs index 879e578d78..839d82e61b 100644 --- a/tracing-subscriber/tests/same_len_filters.rs +++ b/tracing-subscriber/tests/same_len_filters.rs @@ -10,9 +10,9 @@ use tracing_subscriber::{filter::EnvFilter, prelude::*}; fn same_length_targets() { let filter: EnvFilter = "foo=trace,bar=trace".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::TRACE)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::TRACE)) + .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -31,16 +31,16 @@ fn same_num_fields_event() { .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .event( - event::mock() + event::expect() .at_level(Level::TRACE) - .with_fields(field::mock("foo")), + .with_fields(field::expect("foo")), ) .event( - event::mock() + event::expect() .at_level(Level::TRACE) - .with_fields(field::mock("bar")), + .with_fields(field::expect("bar")), ) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); with_default(subscriber, || { @@ -58,18 +58,18 @@ fn same_num_fields_and_name_len() { .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .new_span( - span::mock() + span::expect() .named("foo") .at_level(Level::TRACE) - .with_field(field::mock("bar")), + .with_field(field::expect("bar")), ) .new_span( - span::mock() + span::expect() .named("baz") .at_level(Level::TRACE) - .with_field(field::mock("boz")), + .with_field(field::expect("boz")), ) - .done() + .only() .run_with_handle(); let subscriber = subscriber.with(filter); with_default(subscriber, || { diff --git a/tracing-subscriber/tests/unhinted_layer_filters_dont_break_other_layers.rs b/tracing-subscriber/tests/unhinted_layer_filters_dont_break_other_layers.rs index d8b38345f9..9078b66b35 100644 --- a/tracing-subscriber/tests/unhinted_layer_filters_dont_break_other_layers.rs +++ b/tracing-subscriber/tests/unhinted_layer_filters_dont_break_other_layers.rs @@ -107,20 +107,20 @@ fn filter() -> DynFilterFn { fn unfiltered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::TRACE)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } fn filtered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle() } diff --git a/tracing-subscriber/tests/utils.rs b/tracing-subscriber/tests/utils.rs index e95868d5ea..6cf96b066e 100644 --- a/tracing-subscriber/tests/utils.rs +++ b/tracing-subscriber/tests/utils.rs @@ -7,11 +7,11 @@ use tracing_subscriber::prelude::*; fn init_ext_works() { let (subscriber, finished) = subscriber::mock() .event( - event::mock() + event::expect() .at_level(tracing::Level::INFO) .with_target("init_works"), ) - .done() + .only() .run_with_handle(); let _guard = subscriber.set_default(); diff --git a/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs b/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs index 1bfb4a0adf..9a9f117cdd 100644 --- a/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs +++ b/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs @@ -4,14 +4,11 @@ use std::{ sync::{Arc, Mutex}, }; use tracing::{Level, Subscriber}; -use tracing_mock::{ - event, - layer::{self, MockLayer}, -}; +use tracing_mock::{layer::MockLayer, *}; use tracing_subscriber::{filter, prelude::*}; #[test] -fn vec_layer_filter_interests_are_cached() { +fn vec_subscriber_filter_interests_are_cached() { let mk_filtered = |level: Level, subscriber: MockLayer| { let seen = Arc::new(Mutex::new(HashMap::new())); let filter = filter::filter_fn({ @@ -26,23 +23,23 @@ fn vec_layer_filter_interests_are_cached() { // This layer will return Interest::always for INFO and lower. let (info_layer, info_handle) = layer::named("info") - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let (info_layer, seen_info) = mk_filtered(Level::INFO, info_layer); // This layer will return Interest::always for WARN and lower. let (warn_layer, warn_handle) = layer::named("warn") - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let (warn_layer, seen_warn) = mk_filtered(Level::WARN, warn_layer); diff --git a/tracing/tests/enabled.rs b/tracing/tests/enabled.rs index ea1c69804d..5a4596347e 100644 --- a/tracing/tests/enabled.rs +++ b/tracing/tests/enabled.rs @@ -13,7 +13,7 @@ fn level_and_target() { meta.level() <= &Level::INFO } }) - .done() + .only() .run(); let _guard = tracing::subscriber::set_default(subscriber); @@ -38,7 +38,7 @@ fn span_and_event() { meta.level() <= &Level::INFO } }) - .done() + .only() .run(); let _guard = tracing::subscriber::set_default(subscriber); diff --git a/tracing/tests/event.rs b/tracing/tests/event.rs index 61df19ad3c..6e943c60db 100644 --- a/tracing/tests/event.rs +++ b/tracing/tests/event.rs @@ -22,17 +22,17 @@ macro_rules! event_without_message { fn $name() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("answer") + event::expect().with_fields( + field::expect("answer") .with_value(&42) .and( - field::mock("to_question") + field::expect("to_question") .with_value(&"life, the universe, and everything"), ) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -57,15 +57,19 @@ event_without_message! {nonzeroi32_event_without_message: std::num::NonZeroI32:: #[test] fn event_with_message() { let (subscriber, handle) = subscriber::mock() - .event(event::msg(format_args!( - "hello from my event! yak shaved = {:?}", - true - ))) - .done() + .event( + event::expect().with_fields(field::expect("message").with_value( + &tracing::field::debug(format_args!( + "hello from my tracing::event! yak shaved = {:?}", + true + )), + )), + ) + .only() .run_with_handle(); with_default(subscriber, || { - debug!("hello from my event! yak shaved = {:?}", true); + debug!("hello from my tracing::event! yak shaved = {:?}", true); }); handle.assert_finished(); @@ -76,10 +80,12 @@ fn event_with_message() { fn message_without_delims() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("answer") + event::expect().with_fields( + field::expect("answer") .with_value(&42) - .and(field::mock("question").with_value(&"life, the universe, and everything")) + .and( + field::expect("question").with_value(&"life, the universe, and everything"), + ) .and(field::msg(format_args!( "hello from my event! tricky? {:?}!", true @@ -87,7 +93,7 @@ fn message_without_delims() { .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -103,15 +109,17 @@ fn message_without_delims() { fn string_message_without_delims() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("answer") + event::expect().with_fields( + field::expect("answer") .with_value(&42) - .and(field::mock("question").with_value(&"life, the universe, and everything")) + .and( + field::expect("question").with_value(&"life, the universe, and everything"), + ) .and(field::msg(format_args!("hello from my event"))) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -127,23 +135,23 @@ fn string_message_without_delims() { fn one_with_everything() { let (subscriber, handle) = subscriber::mock() .event( - event::mock() + event::expect() .with_fields( - field::mock("message") + field::expect("message") .with_value(&tracing::field::debug(format_args!( "{:#x} make me one with{what:.>20}", 4_277_009_102u64, what = "everything" ))) - .and(field::mock("foo").with_value(&666)) - .and(field::mock("bar").with_value(&false)) - .and(field::mock("like_a_butterfly").with_value(&42.0)) + .and(field::expect("foo").with_value(&666)) + .and(field::expect("bar").with_value(&false)) + .and(field::expect("like_a_butterfly").with_value(&42.0)) .only(), ) .at_level(Level::ERROR) .with_target("whatever"), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -163,13 +171,13 @@ fn one_with_everything() { fn moved_field() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("foo") + event::expect().with_fields( + field::expect("foo") .with_value(&display("hello from my event")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { let from = "my event"; @@ -184,14 +192,14 @@ fn moved_field() { fn dotted_field_name() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("foo.bar") + event::expect().with_fields( + field::expect("foo.bar") .with_value(&true) - .and(field::mock("foo.baz").with_value(&false)) + .and(field::expect("foo.baz").with_value(&false)) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::event!(Level::INFO, foo.bar = true, foo.baz = false); @@ -205,13 +213,13 @@ fn dotted_field_name() { fn borrowed_field() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("foo") + event::expect().with_fields( + field::expect("foo") .with_value(&display("hello from my event")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { let from = "my event"; @@ -242,15 +250,15 @@ fn move_field_out_of_struct() { }; let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("x") + event::expect().with_fields( + field::expect("x") .with_value(&debug(3.234)) - .and(field::mock("y").with_value(&debug(-1.223))) + .and(field::expect("y").with_value(&debug(-1.223))) .only(), ), ) - .event(event::mock().with_fields(field::mock("position").with_value(&debug(&pos)))) - .done() + .event(event::expect().with_fields(field::expect("position").with_value(&debug(&pos)))) + .only() .run_with_handle(); with_default(subscriber, || { @@ -269,13 +277,13 @@ fn move_field_out_of_struct() { fn display_shorthand() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("my_field") + event::expect().with_fields( + field::expect("my_field") .with_value(&display("hello world")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::event!(Level::TRACE, my_field = %"hello world"); @@ -289,13 +297,13 @@ fn display_shorthand() { fn debug_shorthand() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("my_field") + event::expect().with_fields( + field::expect("my_field") .with_value(&debug("hello world")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::event!(Level::TRACE, my_field = ?"hello world"); @@ -309,14 +317,14 @@ fn debug_shorthand() { fn both_shorthands() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("display_field") + event::expect().with_fields( + field::expect("display_field") .with_value(&display("hello world")) - .and(field::mock("debug_field").with_value(&debug("hello world"))) + .and(field::expect("debug_field").with_value(&debug("hello world"))) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::event!(Level::TRACE, display_field = %"hello world", debug_field = ?"hello world"); @@ -329,9 +337,9 @@ fn both_shorthands() { #[test] fn explicit_child() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) - .event(event::mock().with_explicit_parent(Some("foo"))) - .done() + .new_span(span::expect().named("foo")) + .event(event::expect().with_explicit_parent(Some("foo"))) + .only() .run_with_handle(); with_default(subscriber, || { @@ -346,13 +354,13 @@ fn explicit_child() { #[test] fn explicit_child_at_levels() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) - .event(event::mock().with_explicit_parent(Some("foo"))) - .event(event::mock().with_explicit_parent(Some("foo"))) - .event(event::mock().with_explicit_parent(Some("foo"))) - .event(event::mock().with_explicit_parent(Some("foo"))) - .event(event::mock().with_explicit_parent(Some("foo"))) - .done() + .new_span(span::expect().named("foo")) + .event(event::expect().with_explicit_parent(Some("foo"))) + .event(event::expect().with_explicit_parent(Some("foo"))) + .event(event::expect().with_explicit_parent(Some("foo"))) + .event(event::expect().with_explicit_parent(Some("foo"))) + .event(event::expect().with_explicit_parent(Some("foo"))) + .only() .run_with_handle(); with_default(subscriber, || { @@ -372,15 +380,15 @@ fn explicit_child_at_levels() { fn option_values() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("some_str") + event::expect().with_fields( + field::expect("some_str") .with_value(&"yes") - .and(field::mock("some_bool").with_value(&true)) - .and(field::mock("some_u64").with_value(&42_u64)) + .and(field::expect("some_bool").with_value(&true)) + .and(field::expect("some_u64").with_value(&42_u64)) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -408,15 +416,15 @@ fn option_values() { fn option_ref_values() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("some_str") + event::expect().with_fields( + field::expect("some_str") .with_value(&"yes") - .and(field::mock("some_bool").with_value(&true)) - .and(field::mock("some_u64").with_value(&42_u64)) + .and(field::expect("some_bool").with_value(&true)) + .and(field::expect("some_u64").with_value(&42_u64)) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -444,15 +452,15 @@ fn option_ref_values() { fn option_ref_mut_values() { let (subscriber, handle) = subscriber::mock() .event( - event::mock().with_fields( - field::mock("some_str") + event::expect().with_fields( + field::expect("some_str") .with_value(&"yes") - .and(field::mock("some_bool").with_value(&true)) - .and(field::mock("some_u64").with_value(&42_u64)) + .and(field::expect("some_bool").with_value(&true)) + .and(field::expect("some_u64").with_value(&42_u64)) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -479,11 +487,15 @@ fn option_ref_mut_values() { #[test] fn string_field() { let (subscriber, handle) = subscriber::mock() - .event(event::mock().with_fields(field::mock("my_string").with_value(&"hello").only())) + .event(event::expect().with_fields(field::expect("my_string").with_value(&"hello").only())) .event( - event::mock().with_fields(field::mock("my_string").with_value(&"hello world!").only()), + event::expect().with_fields( + field::expect("my_string") + .with_value(&"hello world!") + .only(), + ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { let mut my_string = String::from("hello"); diff --git a/tracing/tests/filters_dont_leak.rs b/tracing/tests/filters_dont_leak.rs index 2ef1c9c701..df96a4ac72 100644 --- a/tracing/tests/filters_dont_leak.rs +++ b/tracing/tests/filters_dont_leak.rs @@ -13,14 +13,14 @@ fn spans_dont_leak() { let (subscriber, handle) = subscriber::mock() .named("spans/subscriber1") .with_filter(|_| false) - .done() + .only() .run_with_handle(); let _guard = tracing::subscriber::set_default(subscriber); do_span(); - let alice = span::mock().named("alice"); + let alice = span::expect().named("alice"); let (subscriber2, handle2) = subscriber::mock() .named("spans/subscriber2") .with_filter(|_| true) @@ -28,7 +28,7 @@ fn spans_dont_leak() { .enter(alice.clone()) .exit(alice.clone()) .drop_span(alice) - .done() + .only() .run_with_handle(); tracing::subscriber::with_default(subscriber2, || { @@ -53,7 +53,7 @@ fn events_dont_leak() { let (subscriber, handle) = subscriber::mock() .named("events/subscriber1") .with_filter(|_| false) - .done() + .only() .run_with_handle(); let _guard = tracing::subscriber::set_default(subscriber); @@ -63,8 +63,8 @@ fn events_dont_leak() { let (subscriber2, handle2) = subscriber::mock() .named("events/subscriber2") .with_filter(|_| true) - .event(event::mock()) - .done() + .event(event::expect()) + .only() .run_with_handle(); tracing::subscriber::with_default(subscriber2, || { diff --git a/tracing/tests/instrument.rs b/tracing/tests/instrument.rs index a23769e66f..07b6bbfa42 100644 --- a/tracing/tests/instrument.rs +++ b/tracing/tests/instrument.rs @@ -33,17 +33,17 @@ fn span_on_drop() { } let subscriber = subscriber::mock() - .enter(span::mock().named("foo")) - .event(event::mock().at_level(Level::INFO)) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .enter(span::mock().named("bar")) - .event(event::mock().at_level(Level::INFO)) - .exit(span::mock().named("bar")) - .drop_span(span::mock().named("bar")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect().at_level(Level::INFO)) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .enter(span::expect().named("bar")) + .event(event::expect().at_level(Level::INFO)) + .exit(span::expect().named("bar")) + .drop_span(span::expect().named("bar")) + .only() .run(); with_default(subscriber, || { diff --git a/tracing/tests/max_level_hint.rs b/tracing/tests/max_level_hint.rs index 63d3af6357..5c7c476bf3 100644 --- a/tracing/tests/max_level_hint.rs +++ b/tracing/tests/max_level_hint.rs @@ -20,10 +20,10 @@ fn max_level_hints() { ); true }) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); tracing::subscriber::set_global_default(subscriber).unwrap(); diff --git a/tracing/tests/multiple_max_level_hints.rs b/tracing/tests/multiple_max_level_hints.rs index dd50a193b5..81cc8052e9 100644 --- a/tracing/tests/multiple_max_level_hints.rs +++ b/tracing/tests/multiple_max_level_hints.rs @@ -35,10 +35,10 @@ fn multiple_max_level_hints() { ); level <= &Level::INFO }) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let (subscriber2, handle2) = subscriber::mock() .named("subscriber2") @@ -51,11 +51,11 @@ fn multiple_max_level_hints() { ); level <= &Level::DEBUG }) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() + .event(event::expect().at_level(Level::INFO)) + .event(event::expect().at_level(Level::DEBUG)) + .event(event::expect().at_level(Level::WARN)) + .event(event::expect().at_level(Level::ERROR)) + .only() .run_with_handle(); let dispatch1 = tracing::Dispatch::new(subscriber1); diff --git a/tracing/tests/no_subscriber.rs b/tracing/tests/no_subscriber.rs index 5f927c1dee..77e2c106c1 100644 --- a/tracing/tests/no_subscriber.rs +++ b/tracing/tests/no_subscriber.rs @@ -1,14 +1,15 @@ #![cfg(feature = "std")] -use tracing::subscriber::{self, NoSubscriber}; +use tracing_mock::subscriber; #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] -fn no_subscriber_disables_global() { +fn no_collector_disables_global() { // Reproduces https://github.com/tokio-rs/tracing/issues/1999 - let (subscriber, handle) = tracing_mock::subscriber::mock().done().run_with_handle(); - subscriber::set_global_default(subscriber).expect("setting global default must succeed"); - subscriber::with_default(NoSubscriber::default(), || { + let (subscriber, handle) = subscriber::mock().only().run_with_handle(); + tracing::subscriber::set_global_default(subscriber) + .expect("setting global default must succeed"); + tracing::subscriber::with_default(tracing::subscriber::NoSubscriber::default(), || { tracing::info!("this should not be recorded"); }); handle.assert_finished(); diff --git a/tracing/tests/scoped_clobbers_default.rs b/tracing/tests/scoped_clobbers_default.rs index 362d34a82c..dfd6fc9de2 100644 --- a/tracing/tests/scoped_clobbers_default.rs +++ b/tracing/tests/scoped_clobbers_default.rs @@ -8,12 +8,12 @@ fn scoped_clobbers_global() { let (scoped, scoped_handle) = subscriber::mock() .event(event::msg("before global")) .event(event::msg("before drop")) - .done() + .only() .run_with_handle(); let (global, global_handle) = subscriber::mock() .event(event::msg("after drop")) - .done() + .only() .run_with_handle(); // Set a scoped default subscriber, returning a guard. diff --git a/tracing/tests/span.rs b/tracing/tests/span.rs index e4e17757eb..40ba193da8 100644 --- a/tracing/tests/span.rs +++ b/tracing/tests/span.rs @@ -67,12 +67,12 @@ fn handles_to_different_spans_with_the_same_metadata_are_not_equal() { #[test] fn spans_always_go_to_the_subscriber_that_tagged_them() { let subscriber1 = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run(); let subscriber2 = subscriber::mock().run(); @@ -94,12 +94,12 @@ fn spans_always_go_to_the_subscriber_that_tagged_them() { #[test] fn spans_always_go_to_the_subscriber_that_tagged_them_even_across_threads() { let subscriber1 = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run(); let foo = with_default(subscriber1, || { let foo = tracing::span!(Level::TRACE, "foo"); @@ -122,10 +122,10 @@ fn spans_always_go_to_the_subscriber_that_tagged_them_even_across_threads() { #[test] fn dropping_a_span_calls_drop_span() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { let span = tracing::span!(Level::TRACE, "foo"); @@ -140,11 +140,11 @@ fn dropping_a_span_calls_drop_span() { #[test] fn span_closes_after_event() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .event(event::mock()) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect()) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { tracing::span!(Level::TRACE, "foo").in_scope(|| { @@ -159,14 +159,14 @@ fn span_closes_after_event() { #[test] fn new_span_after_event() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .event(event::mock()) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .enter(span::mock().named("bar")) - .exit(span::mock().named("bar")) - .drop_span(span::mock().named("bar")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect()) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .enter(span::expect().named("bar")) + .exit(span::expect().named("bar")) + .drop_span(span::expect().named("bar")) + .only() .run_with_handle(); with_default(subscriber, || { tracing::span!(Level::TRACE, "foo").in_scope(|| { @@ -182,11 +182,11 @@ fn new_span_after_event() { #[test] fn event_outside_of_span() { let (subscriber, handle) = subscriber::mock() - .event(event::mock()) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .event(event::expect()) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { tracing::debug!("my tracing::event!"); @@ -200,7 +200,7 @@ fn event_outside_of_span() { #[test] fn cloning_a_span_calls_clone_span() { let (subscriber, handle) = subscriber::mock() - .clone_span(span::mock().named("foo")) + .clone_span(span::expect().named("foo")) .run_with_handle(); with_default(subscriber, || { let span = tracing::span!(Level::TRACE, "foo"); @@ -216,9 +216,9 @@ fn cloning_a_span_calls_clone_span() { #[test] fn drop_span_when_exiting_dispatchers_context() { let (subscriber, handle) = subscriber::mock() - .clone_span(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .clone_span(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); with_default(subscriber, || { let span = tracing::span!(Level::TRACE, "foo"); @@ -233,15 +233,15 @@ fn drop_span_when_exiting_dispatchers_context() { #[test] fn clone_and_drop_span_always_go_to_the_subscriber_that_tagged_the_span() { let (subscriber1, handle1) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .clone_span(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .clone_span(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .run_with_handle(); - let subscriber2 = subscriber::mock().done().run(); + let subscriber2 = subscriber::mock().only().run(); let foo = with_default(subscriber1, || { let foo = tracing::span!(Level::TRACE, "foo"); @@ -264,10 +264,10 @@ fn clone_and_drop_span_always_go_to_the_subscriber_that_tagged_the_span() { #[test] fn span_closes_when_exited() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { let foo = tracing::span!(Level::TRACE, "foo"); @@ -284,11 +284,11 @@ fn span_closes_when_exited() { #[test] fn enter() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .event(event::mock()) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect()) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { let foo = tracing::span!(Level::TRACE, "foo"); @@ -303,11 +303,11 @@ fn enter() { #[test] fn entered() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .event(event::mock()) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect()) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { let _span = tracing::span!(Level::TRACE, "foo").entered(); @@ -321,11 +321,11 @@ fn entered() { #[test] fn entered_api() { let (subscriber, handle) = subscriber::mock() - .enter(span::mock().named("foo")) - .event(event::mock()) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .event(event::expect()) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { let span = tracing::span!(Level::TRACE, "foo").entered(); @@ -342,16 +342,16 @@ fn entered_api() { fn moved_field() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("bar") + span::expect().named("foo").with_field( + field::expect("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { let from = "my span"; @@ -371,11 +371,11 @@ fn moved_field() { fn dotted_field_name() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock() + span::expect() .named("foo") - .with_field(field::mock("fields.bar").with_value(&true).only()), + .with_field(field::expect("fields.bar").with_value(&true).only()), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::span!(Level::TRACE, "foo", fields.bar = true); @@ -389,16 +389,16 @@ fn dotted_field_name() { fn borrowed_field() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("bar") + span::expect().named("foo").with_field( + field::expect("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -432,17 +432,17 @@ fn move_field_out_of_struct() { }; let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("x") + span::expect().named("foo").with_field( + field::expect("x") .with_value(&debug(3.234)) - .and(field::mock("y").with_value(&debug(-1.223))) + .and(field::expect("y").with_value(&debug(-1.223))) .only(), ), ) .new_span( - span::mock() + span::expect() .named("bar") - .with_field(field::mock("position").with_value(&debug(&pos)).only()), + .with_field(field::expect("position").with_value(&debug(&pos)).only()), ) .run_with_handle(); @@ -465,10 +465,10 @@ fn move_field_out_of_struct() { fn float_values() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("x") + span::expect().named("foo").with_field( + field::expect("x") .with_value(&3.234) - .and(field::mock("y").with_value(&-1.223)) + .and(field::expect("y").with_value(&-1.223)) .only(), ), ) @@ -490,19 +490,19 @@ fn float_values() { fn add_field_after_new_span() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock() + span::expect() .named("foo") - .with_field(field::mock("bar").with_value(&5) - .and(field::mock("baz").with_value).only()), + .with_field(field::expect("bar").with_value(&5) + .and(field::expect("baz").with_value).only()), ) .record( - span::mock().named("foo"), - field::mock("baz").with_value(&true).only(), + span::expect().named("foo"), + field::expect("baz").with_value(&true).only(), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -518,19 +518,19 @@ fn add_field_after_new_span() { #[test] fn add_fields_only_after_new_span() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) + .new_span(span::expect().named("foo")) .record( - span::mock().named("foo"), - field::mock("bar").with_value(&5).only(), + span::expect().named("foo"), + field::expect("bar").with_value(&5).only(), ) .record( - span::mock().named("foo"), - field::mock("baz").with_value(&true).only(), + span::expect().named("foo"), + field::expect("baz").with_value(&true).only(), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -549,21 +549,21 @@ fn add_fields_only_after_new_span() { fn record_new_value_for_field() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("bar") + span::expect().named("foo").with_field( + field::expect("bar") .with_value(&5) - .and(field::mock("baz").with_value(&false)) + .and(field::expect("baz").with_value(&false)) .only(), ), ) .record( - span::mock().named("foo"), - field::mock("baz").with_value(&true).only(), + span::expect().named("foo"), + field::expect("baz").with_value(&true).only(), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -580,25 +580,25 @@ fn record_new_value_for_field() { fn record_new_values_for_fields() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("bar") + span::expect().named("foo").with_field( + field::expect("bar") .with_value(&4) - .and(field::mock("baz").with_value(&false)) + .and(field::expect("baz").with_value(&false)) .only(), ), ) .record( - span::mock().named("foo"), - field::mock("bar").with_value(&5).only(), + span::expect().named("foo"), + field::expect("bar").with_value(&5).only(), ) .record( - span::mock().named("foo"), - field::mock("baz").with_value(&true).only(), + span::expect().named("foo"), + field::expect("baz").with_value(&true).only(), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -616,12 +616,12 @@ fn record_new_values_for_fields() { fn new_span_with_target_and_log_level() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock() + span::expect() .named("foo") .with_target("app_span") .at_level(Level::DEBUG), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -635,8 +635,8 @@ fn new_span_with_target_and_log_level() { #[test] fn explicit_root_span_is_root() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo").with_explicit_parent(None)) - .done() + .new_span(span::expect().named("foo").with_explicit_parent(None)) + .only() .run_with_handle(); with_default(subscriber, || { @@ -650,11 +650,11 @@ fn explicit_root_span_is_root() { #[test] fn explicit_root_span_is_root_regardless_of_ctx() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) - .enter(span::mock().named("foo")) - .new_span(span::mock().named("bar").with_explicit_parent(None)) - .exit(span::mock().named("foo")) - .done() + .new_span(span::expect().named("foo")) + .enter(span::expect().named("foo")) + .new_span(span::expect().named("bar").with_explicit_parent(None)) + .exit(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -670,9 +670,13 @@ fn explicit_root_span_is_root_regardless_of_ctx() { #[test] fn explicit_child() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) - .new_span(span::mock().named("bar").with_explicit_parent(Some("foo"))) - .done() + .new_span(span::expect().named("foo")) + .new_span( + span::expect() + .named("bar") + .with_explicit_parent(Some("foo")), + ) + .only() .run_with_handle(); with_default(subscriber, || { @@ -687,13 +691,13 @@ fn explicit_child() { #[test] fn explicit_child_at_levels() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) - .new_span(span::mock().named("a").with_explicit_parent(Some("foo"))) - .new_span(span::mock().named("b").with_explicit_parent(Some("foo"))) - .new_span(span::mock().named("c").with_explicit_parent(Some("foo"))) - .new_span(span::mock().named("d").with_explicit_parent(Some("foo"))) - .new_span(span::mock().named("e").with_explicit_parent(Some("foo"))) - .done() + .new_span(span::expect().named("foo")) + .new_span(span::expect().named("a").with_explicit_parent(Some("foo"))) + .new_span(span::expect().named("b").with_explicit_parent(Some("foo"))) + .new_span(span::expect().named("c").with_explicit_parent(Some("foo"))) + .new_span(span::expect().named("d").with_explicit_parent(Some("foo"))) + .new_span(span::expect().named("e").with_explicit_parent(Some("foo"))) + .only() .run_with_handle(); with_default(subscriber, || { @@ -712,12 +716,16 @@ fn explicit_child_at_levels() { #[test] fn explicit_child_regardless_of_ctx() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) - .new_span(span::mock().named("bar")) - .enter(span::mock().named("bar")) - .new_span(span::mock().named("baz").with_explicit_parent(Some("foo"))) - .exit(span::mock().named("bar")) - .done() + .new_span(span::expect().named("foo")) + .new_span(span::expect().named("bar")) + .enter(span::expect().named("bar")) + .new_span( + span::expect() + .named("baz") + .with_explicit_parent(Some("foo")), + ) + .exit(span::expect().named("bar")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -733,8 +741,8 @@ fn explicit_child_regardless_of_ctx() { #[test] fn contextual_root() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo").with_contextual_parent(None)) - .done() + .new_span(span::expect().named("foo").with_contextual_parent(None)) + .only() .run_with_handle(); with_default(subscriber, || { @@ -748,15 +756,15 @@ fn contextual_root() { #[test] fn contextual_child() { let (subscriber, handle) = subscriber::mock() - .new_span(span::mock().named("foo")) - .enter(span::mock().named("foo")) + .new_span(span::expect().named("foo")) + .enter(span::expect().named("foo")) .new_span( - span::mock() + span::expect() .named("bar") .with_contextual_parent(Some("foo")), ) - .exit(span::mock().named("foo")) - .done() + .exit(span::expect().named("foo")) + .only() .run_with_handle(); with_default(subscriber, || { @@ -773,13 +781,13 @@ fn contextual_child() { fn display_shorthand() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("my_span").with_field( - field::mock("my_field") + span::expect().named("my_span").with_field( + field::expect("my_field") .with_value(&display("hello world")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::span!(Level::TRACE, "my_span", my_field = %"hello world"); @@ -793,13 +801,13 @@ fn display_shorthand() { fn debug_shorthand() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("my_span").with_field( - field::mock("my_field") + span::expect().named("my_span").with_field( + field::expect("my_field") .with_value(&debug("hello world")) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::span!(Level::TRACE, "my_span", my_field = ?"hello world"); @@ -813,14 +821,14 @@ fn debug_shorthand() { fn both_shorthands() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("my_span").with_field( - field::mock("display_field") + span::expect().named("my_span").with_field( + field::expect("display_field") .with_value(&display("hello world")) - .and(field::mock("debug_field").with_value(&debug("hello world"))) + .and(field::expect("debug_field").with_value(&debug("hello world"))) .only(), ), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { tracing::span!(Level::TRACE, "my_span", display_field = %"hello world", debug_field = ?"hello world"); diff --git a/tracing/tests/subscriber.rs b/tracing/tests/subscriber.rs index 15557c107f..0357d61ac7 100644 --- a/tracing/tests/subscriber.rs +++ b/tracing/tests/subscriber.rs @@ -61,16 +61,16 @@ fn event_macros_dont_infinite_loop() { fn boxed_subscriber() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("bar") + span::expect().named("foo").with_field( + field::expect("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) - .done() + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) + .only() .run_with_handle(); let subscriber: Box = Box::new(subscriber); @@ -94,20 +94,20 @@ fn arced_subscriber() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock().named("foo").with_field( - field::mock("bar") + span::expect().named("foo").with_field( + field::expect("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::mock().named("foo")) - .exit(span::mock().named("foo")) - .drop_span(span::mock().named("foo")) + .enter(span::expect().named("foo")) + .exit(span::expect().named("foo")) + .drop_span(span::expect().named("foo")) .event( - event::mock() - .with_fields(field::mock("message").with_value(&display("hello from my event"))), + event::expect() + .with_fields(field::expect("message").with_value(&display("hello from my event"))), ) - .done() + .only() .run_with_handle(); let subscriber: Arc = Arc::new(subscriber); From dc636dfad0492fe761a264ef93b135f53592296b Mon Sep 17 00:00:00 2001 From: Hayden Stainsby Date: Fri, 11 Nov 2022 18:53:06 +0100 Subject: [PATCH 02/34] mock: change helper functions to `expect::` (#2377) * mock: change helper functions to `expect::` The current format of test expectations in `tracing-mock` isn't ideal. The format `span::expect` requires importing `tracing_mock::` which may conflict with imports from other tracing crates, especially `tracing-core`. So we change the order and move the functions into a module called `expect` so that: * `event::expect` becomes `expect::event` * `span::expect` becomes `expect::span` * `field::expect` becomes `expect::field` This format has two advantages. 1. It reads as natural English, e.g "expect span" 2. It is no longer common to import the modules directly. Regarding point (2), the following format was previously common: ```rust use tracing_mock::field; field::expect(); ``` This import of the `field` module may then conflict with importing the same from `tracing_core`, making it necessary to rename one of the imports. The same code would now be written: ```rust use tracing_mock::expect; expect::field(); ``` Which is less likely to conflict. This change also fixes an unused warning on `MockHandle::new` when the `tracing-subscriber` feature is not enabled. Refs: #539 --- tracing-attributes/tests/async_fn.rs | 76 ++--- tracing-attributes/tests/destructuring.rs | 42 +-- tracing-attributes/tests/err.rs | 62 ++-- tracing-attributes/tests/fields.rs | 51 ++-- tracing-attributes/tests/follows_from.rs | 20 +- tracing-attributes/tests/instrument.rs | 42 +-- tracing-attributes/tests/levels.rs | 90 +++--- tracing-attributes/tests/names.rs | 18 +- tracing-attributes/tests/parents.rs | 10 +- tracing-attributes/tests/ret.rs | 70 ++--- tracing-attributes/tests/targets.rs | 24 +- tracing-futures/src/lib.rs | 98 +++---- tracing-futures/tests/std_future.rs | 48 ++-- tracing-mock/src/event.rs | 18 +- .../src/{expectation.rs => expect.rs} | 24 +- tracing-mock/src/field.rs | 14 +- tracing-mock/src/layer.rs | 2 +- tracing-mock/src/lib.rs | 2 +- tracing-mock/src/span.rs | 10 +- tracing-mock/src/subscriber.rs | 2 +- ...d_layer_filters_dont_break_other_layers.rs | 18 +- tracing-subscriber/tests/env_filter/main.rs | 122 ++++---- .../tests/env_filter/per_layer.rs | 58 ++-- tracing-subscriber/tests/field_filter.rs | 42 +-- tracing-subscriber/tests/filter_log.rs | 6 +- ...d_layer_filters_dont_break_other_layers.rs | 18 +- .../layer_filter_interests_are_cached.rs | 6 +- .../tests/layer_filters/filter_scopes.rs | 84 +++--- .../tests/layer_filters/main.rs | 42 +-- .../tests/layer_filters/per_event.rs | 6 +- .../tests/layer_filters/targets.rs | 1 + .../tests/layer_filters/trees.rs | 58 ++-- tracing-subscriber/tests/layer_filters/vec.rs | 26 +- .../multiple_layer_filter_interests_cached.rs | 22 +- tracing-subscriber/tests/same_len_filters.rs | 20 +- ...d_layer_filters_dont_break_other_layers.rs | 18 +- tracing-subscriber/tests/utils.rs | 2 +- .../vec_subscriber_filter_interests_cached.rs | 20 +- tracing/tests/event.rs | 112 ++++---- tracing/tests/filters_dont_leak.rs | 4 +- tracing/tests/instrument.rs | 20 +- tracing/tests/max_level_hint.rs | 6 +- tracing/tests/multiple_max_level_hints.rs | 14 +- tracing/tests/span.rs | 272 +++++++++--------- tracing/tests/subscriber.rs | 27 +- 45 files changed, 873 insertions(+), 874 deletions(-) rename tracing-mock/src/{expectation.rs => expect.rs} (51%) diff --git a/tracing-attributes/tests/async_fn.rs b/tracing-attributes/tests/async_fn.rs index 924d46bed6..ed36d0d6fb 100644 --- a/tracing-attributes/tests/async_fn.rs +++ b/tracing-attributes/tests/async_fn.rs @@ -84,15 +84,15 @@ fn repro_1831_2() -> impl Future> { #[test] fn async_fn_only_enters_for_polls() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("test_async_fn")) - .enter(span::expect().named("test_async_fn")) - .event(event::expect().with_fields(field::expect("awaiting").with_value(&true))) - .exit(span::expect().named("test_async_fn")) - .enter(span::expect().named("test_async_fn")) - .exit(span::expect().named("test_async_fn")) - .enter(span::expect().named("test_async_fn")) - .exit(span::expect().named("test_async_fn")) - .drop_span(span::expect().named("test_async_fn")) + .new_span(expect::span().named("test_async_fn")) + .enter(expect::span().named("test_async_fn")) + .event(expect::event().with_fields(expect::field("awaiting").with_value(&true))) + .exit(expect::span().named("test_async_fn")) + .enter(expect::span().named("test_async_fn")) + .exit(expect::span().named("test_async_fn")) + .enter(expect::span().named("test_async_fn")) + .exit(expect::span().named("test_async_fn")) + .drop_span(expect::span().named("test_async_fn")) .only() .run_with_handle(); with_default(subscriber, || { @@ -113,14 +113,14 @@ fn async_fn_nested() { tracing::trace!(nested = true); } - let span = span::expect().named("test_async_fns_nested"); - let span2 = span::expect().named("test_async_fns_nested_other"); + let span = expect::span().named("test_async_fns_nested"); + let span2 = expect::span().named("test_async_fns_nested_other"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .new_span(span2.clone()) .enter(span2.clone()) - .event(event::expect().with_fields(field::expect("nested").with_value(&true))) + .event(expect::event().with_fields(expect::field("nested").with_value(&true))) .exit(span2.clone()) .enter(span2.clone()) .exit(span2.clone()) @@ -191,26 +191,26 @@ fn async_fn_with_async_trait() { } } - let span = span::expect().named("foo"); - let span2 = span::expect().named("bar"); - let span3 = span::expect().named("baz"); + let span = expect::span().named("foo"); + let span2 = expect::span().named("bar"); + let span3 = expect::span().named("baz"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::expect("self")) - .with_field(field::expect("v")), + .with_field(expect::field("self")) + .with_field(expect::field("v")), ) .enter(span.clone()) .new_span(span3.clone()) .enter(span3.clone()) - .event(event::expect().with_fields(field::expect("val").with_value(&2u64))) + .event(expect::event().with_fields(expect::field("val").with_value(&2u64))) .exit(span3.clone()) .enter(span3.clone()) .exit(span3.clone()) .drop_span(span3) - .new_span(span2.clone().with_field(field::expect("self"))) + .new_span(span2.clone().with_field(expect::field("self"))) .enter(span2.clone()) - .event(event::expect().with_fields(field::expect("val").with_value(&5u64))) + .event(expect::event().with_fields(expect::field("val").with_value(&5u64))) .exit(span2.clone()) .enter(span2.clone()) .exit(span2.clone()) @@ -255,15 +255,15 @@ fn async_fn_with_async_trait_and_fields_expressions() { async fn call(&mut self, _v: usize) {} } - let span = span::expect().named("call"); + let span = expect::span().named("call"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("_v") + expect::field("_v") .with_value(&5usize) - .and(field::expect("test").with_value(&tracing::field::debug(10))) - .and(field::expect("val").with_value(&42u64)) - .and(field::expect("val2").with_value(&42u64)), + .and(expect::field("test").with_value(&tracing::field::debug(10))) + .and(expect::field("val").with_value(&42u64)) + .and(expect::field("val2").with_value(&42u64)), ), ) .enter(span.clone()) @@ -322,27 +322,27 @@ fn async_fn_with_async_trait_and_fields_expressions_with_generic_parameter() { async fn call_with_mut_self(&mut self) {} } - //let span = span::expect().named("call"); - let span2 = span::expect().named("call_with_self"); - let span3 = span::expect().named("call_with_mut_self"); - let span4 = span::expect().named("sync_fun"); + //let span = span::mock().named("call"); + let span2 = expect::span().named("call_with_self"); + let span3 = expect::span().named("call_with_mut_self"); + let span4 = expect::span().named("sync_fun"); let (subscriber, handle) = subscriber::mock() /*.new_span(span.clone() .with_field( - field::expect("Self").with_value(&"TestImpler"))) + expect::field("Self").with_value(&"TestImpler"))) .enter(span.clone()) .exit(span.clone()) .drop_span(span)*/ .new_span( span2 .clone() - .with_field(field::expect("Self").with_value(&std::any::type_name::())), + .with_field(expect::field("Self").with_value(&std::any::type_name::())), ) .enter(span2.clone()) .new_span( span4 .clone() - .with_field(field::expect("Self").with_value(&std::any::type_name::())), + .with_field(expect::field("Self").with_value(&std::any::type_name::())), ) .enter(span4.clone()) .exit(span4.clone()) @@ -355,7 +355,7 @@ fn async_fn_with_async_trait_and_fields_expressions_with_generic_parameter() { .new_span( span3 .clone() - .with_field(field::expect("Self").with_value(&std::any::type_name::())), + .with_field(expect::field("Self").with_value(&std::any::type_name::())), ) .enter(span3.clone()) .exit(span3.clone()) @@ -397,7 +397,7 @@ fn out_of_scope_fields() { } } - let span = span::expect().named("call"); + let span = expect::span().named("call"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) @@ -430,8 +430,8 @@ fn manual_impl_future() { } } - let span = span::expect().named("manual_impl_future"); - let poll_event = || event::expect().with_fields(field::expect("poll").with_value(&true)); + let span = expect::span().named("manual_impl_future"); + let poll_event = || expect::event().with_fields(expect::field("poll").with_value(&true)); let (subscriber, handle) = subscriber::mock() // await manual_impl_future @@ -463,8 +463,8 @@ fn manual_box_pin() { }) } - let span = span::expect().named("manual_box_pin"); - let poll_event = || event::expect().with_fields(field::expect("poll").with_value(&true)); + let span = expect::span().named("manual_box_pin"); + let poll_event = || expect::event().with_fields(expect::field("poll").with_value(&true)); let (subscriber, handle) = subscriber::mock() // await manual_box_pin diff --git a/tracing-attributes/tests/destructuring.rs b/tracing-attributes/tests/destructuring.rs index 6adbe501c3..cc4fecf3f2 100644 --- a/tracing-attributes/tests/destructuring.rs +++ b/tracing-attributes/tests/destructuring.rs @@ -7,14 +7,14 @@ fn destructure_tuples() { #[instrument] fn my_fn((arg1, arg2): (usize, usize)) {} - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&format_args!("1")) - .and(field::expect("arg2").with_value(&format_args!("2"))) + .and(expect::field("arg2").with_value(&format_args!("2"))) .only(), ), ) @@ -36,16 +36,16 @@ fn destructure_nested_tuples() { #[instrument] fn my_fn(((arg1, arg2), (arg3, arg4)): ((usize, usize), (usize, usize))) {} - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&format_args!("1")) - .and(field::expect("arg2").with_value(&format_args!("2"))) - .and(field::expect("arg3").with_value(&format_args!("3"))) - .and(field::expect("arg4").with_value(&format_args!("4"))) + .and(expect::field("arg2").with_value(&format_args!("2"))) + .and(expect::field("arg3").with_value(&format_args!("3"))) + .and(expect::field("arg4").with_value(&format_args!("4"))) .only(), ), ) @@ -67,12 +67,12 @@ fn destructure_refs() { #[instrument] fn my_fn(&arg1: &usize) {} - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::expect("arg1").with_value(&1usize).only()), + .with_field(expect::field("arg1").with_value(&1usize).only()), ) .enter(span.clone()) .exit(span.clone()) @@ -94,14 +94,14 @@ fn destructure_tuple_structs() { #[instrument] fn my_fn(Foo(arg1, arg2): Foo) {} - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&format_args!("1")) - .and(field::expect("arg2").with_value(&format_args!("2"))) + .and(expect::field("arg2").with_value(&format_args!("2"))) .only(), ), ) @@ -135,14 +135,14 @@ fn destructure_structs() { let _ = (arg1, arg2); } - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&format_args!("1")) - .and(field::expect("arg2").with_value(&format_args!("2"))) + .and(expect::field("arg2").with_value(&format_args!("2"))) .only(), ), ) @@ -180,16 +180,16 @@ fn destructure_everything() { let _ = (arg1, arg2, arg3, arg4); } - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&format_args!("1")) - .and(field::expect("arg2").with_value(&format_args!("2"))) - .and(field::expect("arg3").with_value(&format_args!("3"))) - .and(field::expect("arg4").with_value(&format_args!("4"))) + .and(expect::field("arg2").with_value(&format_args!("2"))) + .and(expect::field("arg3").with_value(&format_args!("3"))) + .and(expect::field("arg4").with_value(&format_args!("4"))) .only(), ), ) diff --git a/tracing-attributes/tests/err.rs b/tracing-attributes/tests/err.rs index 23b28804af..bee7aa5f4e 100644 --- a/tracing-attributes/tests/err.rs +++ b/tracing-attributes/tests/err.rs @@ -21,11 +21,11 @@ fn err_suspicious_else() -> Result { #[test] fn test() { - let span = span::expect().named("err"); + let span = expect::span().named("err"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) .only() @@ -42,11 +42,11 @@ fn err_early_return() -> Result { #[test] fn test_early_return() { - let span = span::expect().named("err_early_return"); + let span = expect::span().named("err_early_return"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) .only() @@ -65,18 +65,18 @@ async fn err_async(polls: usize) -> Result { #[test] fn test_async() { - let span = span::expect().named("err_async"); + let span = expect::span().named("err_async"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("awaiting").with_value(&true)) + expect::event() + .with_fields(expect::field("awaiting").with_value(&true)) .at_level(Level::TRACE), ) .exit(span.clone()) .enter(span.clone()) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR)) .exit(span.clone()) .enter(span.clone()) .exit(span.clone()) @@ -97,11 +97,11 @@ fn err_mut(out: &mut u8) -> Result<(), TryFromIntError> { #[test] fn test_mut() { - let span = span::expect().named("err_mut"); + let span = expect::span().named("err_mut"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR)) .exit(span.clone()) .drop_span(span) .only() @@ -121,18 +121,18 @@ async fn err_mut_async(polls: usize, out: &mut u8) -> Result<(), TryFromIntError #[test] fn test_mut_async() { - let span = span::expect().named("err_mut_async"); + let span = expect::span().named("err_mut_async"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("awaiting").with_value(&true)) + expect::event() + .with_fields(expect::field("awaiting").with_value(&true)) .at_level(Level::TRACE), ) .exit(span.clone()) .enter(span.clone()) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR)) .exit(span.clone()) .enter(span.clone()) .exit(span.clone()) @@ -154,12 +154,12 @@ fn impl_trait_return_type() { Ok(0..x) } - let span = span::expect().named("returns_impl_trait"); + let span = expect::span().named("returns_impl_trait"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::expect("x").with_value(&10usize).only()), + .with_field(expect::field("x").with_value(&10usize).only()), ) .enter(span.clone()) .exit(span.clone()) @@ -183,13 +183,13 @@ fn err_dbg() -> Result { #[test] fn test_err_dbg() { - let span = span::expect().named("err_dbg"); + let span = expect::span().named("err_dbg"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect().at_level(Level::ERROR).with_fields( - field::expect("error") + expect::event().at_level(Level::ERROR).with_fields( + expect::field("error") // use the actual error value that will be emitted, so // that this test doesn't break if the standard library // changes the `fmt::Debug` output from the error type @@ -207,13 +207,13 @@ fn test_err_dbg() { #[test] fn test_err_display_default() { - let span = span::expect().named("err"); + let span = expect::span().named("err"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect().at_level(Level::ERROR).with_fields( - field::expect("error") + expect::event().at_level(Level::ERROR).with_fields( + expect::field("error") // by default, errors will be emitted with their display values .with_value(&tracing::field::display(u8::try_from(1234).unwrap_err())), ), @@ -229,13 +229,13 @@ fn test_err_display_default() { #[test] fn test_err_custom_target() { let filter: EnvFilter = "my_target=error".parse().expect("filter should parse"); - let span = span::expect().named("error_span").with_target("my_target"); + let span = expect::span().named("error_span").with_target("my_target"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() + expect::event() .at_level(Level::ERROR) .with_target("my_target"), ) @@ -264,11 +264,11 @@ fn err_info() -> Result { #[test] fn test_err_info() { - let span = span::expect().named("err_info"); + let span = expect::span().named("err_info"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .exit(span.clone()) .drop_span(span) .only() @@ -284,13 +284,13 @@ fn err_dbg_info() -> Result { #[test] fn test_err_dbg_info() { - let span = span::expect().named("err_dbg_info"); + let span = expect::span().named("err_dbg_info"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect().at_level(Level::INFO).with_fields( - field::expect("error") + expect::event().at_level(Level::INFO).with_fields( + expect::field("error") // use the actual error value that will be emitted, so // that this test doesn't break if the standard library // changes the `fmt::Debug` output from the error type @@ -313,11 +313,11 @@ fn err_warn_info() -> Result { #[test] fn test_err_warn_info() { - let span = span::expect().named("err_warn_info").at_level(Level::WARN); + let span = expect::span().named("err_warn_info").at_level(Level::WARN); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .exit(span.clone()) .drop_span(span) .only() diff --git a/tracing-attributes/tests/fields.rs b/tracing-attributes/tests/fields.rs index 5911b393b7..a3b23d7ac2 100644 --- a/tracing-attributes/tests/fields.rs +++ b/tracing-attributes/tests/fields.rs @@ -1,8 +1,6 @@ use tracing::subscriber::with_default; use tracing_attributes::instrument; -use tracing_mock::field::expect; -use tracing_mock::span::NewSpan; -use tracing_mock::*; +use tracing_mock::{expect, span::NewSpan, subscriber}; #[instrument(fields(foo = "bar", dsa = true, num = 1))] fn fn_no_param() {} @@ -48,11 +46,11 @@ impl HasField { #[test] fn fields() { - let span = span::expect().with_field( - expect("foo") + let span = expect::span().with_field( + expect::field("foo") .with_value(&"bar") - .and(expect("dsa").with_value(&true)) - .and(expect("num").with_value(&1)) + .and(expect::field("dsa").with_value(&true)) + .and(expect::field("num").with_value(&1)) .only(), ); run_test(span, || { @@ -62,10 +60,10 @@ fn fields() { #[test] fn expr_field() { - let span = span::expect().with_field( - expect("s") + let span = expect::span().with_field( + expect::field("s") .with_value(&"hello world") - .and(expect("len").with_value(&"hello world".len())) + .and(expect::field("len").with_value(&"hello world".len())) .only(), ); run_test(span, || { @@ -75,11 +73,11 @@ fn expr_field() { #[test] fn two_expr_fields() { - let span = span::expect().with_field( - expect("s") + let span = expect::span().with_field( + expect::field("s") .with_value(&"hello world") - .and(expect("s.len").with_value(&"hello world".len())) - .and(expect("s.is_empty").with_value(&false)) + .and(expect::field("s.len").with_value(&"hello world".len())) + .and(expect::field("s.is_empty").with_value(&false)) .only(), ); run_test(span, || { @@ -89,19 +87,19 @@ fn two_expr_fields() { #[test] fn clashy_expr_field() { - let span = span::expect().with_field( + let span = expect::span().with_field( // Overriding the `s` field should record `s` as a `Display` value, // rather than as a `Debug` value. - expect("s") + expect::field("s") .with_value(&tracing::field::display("hello world")) - .and(expect("s.len").with_value(&"hello world".len())) + .and(expect::field("s.len").with_value(&"hello world".len())) .only(), ); run_test(span, || { fn_clashy_expr_field("hello world"); }); - let span = span::expect().with_field(expect("s").with_value(&"s").only()); + let span = expect::span().with_field(expect::field("s").with_value(&"s").only()); run_test(span, || { fn_clashy_expr_field2("hello world"); }); @@ -109,7 +107,8 @@ fn clashy_expr_field() { #[test] fn self_expr_field() { - let span = span::expect().with_field(expect("my_field").with_value(&"hello world").only()); + let span = + expect::span().with_field(expect::field("my_field").with_value(&"hello world").only()); run_test(span, || { let has_field = HasField { my_field: "hello world", @@ -120,10 +119,10 @@ fn self_expr_field() { #[test] fn parameters_with_fields() { - let span = span::expect().with_field( - expect("foo") + let span = expect::span().with_field( + expect::field("foo") .with_value(&"bar") - .and(expect("param").with_value(&1u32)) + .and(expect::field("param").with_value(&1u32)) .only(), ); run_test(span, || { @@ -133,7 +132,7 @@ fn parameters_with_fields() { #[test] fn empty_field() { - let span = span::expect().with_field(expect("foo").with_value(&"bar").only()); + let span = expect::span().with_field(expect::field("foo").with_value(&"bar").only()); run_test(span, || { fn_empty_field(); }); @@ -141,7 +140,7 @@ fn empty_field() { #[test] fn string_field() { - let span = span::expect().with_field(expect("s").with_value(&"hello world").only()); + let span = expect::span().with_field(expect::field("s").with_value(&"hello world").only()); run_test(span, || { fn_string(String::from("hello world")); }); @@ -150,8 +149,8 @@ fn string_field() { fn run_test T, T>(span: NewSpan, fun: F) { let (subscriber, handle) = subscriber::mock() .new_span(span) - .enter(span::expect()) - .exit(span::expect()) + .enter(expect::span()) + .exit(expect::span()) .only() .run_with_handle(); diff --git a/tracing-attributes/tests/follows_from.rs b/tracing-attributes/tests/follows_from.rs index 4295442865..6b5526b82e 100644 --- a/tracing-attributes/tests/follows_from.rs +++ b/tracing-attributes/tests/follows_from.rs @@ -13,10 +13,10 @@ fn follows_from_current() {} #[test] fn follows_from_sync_test() { - let cause_a = span::expect().named("cause_a"); - let cause_b = span::expect().named("cause_b"); - let cause_c = span::expect().named("cause_c"); - let consequence = span::expect().named("with_follows_from_sync"); + let cause_a = expect::span().named("cause_a"); + let cause_b = expect::span().named("cause_b"); + let cause_c = expect::span().named("cause_c"); + let consequence = expect::span().named("with_follows_from_sync"); let (subscriber, handle) = subscriber::mock() .new_span(cause_a.clone()) @@ -44,10 +44,10 @@ fn follows_from_sync_test() { #[test] fn follows_from_async_test() { - let cause_a = span::expect().named("cause_a"); - let cause_b = span::expect().named("cause_b"); - let cause_c = span::expect().named("cause_c"); - let consequence = span::expect().named("with_follows_from_async"); + let cause_a = expect::span().named("cause_a"); + let cause_b = expect::span().named("cause_b"); + let cause_c = expect::span().named("cause_c"); + let consequence = expect::span().named("with_follows_from_async"); let (subscriber, handle) = subscriber::mock() .new_span(cause_a.clone()) @@ -79,8 +79,8 @@ fn follows_from_async_test() { #[test] fn follows_from_current_test() { - let cause = span::expect().named("cause"); - let consequence = span::expect().named("follows_from_current"); + let cause = expect::span().named("cause"); + let consequence = expect::span().named("follows_from_current"); let (subscriber, handle) = subscriber::mock() .new_span(cause.clone()) diff --git a/tracing-attributes/tests/instrument.rs b/tracing-attributes/tests/instrument.rs index 41b853c8e0..f751eebf69 100644 --- a/tracing-attributes/tests/instrument.rs +++ b/tracing-attributes/tests/instrument.rs @@ -20,11 +20,11 @@ fn override_everything() { #[instrument(level = Level::DEBUG, target = "my_target")] fn my_other_fn() {} - let span = span::expect() + let span = expect::span() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::expect() + let span2 = expect::span() .named("my_other_fn") .at_level(Level::DEBUG) .with_target("my_target"); @@ -53,21 +53,21 @@ fn fields() { #[instrument(target = "my_target", level = "debug")] fn my_fn(arg1: usize, arg2: bool) {} - let span = span::expect() + let span = expect::span() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::expect() + let span2 = expect::span() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&2usize) - .and(field::expect("arg2").with_value(&false)) + .and(expect::field("arg2").with_value(&false)) .only(), ), ) @@ -76,9 +76,9 @@ fn fields() { .drop_span(span) .new_span( span2.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&3usize) - .and(field::expect("arg2").with_value(&true)) + .and(expect::field("arg2").with_value(&true)) .only(), ), ) @@ -106,17 +106,17 @@ fn skip() { #[instrument(target = "my_target", level = "debug", skip_all)] fn my_fn2(_arg1: usize, _arg2: UnDebug, _arg3: UnDebug) {} - let span = span::expect() + let span = expect::span() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::expect() + let span2 = expect::span() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span3 = span::expect() + let span3 = expect::span() .named("my_fn2") .at_level(Level::DEBUG) .with_target("my_target"); @@ -124,7 +124,7 @@ fn skip() { let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::expect("arg1").with_value(&2usize).only()), + .with_field(expect::field("arg1").with_value(&2usize).only()), ) .enter(span.clone()) .exit(span.clone()) @@ -132,7 +132,7 @@ fn skip() { .new_span( span2 .clone() - .with_field(field::expect("arg1").with_value(&3usize).only()), + .with_field(expect::field("arg1").with_value(&3usize).only()), ) .enter(span2.clone()) .exit(span2.clone()) @@ -165,14 +165,14 @@ fn generics() { { } - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("arg1") + expect::field("arg1") .with_value(&format_args!("Foo")) - .and(field::expect("arg2").with_value(&format_args!("false"))), + .and(expect::field("arg2").with_value(&format_args!("false"))), ), ) .enter(span.clone()) @@ -198,14 +198,14 @@ fn methods() { fn my_fn(&self, arg1: usize) {} } - let span = span::expect().named("my_fn"); + let span = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::expect("self") + expect::field("self") .with_value(&format_args!("Foo")) - .and(field::expect("arg1").with_value(&42usize)), + .and(expect::field("arg1").with_value(&42usize)), ), ) .enter(span.clone()) @@ -229,12 +229,12 @@ fn impl_trait_return_type() { 0..x } - let span = span::expect().named("returns_impl_trait"); + let span = expect::span().named("returns_impl_trait"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::expect("x").with_value(&10usize).only()), + .with_field(expect::field("x").with_value(&10usize).only()), ) .enter(span.clone()) .exit(span.clone()) diff --git a/tracing-attributes/tests/levels.rs b/tracing-attributes/tests/levels.rs index b4bb1bd907..ed80dc16a6 100644 --- a/tracing-attributes/tests/levels.rs +++ b/tracing-attributes/tests/levels.rs @@ -20,21 +20,21 @@ fn named_levels() { #[instrument(level = "eRrOr")] fn error() {} let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("trace").at_level(Level::TRACE)) - .enter(span::expect().named("trace").at_level(Level::TRACE)) - .exit(span::expect().named("trace").at_level(Level::TRACE)) - .new_span(span::expect().named("debug").at_level(Level::DEBUG)) - .enter(span::expect().named("debug").at_level(Level::DEBUG)) - .exit(span::expect().named("debug").at_level(Level::DEBUG)) - .new_span(span::expect().named("info").at_level(Level::INFO)) - .enter(span::expect().named("info").at_level(Level::INFO)) - .exit(span::expect().named("info").at_level(Level::INFO)) - .new_span(span::expect().named("warn").at_level(Level::WARN)) - .enter(span::expect().named("warn").at_level(Level::WARN)) - .exit(span::expect().named("warn").at_level(Level::WARN)) - .new_span(span::expect().named("error").at_level(Level::ERROR)) - .enter(span::expect().named("error").at_level(Level::ERROR)) - .exit(span::expect().named("error").at_level(Level::ERROR)) + .new_span(expect::span().named("trace").at_level(Level::TRACE)) + .enter(expect::span().named("trace").at_level(Level::TRACE)) + .exit(expect::span().named("trace").at_level(Level::TRACE)) + .new_span(expect::span().named("debug").at_level(Level::DEBUG)) + .enter(expect::span().named("debug").at_level(Level::DEBUG)) + .exit(expect::span().named("debug").at_level(Level::DEBUG)) + .new_span(expect::span().named("info").at_level(Level::INFO)) + .enter(expect::span().named("info").at_level(Level::INFO)) + .exit(expect::span().named("info").at_level(Level::INFO)) + .new_span(expect::span().named("warn").at_level(Level::WARN)) + .enter(expect::span().named("warn").at_level(Level::WARN)) + .exit(expect::span().named("warn").at_level(Level::WARN)) + .new_span(expect::span().named("error").at_level(Level::ERROR)) + .enter(expect::span().named("error").at_level(Level::ERROR)) + .exit(expect::span().named("error").at_level(Level::ERROR)) .only() .run_with_handle(); @@ -66,21 +66,21 @@ fn numeric_levels() { #[instrument(level = 5)] fn error() {} let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("trace").at_level(Level::TRACE)) - .enter(span::expect().named("trace").at_level(Level::TRACE)) - .exit(span::expect().named("trace").at_level(Level::TRACE)) - .new_span(span::expect().named("debug").at_level(Level::DEBUG)) - .enter(span::expect().named("debug").at_level(Level::DEBUG)) - .exit(span::expect().named("debug").at_level(Level::DEBUG)) - .new_span(span::expect().named("info").at_level(Level::INFO)) - .enter(span::expect().named("info").at_level(Level::INFO)) - .exit(span::expect().named("info").at_level(Level::INFO)) - .new_span(span::expect().named("warn").at_level(Level::WARN)) - .enter(span::expect().named("warn").at_level(Level::WARN)) - .exit(span::expect().named("warn").at_level(Level::WARN)) - .new_span(span::expect().named("error").at_level(Level::ERROR)) - .enter(span::expect().named("error").at_level(Level::ERROR)) - .exit(span::expect().named("error").at_level(Level::ERROR)) + .new_span(expect::span().named("trace").at_level(Level::TRACE)) + .enter(expect::span().named("trace").at_level(Level::TRACE)) + .exit(expect::span().named("trace").at_level(Level::TRACE)) + .new_span(expect::span().named("debug").at_level(Level::DEBUG)) + .enter(expect::span().named("debug").at_level(Level::DEBUG)) + .exit(expect::span().named("debug").at_level(Level::DEBUG)) + .new_span(expect::span().named("info").at_level(Level::INFO)) + .enter(expect::span().named("info").at_level(Level::INFO)) + .exit(expect::span().named("info").at_level(Level::INFO)) + .new_span(expect::span().named("warn").at_level(Level::WARN)) + .enter(expect::span().named("warn").at_level(Level::WARN)) + .exit(expect::span().named("warn").at_level(Level::WARN)) + .new_span(expect::span().named("error").at_level(Level::ERROR)) + .enter(expect::span().named("error").at_level(Level::ERROR)) + .exit(expect::span().named("error").at_level(Level::ERROR)) .only() .run_with_handle(); @@ -112,21 +112,21 @@ fn enum_levels() { #[instrument(level = Level::ERROR)] fn error() {} let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("trace").at_level(Level::TRACE)) - .enter(span::expect().named("trace").at_level(Level::TRACE)) - .exit(span::expect().named("trace").at_level(Level::TRACE)) - .new_span(span::expect().named("debug").at_level(Level::DEBUG)) - .enter(span::expect().named("debug").at_level(Level::DEBUG)) - .exit(span::expect().named("debug").at_level(Level::DEBUG)) - .new_span(span::expect().named("info").at_level(Level::INFO)) - .enter(span::expect().named("info").at_level(Level::INFO)) - .exit(span::expect().named("info").at_level(Level::INFO)) - .new_span(span::expect().named("warn").at_level(Level::WARN)) - .enter(span::expect().named("warn").at_level(Level::WARN)) - .exit(span::expect().named("warn").at_level(Level::WARN)) - .new_span(span::expect().named("error").at_level(Level::ERROR)) - .enter(span::expect().named("error").at_level(Level::ERROR)) - .exit(span::expect().named("error").at_level(Level::ERROR)) + .new_span(expect::span().named("trace").at_level(Level::TRACE)) + .enter(expect::span().named("trace").at_level(Level::TRACE)) + .exit(expect::span().named("trace").at_level(Level::TRACE)) + .new_span(expect::span().named("debug").at_level(Level::DEBUG)) + .enter(expect::span().named("debug").at_level(Level::DEBUG)) + .exit(expect::span().named("debug").at_level(Level::DEBUG)) + .new_span(expect::span().named("info").at_level(Level::INFO)) + .enter(expect::span().named("info").at_level(Level::INFO)) + .exit(expect::span().named("info").at_level(Level::INFO)) + .new_span(expect::span().named("warn").at_level(Level::WARN)) + .enter(expect::span().named("warn").at_level(Level::WARN)) + .exit(expect::span().named("warn").at_level(Level::WARN)) + .new_span(expect::span().named("error").at_level(Level::ERROR)) + .enter(expect::span().named("error").at_level(Level::ERROR)) + .exit(expect::span().named("error").at_level(Level::ERROR)) .only() .run_with_handle(); diff --git a/tracing-attributes/tests/names.rs b/tracing-attributes/tests/names.rs index 6161c68053..03e3dbfa45 100644 --- a/tracing-attributes/tests/names.rs +++ b/tracing-attributes/tests/names.rs @@ -17,9 +17,9 @@ fn custom_name_no_equals() {} #[test] fn default_name_test() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("default_name")) - .enter(span::expect().named("default_name")) - .exit(span::expect().named("default_name")) + .new_span(expect::span().named("default_name")) + .enter(expect::span().named("default_name")) + .exit(expect::span().named("default_name")) .only() .run_with_handle(); @@ -33,9 +33,9 @@ fn default_name_test() { #[test] fn custom_name_test() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("my_name")) - .enter(span::expect().named("my_name")) - .exit(span::expect().named("my_name")) + .new_span(expect::span().named("my_name")) + .enter(expect::span().named("my_name")) + .exit(expect::span().named("my_name")) .only() .run_with_handle(); @@ -49,9 +49,9 @@ fn custom_name_test() { #[test] fn custom_name_no_equals_test() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("my_other_name")) - .enter(span::expect().named("my_other_name")) - .exit(span::expect().named("my_other_name")) + .new_span(expect::span().named("my_other_name")) + .enter(expect::span().named("my_other_name")) + .exit(expect::span().named("my_other_name")) .only() .run_with_handle(); diff --git a/tracing-attributes/tests/parents.rs b/tracing-attributes/tests/parents.rs index d3069f3063..d4559415d9 100644 --- a/tracing-attributes/tests/parents.rs +++ b/tracing-attributes/tests/parents.rs @@ -14,8 +14,8 @@ where #[test] fn default_parent_test() { - let contextual_parent = span::expect().named("contextual_parent"); - let child = span::expect().named("with_default_parent"); + let contextual_parent = expect::span().named("contextual_parent"); + let child = expect::span().named("with_default_parent"); let (subscriber, handle) = subscriber::mock() .new_span( @@ -60,9 +60,9 @@ fn default_parent_test() { #[test] fn explicit_parent_test() { - let contextual_parent = span::expect().named("contextual_parent"); - let explicit_parent = span::expect().named("explicit_parent"); - let child = span::expect().named("with_explicit_parent"); + let contextual_parent = expect::span().named("contextual_parent"); + let explicit_parent = expect::span().named("explicit_parent"); + let child = expect::span().named("with_explicit_parent"); let (subscriber, handle) = subscriber::mock() .new_span( diff --git a/tracing-attributes/tests/ret.rs b/tracing-attributes/tests/ret.rs index 40275df3fd..90bd9e185d 100644 --- a/tracing-attributes/tests/ret.rs +++ b/tracing-attributes/tests/ret.rs @@ -19,13 +19,13 @@ fn ret_with_target() -> i32 { #[test] fn test() { - let span = span::expect().named("ret"); + let span = expect::span().named("ret"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) @@ -40,7 +40,7 @@ fn test() { #[test] fn test_custom_target() { let filter: EnvFilter = "my_target=info".parse().expect("filter should parse"); - let span = span::expect() + let span = expect::span() .named("ret_with_target") .with_target("my_target"); @@ -48,8 +48,8 @@ fn test_custom_target() { .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO) .with_target("my_target"), ) @@ -71,13 +71,13 @@ fn ret_warn() -> i32 { #[test] fn test_warn() { - let span = span::expect().named("ret_warn"); + let span = expect::span().named("ret_warn"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(42))) .at_level(Level::WARN), ) .exit(span.clone()) @@ -98,18 +98,18 @@ fn ret_mut(a: &mut i32) -> i32 { #[test] fn test_mut() { - let span = span::expect().named("ret_mut"); + let span = expect::span().named("ret_mut"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("a").with_value(&tracing::field::display(2))) + expect::event() + .with_fields(expect::field("a").with_value(&tracing::field::display(2))) .at_level(Level::INFO), ) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(2))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(2))) .at_level(Level::INFO), ) .exit(span.clone()) @@ -128,13 +128,13 @@ async fn ret_async() -> i32 { #[test] fn test_async() { - let span = span::expect().named("ret_async"); + let span = expect::span().named("ret_async"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) @@ -155,13 +155,13 @@ fn ret_impl_type() -> impl Copy { #[test] fn test_impl_type() { - let span = span::expect().named("ret_impl_type"); + let span = expect::span().named("ret_impl_type"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) @@ -180,13 +180,13 @@ fn ret_display() -> i32 { #[test] fn test_dbg() { - let span = span::expect().named("ret_display"); + let span = expect::span().named("ret_display"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::display(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::display(42))) .at_level(Level::INFO), ) .exit(span.clone()) @@ -205,14 +205,14 @@ fn ret_and_err() -> Result { #[test] fn test_ret_and_err() { - let span = span::expect().named("ret_and_err"); + let span = expect::span().named("ret_and_err"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() + expect::event() .with_fields( - field::expect("error") + expect::field("error") .with_value(&tracing::field::display(u8::try_from(1234).unwrap_err())) .only(), ) @@ -234,14 +234,14 @@ fn ret_and_ok() -> Result { #[test] fn test_ret_and_ok() { - let span = span::expect().named("ret_and_ok"); + let span = expect::span().named("ret_and_ok"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() + expect::event() .with_fields( - field::expect("return") + expect::field("return") .with_value(&tracing::field::debug(u8::try_from(123).unwrap())) .only(), ) @@ -263,13 +263,13 @@ fn ret_warn_info() -> i32 { #[test] fn test_warn_info() { - let span = span::expect().named("ret_warn_info").at_level(Level::WARN); + let span = expect::span().named("ret_warn_info").at_level(Level::WARN); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(42))) .at_level(Level::INFO), ) .exit(span.clone()) @@ -288,13 +288,13 @@ fn ret_dbg_warn() -> i32 { #[test] fn test_dbg_warn() { - let span = span::expect().named("ret_dbg_warn").at_level(Level::INFO); + let span = expect::span().named("ret_dbg_warn").at_level(Level::INFO); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::expect() - .with_fields(field::expect("return").with_value(&tracing::field::debug(42))) + expect::event() + .with_fields(expect::field("return").with_value(&tracing::field::debug(42))) .at_level(Level::WARN), ) .exit(span.clone()) diff --git a/tracing-attributes/tests/targets.rs b/tracing-attributes/tests/targets.rs index 3a545ebff9..0e70287d3e 100644 --- a/tracing-attributes/tests/targets.rs +++ b/tracing-attributes/tests/targets.rs @@ -24,32 +24,32 @@ mod my_mod { fn default_targets() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect() + expect::span() .named("default_target") .with_target(module_path!()), ) .enter( - span::expect() + expect::span() .named("default_target") .with_target(module_path!()), ) .exit( - span::expect() + expect::span() .named("default_target") .with_target(module_path!()), ) .new_span( - span::expect() + expect::span() .named("default_target") .with_target(my_mod::MODULE_PATH), ) .enter( - span::expect() + expect::span() .named("default_target") .with_target(my_mod::MODULE_PATH), ) .exit( - span::expect() + expect::span() .named("default_target") .with_target(my_mod::MODULE_PATH), ) @@ -68,32 +68,32 @@ fn default_targets() { fn custom_targets() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect() + expect::span() .named("custom_target") .with_target("my_target"), ) .enter( - span::expect() + expect::span() .named("custom_target") .with_target("my_target"), ) .exit( - span::expect() + expect::span() .named("custom_target") .with_target("my_target"), ) .new_span( - span::expect() + expect::span() .named("custom_target") .with_target("my_other_target"), ) .enter( - span::expect() + expect::span() .named("custom_target") .with_target("my_other_target"), ) .exit( - span::expect() + expect::span() .named("custom_target") .with_target("my_other_target"), ) diff --git a/tracing-futures/src/lib.rs b/tracing-futures/src/lib.rs index 2795d87253..c79e748a0d 100644 --- a/tracing-futures/src/lib.rs +++ b/tracing-futures/src/lib.rs @@ -634,13 +634,13 @@ mod tests { #[test] fn future_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -655,13 +655,13 @@ mod tests { #[test] fn future_error_ends_span() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -677,17 +677,17 @@ mod tests { #[test] fn stream_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .run_with_handle(); with_default(subscriber, || { stream::iter_ok::<_, ()>(&[1, 2, 3]) @@ -702,14 +702,14 @@ mod tests { // #[test] // fn span_follows_future_onto_threadpool() { // let (subscriber, handle) = subscriber::mock() - // .enter(span::expect().named("a")) - // .enter(span::expect().named("b")) - // .exit(span::expect().named("b")) - // .enter(span::expect().named("b")) - // .exit(span::expect().named("b")) - // .drop_span(span::expect().named("b")) - // .exit(span::expect().named("a")) - // .drop_span(span::expect().named("a")) + // .enter(expect::span().named("a")) + // .enter(expect::span().named("b")) + // .exit(expect::span().named("b")) + // .enter(expect::span().named("b")) + // .exit(expect::span().named("b")) + // .drop_span(expect::span().named("b")) + // .exit(expect::span().named("a")) + // .drop_span(expect::span().named("a")) // .only() // .run_with_handle(); // let mut runtime = tokio::runtime::Runtime::new().unwrap(); @@ -740,15 +740,15 @@ mod tests { #[test] fn stream_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .run_with_handle(); with_default(subscriber, || { Instrument::instrument(stream::iter(&[1, 2, 3]), tracing::trace_span!("foo")) @@ -762,13 +762,13 @@ mod tests { #[test] fn sink_enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .run_with_handle(); with_default(subscriber, || { Instrument::instrument(sink::drain(), tracing::trace_span!("foo")) diff --git a/tracing-futures/tests/std_future.rs b/tracing-futures/tests/std_future.rs index 71f888ce0b..4f29fd73cd 100644 --- a/tracing-futures/tests/std_future.rs +++ b/tracing-futures/tests/std_future.rs @@ -8,13 +8,13 @@ use tracing_mock::*; #[test] fn enter_exit_is_reasonable() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -27,13 +27,13 @@ fn enter_exit_is_reasonable() { #[test] fn error_ends_span() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -66,16 +66,16 @@ fn span_on_drop() { } let subscriber = subscriber::mock() - .enter(span::expect().named("foo")) - .event(event::expect().at_level(Level::INFO)) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) - .enter(span::expect().named("bar")) - .event(event::expect().at_level(Level::INFO)) - .exit(span::expect().named("bar")) - .drop_span(span::expect().named("bar")) + .enter(expect::span().named("foo")) + .event(expect::event().at_level(Level::INFO)) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) + .enter(expect::span().named("bar")) + .event(expect::event().at_level(Level::INFO)) + .exit(expect::span().named("bar")) + .drop_span(expect::span().named("bar")) .only() .run(); diff --git a/tracing-mock/src/event.rs b/tracing-mock/src/event.rs index cd3bef76a3..0713ec0bae 100644 --- a/tracing-mock/src/event.rs +++ b/tracing-mock/src/event.rs @@ -1,5 +1,5 @@ #![allow(missing_docs)] -use super::{field, metadata::ExpectedMetadata, span, Parent}; +use super::{expect, field, metadata::ExpectedMetadata, span, Parent}; use std::fmt; @@ -9,20 +9,14 @@ use std::fmt; /// `subscriber` module. #[derive(Default, Eq, PartialEq)] pub struct ExpectedEvent { - fields: Option, - parent: Option, - in_spans: Vec, - metadata: ExpectedMetadata, -} - -pub fn expect() -> ExpectedEvent { - ExpectedEvent { - ..Default::default() - } + pub(super) fields: Option, + pub(super) parent: Option, + pub(super) in_spans: Vec, + pub(super) metadata: ExpectedMetadata, } pub fn msg(message: impl fmt::Display) -> ExpectedEvent { - expect().with_fields(field::msg(message)) + expect::event().with_fields(field::msg(message)) } impl ExpectedEvent { diff --git a/tracing-mock/src/expectation.rs b/tracing-mock/src/expect.rs similarity index 51% rename from tracing-mock/src/expectation.rs rename to tracing-mock/src/expect.rs index cd48728ae7..a21f260e8d 100644 --- a/tracing-mock/src/expectation.rs +++ b/tracing-mock/src/expect.rs @@ -1,6 +1,6 @@ use crate::{ event::ExpectedEvent, - field::ExpectedFields, + field::{ExpectedField, ExpectedFields, ExpectedValue}, span::{ExpectedSpan, NewSpan}, }; @@ -19,3 +19,25 @@ pub(crate) enum Expect { NewSpan(NewSpan), Nothing, } + +pub fn event() -> ExpectedEvent { + ExpectedEvent { + ..Default::default() + } +} + +pub fn field(name: K) -> ExpectedField +where + String: From, +{ + ExpectedField { + name: name.into(), + value: ExpectedValue::Any, + } +} + +pub fn span() -> ExpectedSpan { + ExpectedSpan { + ..Default::default() + } +} diff --git a/tracing-mock/src/field.rs b/tracing-mock/src/field.rs index be3f9c47cf..ea5f7a4eb7 100644 --- a/tracing-mock/src/field.rs +++ b/tracing-mock/src/field.rs @@ -15,8 +15,8 @@ pub struct ExpectedFields { #[derive(Debug)] pub struct ExpectedField { - name: String, - value: ExpectedValue, + pub(super) name: String, + pub(super) value: ExpectedValue, } #[derive(Debug)] @@ -55,16 +55,6 @@ impl PartialEq for ExpectedValue { } } -pub fn expect(name: K) -> ExpectedField -where - String: From, -{ - ExpectedField { - name: name.into(), - value: ExpectedValue::Any, - } -} - pub fn msg(message: impl fmt::Display) -> ExpectedField { ExpectedField { name: "message".to_string(), diff --git a/tracing-mock/src/layer.rs b/tracing-mock/src/layer.rs index 85509ab075..c577163dee 100644 --- a/tracing-mock/src/layer.rs +++ b/tracing-mock/src/layer.rs @@ -1,7 +1,7 @@ #![allow(missing_docs, dead_code)] use crate::{ event::ExpectedEvent, - expectation::Expect, + expect::Expect, field::ExpectedFields, span::{ExpectedSpan, NewSpan}, subscriber::MockHandle, diff --git a/tracing-mock/src/lib.rs b/tracing-mock/src/lib.rs index a8ba0865b7..e7a6e8b0e2 100644 --- a/tracing-mock/src/lib.rs +++ b/tracing-mock/src/lib.rs @@ -4,7 +4,7 @@ use std::{ }; pub mod event; -mod expectation; +pub mod expect; pub mod field; mod metadata; pub mod span; diff --git a/tracing-mock/src/span.rs b/tracing-mock/src/span.rs index 35cab3ebb9..9af084fe69 100644 --- a/tracing-mock/src/span.rs +++ b/tracing-mock/src/span.rs @@ -1,5 +1,5 @@ #![allow(missing_docs)] -use super::{field::ExpectedFields, metadata::ExpectedMetadata, Parent}; +use super::{expect, field::ExpectedFields, metadata::ExpectedMetadata, Parent}; use std::fmt; /// A mock span. @@ -18,17 +18,11 @@ pub struct NewSpan { pub(crate) parent: Option, } -pub fn expect() -> ExpectedSpan { - ExpectedSpan { - ..Default::default() - } -} - pub fn named(name: I) -> ExpectedSpan where I: Into, { - expect().named(name) + expect::span().named(name) } impl ExpectedSpan { diff --git a/tracing-mock/src/subscriber.rs b/tracing-mock/src/subscriber.rs index 3049993fe8..f7e2929903 100644 --- a/tracing-mock/src/subscriber.rs +++ b/tracing-mock/src/subscriber.rs @@ -1,7 +1,7 @@ #![allow(missing_docs)] use crate::{ event::ExpectedEvent, - expectation::Expect, + expect::Expect, field::ExpectedFields, span::{ExpectedSpan, NewSpan}, }; diff --git a/tracing-subscriber/tests/cached_layer_filters_dont_break_other_layers.rs b/tracing-subscriber/tests/cached_layer_filters_dont_break_other_layers.rs index 478b6e9b20..b6d767739d 100644 --- a/tracing-subscriber/tests/cached_layer_filters_dont_break_other_layers.rs +++ b/tracing-subscriber/tests/cached_layer_filters_dont_break_other_layers.rs @@ -1,7 +1,7 @@ #![cfg(feature = "registry")] use tracing::Level; use tracing_mock::{ - event, + expect, layer::{self, MockLayer}, subscriber, }; @@ -107,20 +107,20 @@ fn filter() -> LevelFilter { fn unfiltered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::expect().at_level(Level::TRACE)) - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle() } fn filtered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle() } diff --git a/tracing-subscriber/tests/env_filter/main.rs b/tracing-subscriber/tests/env_filter/main.rs index 2ec008dd68..21dbc1d37c 100644 --- a/tracing-subscriber/tests/env_filter/main.rs +++ b/tracing-subscriber/tests/env_filter/main.rs @@ -3,7 +3,7 @@ mod per_layer; use tracing::{self, subscriber::with_default, Level}; -use tracing_mock::{event, field, layer, span, subscriber}; +use tracing_mock::{expect, layer, span, subscriber}; use tracing_subscriber::{ filter::{EnvFilter, LevelFilter}, prelude::*, @@ -13,9 +13,9 @@ use tracing_subscriber::{ fn level_filter_event() { let filter: EnvFilter = "info".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -38,16 +38,16 @@ fn same_name_spans() { .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .new_span( - span::expect() + expect::span() .named("foo") .at_level(Level::TRACE) - .with_field(field::expect("bar")), + .with_field(expect::field("bar")), ) .new_span( - span::expect() + expect::span() .named("foo") .at_level(Level::TRACE) - .with_field(field::expect("baz")), + .with_field(expect::field("baz")), ) .only() .run_with_handle(); @@ -64,11 +64,11 @@ fn same_name_spans() { fn level_filter_event_with_target() { let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) - .event(event::expect().at_level(Level::WARN).with_target("stuff")) - .event(event::expect().at_level(Level::ERROR)) - .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG).with_target("stuff")) + .event(expect::event().at_level(Level::WARN).with_target("stuff")) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR).with_target("stuff")) .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -98,7 +98,7 @@ fn level_filter_event_with_target_and_span_global() { let (subscriber, handle) = subscriber::mock() .enter(cool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) @@ -133,11 +133,11 @@ fn not_order_dependent() { let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) - .event(event::expect().at_level(Level::WARN).with_target("stuff")) - .event(event::expect().at_level(Level::ERROR)) - .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG).with_target("stuff")) + .event(expect::event().at_level(Level::WARN).with_target("stuff")) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR).with_target("stuff")) .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -167,8 +167,8 @@ fn add_directive_enables_event() { filter = filter.add_directive("hello=trace".parse().expect("directive should parse")); let (subscriber, finished) = subscriber::mock() - .event(event::expect().at_level(Level::INFO).with_target("hello")) - .event(event::expect().at_level(Level::TRACE).with_target("hello")) + .event(expect::event().at_level(Level::INFO).with_target("hello")) + .event(expect::event().at_level(Level::TRACE).with_target("hello")) .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -187,18 +187,18 @@ fn span_name_filter_is_dynamic() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::expect().at_level(Level::INFO)) - .enter(span::expect().named("cool_span")) - .event(event::expect().at_level(Level::DEBUG)) - .enter(span::expect().named("uncool_span")) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::DEBUG)) - .exit(span::expect().named("uncool_span")) - .exit(span::expect().named("cool_span")) - .enter(span::expect().named("uncool_span")) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) - .exit(span::expect().named("uncool_span")) + .event(expect::event().at_level(Level::INFO)) + .enter(expect::span().named("cool_span")) + .event(expect::event().at_level(Level::DEBUG)) + .enter(expect::span().named("uncool_span")) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::DEBUG)) + .exit(expect::span().named("uncool_span")) + .exit(expect::span().named("cool_span")) + .enter(expect::span().named("uncool_span")) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) + .exit(expect::span().named("uncool_span")) .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -245,9 +245,9 @@ mod per_layer_filter { fn level_filter_event() { let filter: EnvFilter = "info".parse().expect("filter should parse"); let (layer, handle) = layer::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); @@ -271,16 +271,16 @@ mod per_layer_filter { .expect("filter should parse"); let (layer, handle) = layer::mock() .new_span( - span::expect() + expect::span() .named("foo") .at_level(Level::TRACE) - .with_field(field::expect("bar")), + .with_field(expect::field("bar")), ) .new_span( - span::expect() + expect::span() .named("foo") .at_level(Level::TRACE) - .with_field(field::expect("baz")), + .with_field(expect::field("baz")), ) .only() .run_with_handle(); @@ -299,11 +299,11 @@ mod per_layer_filter { fn level_filter_event_with_target() { let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse"); let (layer, handle) = layer::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) - .event(event::expect().at_level(Level::WARN).with_target("stuff")) - .event(event::expect().at_level(Level::ERROR)) - .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG).with_target("stuff")) + .event(expect::event().at_level(Level::WARN).with_target("stuff")) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR).with_target("stuff")) .only() .run_with_handle(); @@ -333,7 +333,7 @@ mod per_layer_filter { let (layer, handle) = layer::mock() .enter(cool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) @@ -366,11 +366,11 @@ mod per_layer_filter { let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse"); let (layer, finished) = layer::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) - .event(event::expect().at_level(Level::WARN).with_target("stuff")) - .event(event::expect().at_level(Level::ERROR)) - .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG).with_target("stuff")) + .event(expect::event().at_level(Level::WARN).with_target("stuff")) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR).with_target("stuff")) .only() .run_with_handle(); @@ -401,8 +401,8 @@ mod per_layer_filter { filter = filter.add_directive("hello=trace".parse().expect("directive should parse")); let (layer, finished) = layer::mock() - .event(event::expect().at_level(Level::INFO).with_target("hello")) - .event(event::expect().at_level(Level::TRACE).with_target("hello")) + .event(expect::event().at_level(Level::INFO).with_target("hello")) + .event(expect::event().at_level(Level::TRACE).with_target("hello")) .only() .run_with_handle(); @@ -424,21 +424,21 @@ mod per_layer_filter { let cool_span = span::named("cool_span"); let uncool_span = span::named("uncool_span"); let (layer, finished) = layer::mock() - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .enter(cool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) .enter(uncool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![uncool_span.clone()]), ) @@ -446,12 +446,12 @@ mod per_layer_filter { .exit(cool_span) .enter(uncool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::expect() + expect::event() .at_level(Level::ERROR) .in_scope(vec![uncool_span.clone()]), ) @@ -497,7 +497,7 @@ mod per_layer_filter { let (layer, handle) = layer::named("layer1") .enter(span.clone()) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![span.clone()]), ) @@ -513,7 +513,7 @@ mod per_layer_filter { let (layer, handle) = layer::named("layer2") .enter(span.clone()) .event( - event::expect() + expect::event() .at_level(Level::INFO) .in_scope(vec![span.clone()]), ) diff --git a/tracing-subscriber/tests/env_filter/per_layer.rs b/tracing-subscriber/tests/env_filter/per_layer.rs index 587d34fb77..229b9ff776 100644 --- a/tracing-subscriber/tests/env_filter/per_layer.rs +++ b/tracing-subscriber/tests/env_filter/per_layer.rs @@ -2,15 +2,15 @@ //! `Layer` filter). #![cfg(feature = "registry")] use super::*; -use tracing_mock::{event, field, layer, span}; +use tracing_mock::{layer, span}; #[test] fn level_filter_event() { let filter: EnvFilter = "info".parse().expect("filter should parse"); let (layer, handle) = layer::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); @@ -34,16 +34,16 @@ fn same_name_spans() { .expect("filter should parse"); let (layer, handle) = layer::mock() .new_span( - span::expect() + expect::span() .named("foo") .at_level(Level::TRACE) - .with_field(field::expect("bar")), + .with_field(expect::field("bar")), ) .new_span( - span::expect() + expect::span() .named("foo") .at_level(Level::TRACE) - .with_field(field::expect("baz")), + .with_field(expect::field("baz")), ) .only() .run_with_handle(); @@ -62,11 +62,11 @@ fn same_name_spans() { fn level_filter_event_with_target() { let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse"); let (layer, handle) = layer::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) - .event(event::expect().at_level(Level::WARN).with_target("stuff")) - .event(event::expect().at_level(Level::ERROR)) - .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG).with_target("stuff")) + .event(expect::event().at_level(Level::WARN).with_target("stuff")) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR).with_target("stuff")) .only() .run_with_handle(); @@ -96,7 +96,7 @@ fn level_filter_event_with_target_and_span() { let (layer, handle) = layer::mock() .enter(cool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) @@ -129,11 +129,11 @@ fn not_order_dependent() { let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse"); let (layer, finished) = layer::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::DEBUG).with_target("stuff")) - .event(event::expect().at_level(Level::WARN).with_target("stuff")) - .event(event::expect().at_level(Level::ERROR)) - .event(event::expect().at_level(Level::ERROR).with_target("stuff")) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG).with_target("stuff")) + .event(expect::event().at_level(Level::WARN).with_target("stuff")) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::ERROR).with_target("stuff")) .only() .run_with_handle(); @@ -164,8 +164,8 @@ fn add_directive_enables_event() { filter = filter.add_directive("hello=trace".parse().expect("directive should parse")); let (layer, finished) = layer::mock() - .event(event::expect().at_level(Level::INFO).with_target("hello")) - .event(event::expect().at_level(Level::TRACE).with_target("hello")) + .event(expect::event().at_level(Level::INFO).with_target("hello")) + .event(expect::event().at_level(Level::TRACE).with_target("hello")) .only() .run_with_handle(); @@ -187,21 +187,21 @@ fn span_name_filter_is_dynamic() { let cool_span = span::named("cool_span"); let uncool_span = span::named("uncool_span"); let (layer, finished) = layer::mock() - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .enter(cool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![cool_span.clone()]), ) .enter(uncool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![uncool_span.clone()]), ) @@ -209,12 +209,12 @@ fn span_name_filter_is_dynamic() { .exit(cool_span) .enter(uncool_span.clone()) .event( - event::expect() + expect::event() .at_level(Level::WARN) .in_scope(vec![uncool_span.clone()]), ) .event( - event::expect() + expect::event() .at_level(Level::ERROR) .in_scope(vec![uncool_span.clone()]), ) @@ -260,7 +260,7 @@ fn multiple_dynamic_filters() { let (layer, handle) = layer::named("layer1") .enter(span.clone()) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) .in_scope(vec![span.clone()]), ) @@ -276,7 +276,7 @@ fn multiple_dynamic_filters() { let (layer, handle) = layer::named("layer2") .enter(span.clone()) .event( - event::expect() + expect::event() .at_level(Level::INFO) .in_scope(vec![span.clone()]), ) diff --git a/tracing-subscriber/tests/field_filter.rs b/tracing-subscriber/tests/field_filter.rs index 5d41ec028b..b14aebc421 100644 --- a/tracing-subscriber/tests/field_filter.rs +++ b/tracing-subscriber/tests/field_filter.rs @@ -10,14 +10,14 @@ fn field_filter_events() { let filter: EnvFilter = "[{thing}]=debug".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .event( - event::expect() + expect::event() .at_level(Level::INFO) - .with_fields(field::expect("thing")), + .with_fields(expect::field("thing")), ) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) - .with_fields(field::expect("thing")), + .with_fields(expect::field("thing")), ) .only() .run_with_handle(); @@ -41,22 +41,22 @@ fn field_filter_spans() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .enter(span::expect().named("span1")) + .enter(expect::span().named("span1")) .event( - event::expect() + expect::event() .at_level(Level::INFO) - .with_fields(field::expect("something")), + .with_fields(expect::field("something")), ) - .exit(span::expect().named("span1")) - .enter(span::expect().named("span2")) - .exit(span::expect().named("span2")) - .enter(span::expect().named("span3")) + .exit(expect::span().named("span1")) + .enter(expect::span().named("span2")) + .exit(expect::span().named("span2")) + .enter(expect::span().named("span3")) .event( - event::expect() + expect::event() .at_level(Level::DEBUG) - .with_fields(field::expect("something")), + .with_fields(expect::field("something")), ) - .exit(span::expect().named("span3")) + .exit(expect::span().named("span3")) .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -84,15 +84,15 @@ fn record_after_created() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .enter(span::expect().named("span")) - .exit(span::expect().named("span")) + .enter(expect::span().named("span")) + .exit(expect::span().named("span")) .record( - span::expect().named("span"), - field::expect("enabled").with_value(&true), + expect::span().named("span"), + expect::field("enabled").with_value(&true), ) - .enter(span::expect().named("span")) - .event(event::expect().at_level(Level::DEBUG)) - .exit(span::expect().named("span")) + .enter(expect::span().named("span")) + .event(expect::event().at_level(Level::DEBUG)) + .exit(expect::span().named("span")) .only() .run_with_handle(); let subscriber = subscriber.with(filter); diff --git a/tracing-subscriber/tests/filter_log.rs b/tracing-subscriber/tests/filter_log.rs index 9810684e56..9cda4340e4 100644 --- a/tracing-subscriber/tests/filter_log.rs +++ b/tracing-subscriber/tests/filter_log.rs @@ -36,9 +36,9 @@ fn log_is_enabled() { .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); diff --git a/tracing-subscriber/tests/hinted_layer_filters_dont_break_other_layers.rs b/tracing-subscriber/tests/hinted_layer_filters_dont_break_other_layers.rs index bbb68bd87a..a3ad351580 100644 --- a/tracing-subscriber/tests/hinted_layer_filters_dont_break_other_layers.rs +++ b/tracing-subscriber/tests/hinted_layer_filters_dont_break_other_layers.rs @@ -1,7 +1,7 @@ #![cfg(feature = "registry")] use tracing::{Level, Metadata, Subscriber}; use tracing_mock::{ - event, layer, + expect, layer, layer::MockLayer, subscriber::{self}, }; @@ -115,20 +115,20 @@ fn filter() -> DynFilterFn { fn unfiltered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::expect().at_level(Level::TRACE)) - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle() } fn filtered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle() } diff --git a/tracing-subscriber/tests/layer_filter_interests_are_cached.rs b/tracing-subscriber/tests/layer_filter_interests_are_cached.rs index c5f86c3cc9..867fdd0717 100644 --- a/tracing-subscriber/tests/layer_filter_interests_are_cached.rs +++ b/tracing-subscriber/tests/layer_filter_interests_are_cached.rs @@ -4,7 +4,7 @@ use std::{ sync::{Arc, Mutex}, }; use tracing::{Level, Subscriber}; -use tracing_mock::{event, layer}; +use tracing_mock::{expect, layer}; use tracing_subscriber::{filter, prelude::*}; #[test] @@ -21,8 +21,8 @@ fn layer_filter_interests_are_cached() { }); let (expect, handle) = layer::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); diff --git a/tracing-subscriber/tests/layer_filters/filter_scopes.rs b/tracing-subscriber/tests/layer_filters/filter_scopes.rs index b3957e9a30..02d000748f 100644 --- a/tracing-subscriber/tests/layer_filters/filter_scopes.rs +++ b/tracing-subscriber/tests/layer_filters/filter_scopes.rs @@ -1,48 +1,48 @@ use super::*; -use tracing_mock::layer::MockLayer; +use tracing_mock::{event, expect, layer::MockLayer}; #[test] fn filters_span_scopes() { let (debug_layer, debug_handle) = layer::named("debug") - .enter(span::expect().at_level(Level::DEBUG)) - .enter(span::expect().at_level(Level::INFO)) - .enter(span::expect().at_level(Level::WARN)) - .enter(span::expect().at_level(Level::ERROR)) + .enter(expect::span().at_level(Level::DEBUG)) + .enter(expect::span().at_level(Level::INFO)) + .enter(expect::span().at_level(Level::WARN)) + .enter(expect::span().at_level(Level::ERROR)) .event(event::msg("hello world").in_scope(vec![ - span::expect().at_level(Level::ERROR), - span::expect().at_level(Level::WARN), - span::expect().at_level(Level::INFO), - span::expect().at_level(Level::DEBUG), + expect::span().at_level(Level::ERROR), + expect::span().at_level(Level::WARN), + expect::span().at_level(Level::INFO), + expect::span().at_level(Level::DEBUG), ])) - .exit(span::expect().at_level(Level::ERROR)) - .exit(span::expect().at_level(Level::WARN)) - .exit(span::expect().at_level(Level::INFO)) - .exit(span::expect().at_level(Level::DEBUG)) + .exit(expect::span().at_level(Level::ERROR)) + .exit(expect::span().at_level(Level::WARN)) + .exit(expect::span().at_level(Level::INFO)) + .exit(expect::span().at_level(Level::DEBUG)) .only() .run_with_handle(); let (info_layer, info_handle) = layer::named("info") - .enter(span::expect().at_level(Level::INFO)) - .enter(span::expect().at_level(Level::WARN)) - .enter(span::expect().at_level(Level::ERROR)) + .enter(expect::span().at_level(Level::INFO)) + .enter(expect::span().at_level(Level::WARN)) + .enter(expect::span().at_level(Level::ERROR)) .event(event::msg("hello world").in_scope(vec![ - span::expect().at_level(Level::ERROR), - span::expect().at_level(Level::WARN), - span::expect().at_level(Level::INFO), + expect::span().at_level(Level::ERROR), + expect::span().at_level(Level::WARN), + expect::span().at_level(Level::INFO), ])) - .exit(span::expect().at_level(Level::ERROR)) - .exit(span::expect().at_level(Level::WARN)) - .exit(span::expect().at_level(Level::INFO)) + .exit(expect::span().at_level(Level::ERROR)) + .exit(expect::span().at_level(Level::WARN)) + .exit(expect::span().at_level(Level::INFO)) .only() .run_with_handle(); let (warn_layer, warn_handle) = layer::named("warn") - .enter(span::expect().at_level(Level::WARN)) - .enter(span::expect().at_level(Level::ERROR)) + .enter(expect::span().at_level(Level::WARN)) + .enter(expect::span().at_level(Level::ERROR)) .event(event::msg("hello world").in_scope(vec![ - span::expect().at_level(Level::ERROR), - span::expect().at_level(Level::WARN), + expect::span().at_level(Level::ERROR), + expect::span().at_level(Level::WARN), ])) - .exit(span::expect().at_level(Level::ERROR)) - .exit(span::expect().at_level(Level::WARN)) + .exit(expect::span().at_level(Level::ERROR)) + .exit(expect::span().at_level(Level::WARN)) .only() .run_with_handle(); @@ -70,22 +70,22 @@ fn filters_span_scopes() { fn filters_interleaved_span_scopes() { fn target_layer(target: &'static str) -> (MockLayer, subscriber::MockHandle) { layer::named(format!("target_{}", target)) - .enter(span::expect().with_target(target)) - .enter(span::expect().with_target(target)) + .enter(expect::span().with_target(target)) + .enter(expect::span().with_target(target)) .event(event::msg("hello world").in_scope(vec![ - span::expect().with_target(target), - span::expect().with_target(target), + expect::span().with_target(target), + expect::span().with_target(target), ])) .event( event::msg("hello to my target") .in_scope(vec![ - span::expect().with_target(target), - span::expect().with_target(target), + expect::span().with_target(target), + expect::span().with_target(target), ]) .with_target(target), ) - .exit(span::expect().with_target(target)) - .exit(span::expect().with_target(target)) + .exit(expect::span().with_target(target)) + .exit(expect::span().with_target(target)) .only() .run_with_handle() } @@ -93,14 +93,14 @@ fn filters_interleaved_span_scopes() { let (a_layer, a_handle) = target_layer("a"); let (b_layer, b_handle) = target_layer("b"); let (all_layer, all_handle) = layer::named("all") - .enter(span::expect().with_target("b")) - .enter(span::expect().with_target("a")) + .enter(expect::span().with_target("b")) + .enter(expect::span().with_target("a")) .event(event::msg("hello world").in_scope(vec![ - span::expect().with_target("a"), - span::expect().with_target("b"), + expect::span().with_target("a"), + expect::span().with_target("b"), ])) - .exit(span::expect().with_target("a")) - .exit(span::expect().with_target("b")) + .exit(expect::span().with_target("a")) + .exit(expect::span().with_target("b")) .only() .run_with_handle(); diff --git a/tracing-subscriber/tests/layer_filters/main.rs b/tracing-subscriber/tests/layer_filters/main.rs index 5b8812f713..170074e8b3 100644 --- a/tracing-subscriber/tests/layer_filters/main.rs +++ b/tracing-subscriber/tests/layer_filters/main.rs @@ -8,26 +8,26 @@ mod trees; mod vec; use tracing::{level_filters::LevelFilter, Level}; -use tracing_mock::{event, layer, span, subscriber}; +use tracing_mock::{event, expect, layer, subscriber}; use tracing_subscriber::{filter, prelude::*, Layer}; #[test] fn basic_subscriber_filters() { let (trace_layer, trace_handle) = layer::named("trace") - .event(event::expect().at_level(Level::TRACE)) - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); let (debug_layer, debug_handle) = layer::named("debug") - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); let (info_layer, info_handle) = layer::named("info") - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); @@ -49,20 +49,20 @@ fn basic_subscriber_filters() { #[test] fn basic_subscriber_filters_spans() { let (trace_layer, trace_handle) = layer::named("trace") - .new_span(span::expect().at_level(Level::TRACE)) - .new_span(span::expect().at_level(Level::DEBUG)) - .new_span(span::expect().at_level(Level::INFO)) + .new_span(expect::span().at_level(Level::TRACE)) + .new_span(expect::span().at_level(Level::DEBUG)) + .new_span(expect::span().at_level(Level::INFO)) .only() .run_with_handle(); let (debug_layer, debug_handle) = layer::named("debug") - .new_span(span::expect().at_level(Level::DEBUG)) - .new_span(span::expect().at_level(Level::INFO)) + .new_span(expect::span().at_level(Level::DEBUG)) + .new_span(expect::span().at_level(Level::INFO)) .only() .run_with_handle(); let (info_layer, info_handle) = layer::named("info") - .new_span(span::expect().at_level(Level::INFO)) + .new_span(expect::span().at_level(Level::INFO)) .only() .run_with_handle(); @@ -84,9 +84,9 @@ fn basic_subscriber_filters_spans() { #[test] fn global_filters_subscribers_still_work() { let (expect, handle) = layer::mock() - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); @@ -107,8 +107,8 @@ fn global_filters_subscribers_still_work() { #[test] fn global_filter_interests_are_cached() { let (expect, handle) = layer::mock() - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); @@ -135,9 +135,9 @@ fn global_filter_interests_are_cached() { #[test] fn global_filters_affect_subscriber_filters() { let (expect, handle) = layer::named("debug") - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); diff --git a/tracing-subscriber/tests/layer_filters/per_event.rs b/tracing-subscriber/tests/layer_filters/per_event.rs index 9eb9855426..897c9f2df5 100644 --- a/tracing-subscriber/tests/layer_filters/per_event.rs +++ b/tracing-subscriber/tests/layer_filters/per_event.rs @@ -1,5 +1,5 @@ use tracing::Level; -use tracing_mock::{event, layer}; +use tracing_mock::{expect, layer}; use tracing_subscriber::{field::Visit, layer::Filter, prelude::*}; struct FilterEvent; @@ -42,8 +42,8 @@ impl Filter for FilterEvent { #[test] fn per_layer_event_field_filtering() { let (expect, handle) = layer::mock() - .event(event::expect().at_level(Level::TRACE)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); diff --git a/tracing-subscriber/tests/layer_filters/targets.rs b/tracing-subscriber/tests/layer_filters/targets.rs index 56f6448822..19bcff1489 100644 --- a/tracing-subscriber/tests/layer_filters/targets.rs +++ b/tracing-subscriber/tests/layer_filters/targets.rs @@ -1,4 +1,5 @@ use super::*; +use tracing_mock::event; use tracing_subscriber::{ filter::{filter_fn, Targets}, prelude::*, diff --git a/tracing-subscriber/tests/layer_filters/trees.rs b/tracing-subscriber/tests/layer_filters/trees.rs index 1418fc40fa..a0dbbbe907 100644 --- a/tracing-subscriber/tests/layer_filters/trees.rs +++ b/tracing-subscriber/tests/layer_filters/trees.rs @@ -1,11 +1,11 @@ use super::*; -use tracing_mock::layer::MockLayer; +use tracing_mock::{event, expect, layer::MockLayer}; #[test] fn basic_trees() { let (with_target, with_target_handle) = layer::named("info_with_target") .event( - event::expect() + expect::event() .at_level(Level::INFO) .with_target("my_target"), ) @@ -14,12 +14,12 @@ fn basic_trees() { let (info, info_handle) = layer::named("info") .event( - event::expect() + expect::event() .at_level(Level::INFO) .with_target(module_path!()), ) .event( - event::expect() + expect::event() .at_level(Level::INFO) .with_target("my_target"), ) @@ -28,18 +28,18 @@ fn basic_trees() { let (all, all_handle) = layer::named("all") .event( - event::expect() + expect::event() .at_level(Level::INFO) .with_target(module_path!()), ) - .event(event::expect().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::TRACE)) .event( - event::expect() + expect::event() .at_level(Level::INFO) .with_target("my_target"), ) .event( - event::expect() + expect::event() .at_level(Level::TRACE) .with_target("my_target"), ) @@ -69,11 +69,11 @@ fn basic_trees() { fn filter_span_scopes() { fn target_layer(target: &'static str) -> (MockLayer, subscriber::MockHandle) { layer::named(format!("target_{}", target)) - .enter(span::expect().with_target(target).at_level(Level::INFO)) + .enter(expect::span().with_target(target).at_level(Level::INFO)) .event(event::msg("hello world").in_scope(vec![ - span::expect().with_target(target).at_level(Level::INFO), + expect::span().with_target(target).at_level(Level::INFO), ])) - .exit(span::expect().with_target(target).at_level(Level::INFO)) + .exit(expect::span().with_target(target).at_level(Level::INFO)) .only() .run_with_handle() } @@ -81,28 +81,28 @@ fn filter_span_scopes() { let (a_layer, a_handle) = target_layer("a"); let (b_layer, b_handle) = target_layer("b"); let (info_layer, info_handle) = layer::named("info") - .enter(span::expect().with_target("b").at_level(Level::INFO)) - .enter(span::expect().with_target("a").at_level(Level::INFO)) + .enter(expect::span().with_target("b").at_level(Level::INFO)) + .enter(expect::span().with_target("a").at_level(Level::INFO)) .event(event::msg("hello world").in_scope(vec![ - span::expect().with_target("a").at_level(Level::INFO), - span::expect().with_target("b").at_level(Level::INFO), + expect::span().with_target("a").at_level(Level::INFO), + expect::span().with_target("b").at_level(Level::INFO), ])) - .exit(span::expect().with_target("a").at_level(Level::INFO)) - .exit(span::expect().with_target("b").at_level(Level::INFO)) + .exit(expect::span().with_target("a").at_level(Level::INFO)) + .exit(expect::span().with_target("b").at_level(Level::INFO)) .only() .run_with_handle(); let full_scope = vec![ - span::expect().with_target("b").at_level(Level::TRACE), - span::expect().with_target("a").at_level(Level::INFO), - span::expect().with_target("b").at_level(Level::INFO), - span::expect().with_target("a").at_level(Level::TRACE), + expect::span().with_target("b").at_level(Level::TRACE), + expect::span().with_target("a").at_level(Level::INFO), + expect::span().with_target("b").at_level(Level::INFO), + expect::span().with_target("a").at_level(Level::TRACE), ]; let (all_layer, all_handle) = layer::named("all") - .enter(span::expect().with_target("a").at_level(Level::TRACE)) - .enter(span::expect().with_target("b").at_level(Level::INFO)) - .enter(span::expect().with_target("a").at_level(Level::INFO)) - .enter(span::expect().with_target("b").at_level(Level::TRACE)) + .enter(expect::span().with_target("a").at_level(Level::TRACE)) + .enter(expect::span().with_target("b").at_level(Level::INFO)) + .enter(expect::span().with_target("a").at_level(Level::INFO)) + .enter(expect::span().with_target("b").at_level(Level::TRACE)) .event(event::msg("hello world").in_scope(full_scope.clone())) .event( event::msg("hello to my target") @@ -114,10 +114,10 @@ fn filter_span_scopes() { .with_target("b") .in_scope(full_scope), ) - .exit(span::expect().with_target("b").at_level(Level::TRACE)) - .exit(span::expect().with_target("a").at_level(Level::INFO)) - .exit(span::expect().with_target("b").at_level(Level::INFO)) - .exit(span::expect().with_target("a").at_level(Level::TRACE)) + .exit(expect::span().with_target("b").at_level(Level::TRACE)) + .exit(expect::span().with_target("a").at_level(Level::INFO)) + .exit(expect::span().with_target("b").at_level(Level::INFO)) + .exit(expect::span().with_target("a").at_level(Level::TRACE)) .only() .run_with_handle(); diff --git a/tracing-subscriber/tests/layer_filters/vec.rs b/tracing-subscriber/tests/layer_filters/vec.rs index 884ec60a95..3555e19545 100644 --- a/tracing-subscriber/tests/layer_filters/vec.rs +++ b/tracing-subscriber/tests/layer_filters/vec.rs @@ -1,26 +1,26 @@ use super::*; use tracing::Subscriber; -use tracing_mock::layer::MockLayer; +use tracing_mock::{expect, layer::MockLayer}; #[test] fn with_filters_unboxed() { let (trace_layer, trace_handle) = layer::named("trace") - .event(event::expect().at_level(Level::TRACE)) - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); let trace_layer = trace_layer.with_filter(LevelFilter::TRACE); let (debug_layer, debug_handle) = layer::named("debug") - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); let debug_layer = debug_layer.with_filter(LevelFilter::DEBUG); let (info_layer, info_handle) = layer::named("info") - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); let info_layer = info_layer.with_filter(LevelFilter::INFO); @@ -41,22 +41,22 @@ fn with_filters_unboxed() { #[test] fn with_filters_boxed() { let (unfiltered_layer, unfiltered_handle) = layer::named("unfiltered") - .event(event::expect().at_level(Level::TRACE)) - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); let unfiltered_layer = unfiltered_layer.boxed(); let (debug_layer, debug_handle) = layer::named("debug") - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); let debug_layer = debug_layer.with_filter(LevelFilter::DEBUG).boxed(); let (target_layer, target_handle) = layer::named("target") - .event(event::expect().at_level(Level::INFO)) + .event(expect::event().at_level(Level::INFO)) .only() .run_with_handle(); let target_layer = target_layer diff --git a/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs b/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs index 6f9ee0c310..553c5371a2 100644 --- a/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs +++ b/tracing-subscriber/tests/multiple_layer_filter_interests_cached.rs @@ -4,7 +4,7 @@ use std::{ sync::{Arc, Mutex}, }; use tracing::{Level, Subscriber}; -use tracing_mock::{event, layer}; +use tracing_mock::{expect, layer}; use tracing_subscriber::{filter, prelude::*}; #[test] @@ -23,12 +23,12 @@ fn multiple_layer_filter_interests_are_cached() { let seen_info = seen_info2; let (info_layer, info_handle) = layer::named("info") - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); let info_layer = info_layer.with_filter(filter); @@ -47,10 +47,10 @@ fn multiple_layer_filter_interests_are_cached() { let seen_warn = seen_warn2; let (warn_layer, warn_handle) = layer::named("warn") - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); let warn_layer = warn_layer.with_filter(filter); diff --git a/tracing-subscriber/tests/same_len_filters.rs b/tracing-subscriber/tests/same_len_filters.rs index 839d82e61b..ac0b908d28 100644 --- a/tracing-subscriber/tests/same_len_filters.rs +++ b/tracing-subscriber/tests/same_len_filters.rs @@ -10,8 +10,8 @@ use tracing_subscriber::{filter::EnvFilter, prelude::*}; fn same_length_targets() { let filter: EnvFilter = "foo=trace,bar=trace".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() - .event(event::expect().at_level(Level::TRACE)) - .event(event::expect().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::TRACE)) .only() .run_with_handle(); let subscriber = subscriber.with(filter); @@ -31,14 +31,14 @@ fn same_num_fields_event() { .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .event( - event::expect() + expect::event() .at_level(Level::TRACE) - .with_fields(field::expect("foo")), + .with_fields(expect::field("foo")), ) .event( - event::expect() + expect::event() .at_level(Level::TRACE) - .with_fields(field::expect("bar")), + .with_fields(expect::field("bar")), ) .only() .run_with_handle(); @@ -58,16 +58,16 @@ fn same_num_fields_and_name_len() { .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .new_span( - span::expect() + expect::span() .named("foo") .at_level(Level::TRACE) - .with_field(field::expect("bar")), + .with_field(expect::field("bar")), ) .new_span( - span::expect() + expect::span() .named("baz") .at_level(Level::TRACE) - .with_field(field::expect("boz")), + .with_field(expect::field("boz")), ) .only() .run_with_handle(); diff --git a/tracing-subscriber/tests/unhinted_layer_filters_dont_break_other_layers.rs b/tracing-subscriber/tests/unhinted_layer_filters_dont_break_other_layers.rs index 9078b66b35..a0f3b51423 100644 --- a/tracing-subscriber/tests/unhinted_layer_filters_dont_break_other_layers.rs +++ b/tracing-subscriber/tests/unhinted_layer_filters_dont_break_other_layers.rs @@ -1,7 +1,7 @@ #![cfg(feature = "registry")] use tracing::Level; use tracing_mock::{ - event, + expect, layer::{self, MockLayer}, subscriber, }; @@ -107,20 +107,20 @@ fn filter() -> DynFilterFn { fn unfiltered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::expect().at_level(Level::TRACE)) - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::TRACE)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle() } fn filtered(name: &str) -> (MockLayer, subscriber::MockHandle) { layer::named(name) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle() } diff --git a/tracing-subscriber/tests/utils.rs b/tracing-subscriber/tests/utils.rs index 6cf96b066e..9a8eb30ace 100644 --- a/tracing-subscriber/tests/utils.rs +++ b/tracing-subscriber/tests/utils.rs @@ -7,7 +7,7 @@ use tracing_subscriber::prelude::*; fn init_ext_works() { let (subscriber, finished) = subscriber::mock() .event( - event::expect() + expect::event() .at_level(tracing::Level::INFO) .with_target("init_works"), ) diff --git a/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs b/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs index 9a9f117cdd..8e1ecabce1 100644 --- a/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs +++ b/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs @@ -23,22 +23,22 @@ fn vec_subscriber_filter_interests_are_cached() { // This layer will return Interest::always for INFO and lower. let (info_layer, info_handle) = layer::named("info") - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); let (info_layer, seen_info) = mk_filtered(Level::INFO, info_layer); // This layer will return Interest::always for WARN and lower. let (warn_layer, warn_handle) = layer::named("warn") - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); let (warn_layer, seen_warn) = mk_filtered(Level::WARN, warn_layer); diff --git a/tracing/tests/event.rs b/tracing/tests/event.rs index 6e943c60db..5a0dc9ce4a 100644 --- a/tracing/tests/event.rs +++ b/tracing/tests/event.rs @@ -22,11 +22,11 @@ macro_rules! event_without_message { fn $name() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("answer") + expect::event().with_fields( + expect::field("answer") .with_value(&42) .and( - field::expect("to_question") + expect::field("to_question") .with_value(&"life, the universe, and everything"), ) .only(), @@ -58,7 +58,7 @@ event_without_message! {nonzeroi32_event_without_message: std::num::NonZeroI32:: fn event_with_message() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields(field::expect("message").with_value( + expect::event().with_fields(expect::field("message").with_value( &tracing::field::debug(format_args!( "hello from my tracing::event! yak shaved = {:?}", true @@ -80,11 +80,11 @@ fn event_with_message() { fn message_without_delims() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("answer") + expect::event().with_fields( + expect::field("answer") .with_value(&42) .and( - field::expect("question").with_value(&"life, the universe, and everything"), + expect::field("question").with_value(&"life, the universe, and everything"), ) .and(field::msg(format_args!( "hello from my event! tricky? {:?}!", @@ -109,11 +109,11 @@ fn message_without_delims() { fn string_message_without_delims() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("answer") + expect::event().with_fields( + expect::field("answer") .with_value(&42) .and( - field::expect("question").with_value(&"life, the universe, and everything"), + expect::field("question").with_value(&"life, the universe, and everything"), ) .and(field::msg(format_args!("hello from my event"))) .only(), @@ -135,17 +135,17 @@ fn string_message_without_delims() { fn one_with_everything() { let (subscriber, handle) = subscriber::mock() .event( - event::expect() + expect::event() .with_fields( - field::expect("message") + expect::field("message") .with_value(&tracing::field::debug(format_args!( "{:#x} make me one with{what:.>20}", 4_277_009_102u64, what = "everything" ))) - .and(field::expect("foo").with_value(&666)) - .and(field::expect("bar").with_value(&false)) - .and(field::expect("like_a_butterfly").with_value(&42.0)) + .and(expect::field("foo").with_value(&666)) + .and(expect::field("bar").with_value(&false)) + .and(expect::field("like_a_butterfly").with_value(&42.0)) .only(), ) .at_level(Level::ERROR) @@ -171,8 +171,8 @@ fn one_with_everything() { fn moved_field() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("foo") + expect::event().with_fields( + expect::field("foo") .with_value(&display("hello from my event")) .only(), ), @@ -192,10 +192,10 @@ fn moved_field() { fn dotted_field_name() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("foo.bar") + expect::event().with_fields( + expect::field("foo.bar") .with_value(&true) - .and(field::expect("foo.baz").with_value(&false)) + .and(expect::field("foo.baz").with_value(&false)) .only(), ), ) @@ -213,8 +213,8 @@ fn dotted_field_name() { fn borrowed_field() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("foo") + expect::event().with_fields( + expect::field("foo") .with_value(&display("hello from my event")) .only(), ), @@ -250,14 +250,14 @@ fn move_field_out_of_struct() { }; let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("x") + expect::event().with_fields( + expect::field("x") .with_value(&debug(3.234)) - .and(field::expect("y").with_value(&debug(-1.223))) + .and(expect::field("y").with_value(&debug(-1.223))) .only(), ), ) - .event(event::expect().with_fields(field::expect("position").with_value(&debug(&pos)))) + .event(expect::event().with_fields(expect::field("position").with_value(&debug(&pos)))) .only() .run_with_handle(); @@ -277,8 +277,8 @@ fn move_field_out_of_struct() { fn display_shorthand() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("my_field") + expect::event().with_fields( + expect::field("my_field") .with_value(&display("hello world")) .only(), ), @@ -297,8 +297,8 @@ fn display_shorthand() { fn debug_shorthand() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("my_field") + expect::event().with_fields( + expect::field("my_field") .with_value(&debug("hello world")) .only(), ), @@ -317,10 +317,10 @@ fn debug_shorthand() { fn both_shorthands() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("display_field") + expect::event().with_fields( + expect::field("display_field") .with_value(&display("hello world")) - .and(field::expect("debug_field").with_value(&debug("hello world"))) + .and(expect::field("debug_field").with_value(&debug("hello world"))) .only(), ), ) @@ -337,8 +337,8 @@ fn both_shorthands() { #[test] fn explicit_child() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo")) - .event(event::expect().with_explicit_parent(Some("foo"))) + .new_span(expect::span().named("foo")) + .event(expect::event().with_explicit_parent(Some("foo"))) .only() .run_with_handle(); @@ -354,12 +354,12 @@ fn explicit_child() { #[test] fn explicit_child_at_levels() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo")) - .event(event::expect().with_explicit_parent(Some("foo"))) - .event(event::expect().with_explicit_parent(Some("foo"))) - .event(event::expect().with_explicit_parent(Some("foo"))) - .event(event::expect().with_explicit_parent(Some("foo"))) - .event(event::expect().with_explicit_parent(Some("foo"))) + .new_span(expect::span().named("foo")) + .event(expect::event().with_explicit_parent(Some("foo"))) + .event(expect::event().with_explicit_parent(Some("foo"))) + .event(expect::event().with_explicit_parent(Some("foo"))) + .event(expect::event().with_explicit_parent(Some("foo"))) + .event(expect::event().with_explicit_parent(Some("foo"))) .only() .run_with_handle(); @@ -380,11 +380,11 @@ fn explicit_child_at_levels() { fn option_values() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("some_str") + expect::event().with_fields( + expect::field("some_str") .with_value(&"yes") - .and(field::expect("some_bool").with_value(&true)) - .and(field::expect("some_u64").with_value(&42_u64)) + .and(expect::field("some_bool").with_value(&true)) + .and(expect::field("some_u64").with_value(&42_u64)) .only(), ), ) @@ -416,11 +416,11 @@ fn option_values() { fn option_ref_values() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("some_str") + expect::event().with_fields( + expect::field("some_str") .with_value(&"yes") - .and(field::expect("some_bool").with_value(&true)) - .and(field::expect("some_u64").with_value(&42_u64)) + .and(expect::field("some_bool").with_value(&true)) + .and(expect::field("some_u64").with_value(&42_u64)) .only(), ), ) @@ -452,11 +452,11 @@ fn option_ref_values() { fn option_ref_mut_values() { let (subscriber, handle) = subscriber::mock() .event( - event::expect().with_fields( - field::expect("some_str") + expect::event().with_fields( + expect::field("some_str") .with_value(&"yes") - .and(field::expect("some_bool").with_value(&true)) - .and(field::expect("some_u64").with_value(&42_u64)) + .and(expect::field("some_bool").with_value(&true)) + .and(expect::field("some_u64").with_value(&42_u64)) .only(), ), ) @@ -487,10 +487,10 @@ fn option_ref_mut_values() { #[test] fn string_field() { let (subscriber, handle) = subscriber::mock() - .event(event::expect().with_fields(field::expect("my_string").with_value(&"hello").only())) + .event(expect::event().with_fields(expect::field("my_string").with_value(&"hello").only())) .event( - event::expect().with_fields( - field::expect("my_string") + expect::event().with_fields( + expect::field("my_string") .with_value(&"hello world!") .only(), ), diff --git a/tracing/tests/filters_dont_leak.rs b/tracing/tests/filters_dont_leak.rs index df96a4ac72..c46b91f18f 100644 --- a/tracing/tests/filters_dont_leak.rs +++ b/tracing/tests/filters_dont_leak.rs @@ -20,7 +20,7 @@ fn spans_dont_leak() { do_span(); - let alice = span::expect().named("alice"); + let alice = expect::span().named("alice"); let (subscriber2, handle2) = subscriber::mock() .named("spans/subscriber2") .with_filter(|_| true) @@ -63,7 +63,7 @@ fn events_dont_leak() { let (subscriber2, handle2) = subscriber::mock() .named("events/subscriber2") .with_filter(|_| true) - .event(event::expect()) + .event(expect::event()) .only() .run_with_handle(); diff --git a/tracing/tests/instrument.rs b/tracing/tests/instrument.rs index 07b6bbfa42..5247249946 100644 --- a/tracing/tests/instrument.rs +++ b/tracing/tests/instrument.rs @@ -33,16 +33,16 @@ fn span_on_drop() { } let subscriber = subscriber::mock() - .enter(span::expect().named("foo")) - .event(event::expect().at_level(Level::INFO)) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) - .enter(span::expect().named("bar")) - .event(event::expect().at_level(Level::INFO)) - .exit(span::expect().named("bar")) - .drop_span(span::expect().named("bar")) + .enter(expect::span().named("foo")) + .event(expect::event().at_level(Level::INFO)) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) + .enter(expect::span().named("bar")) + .event(expect::event().at_level(Level::INFO)) + .exit(expect::span().named("bar")) + .drop_span(expect::span().named("bar")) .only() .run(); diff --git a/tracing/tests/max_level_hint.rs b/tracing/tests/max_level_hint.rs index 5c7c476bf3..2e04bc3f1d 100644 --- a/tracing/tests/max_level_hint.rs +++ b/tracing/tests/max_level_hint.rs @@ -20,9 +20,9 @@ fn max_level_hints() { ); true }) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); diff --git a/tracing/tests/multiple_max_level_hints.rs b/tracing/tests/multiple_max_level_hints.rs index 81cc8052e9..f78fda70fb 100644 --- a/tracing/tests/multiple_max_level_hints.rs +++ b/tracing/tests/multiple_max_level_hints.rs @@ -35,9 +35,9 @@ fn multiple_max_level_hints() { ); level <= &Level::INFO }) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); let (subscriber2, handle2) = subscriber::mock() @@ -51,10 +51,10 @@ fn multiple_max_level_hints() { ); level <= &Level::DEBUG }) - .event(event::expect().at_level(Level::INFO)) - .event(event::expect().at_level(Level::DEBUG)) - .event(event::expect().at_level(Level::WARN)) - .event(event::expect().at_level(Level::ERROR)) + .event(expect::event().at_level(Level::INFO)) + .event(expect::event().at_level(Level::DEBUG)) + .event(expect::event().at_level(Level::WARN)) + .event(expect::event().at_level(Level::ERROR)) .only() .run_with_handle(); diff --git a/tracing/tests/span.rs b/tracing/tests/span.rs index 40ba193da8..d75f3a89a8 100644 --- a/tracing/tests/span.rs +++ b/tracing/tests/span.rs @@ -67,11 +67,11 @@ fn handles_to_different_spans_with_the_same_metadata_are_not_equal() { #[test] fn spans_always_go_to_the_subscriber_that_tagged_them() { let subscriber1 = subscriber::mock() - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run(); let subscriber2 = subscriber::mock().run(); @@ -94,11 +94,11 @@ fn spans_always_go_to_the_subscriber_that_tagged_them() { #[test] fn spans_always_go_to_the_subscriber_that_tagged_them_even_across_threads() { let subscriber1 = subscriber::mock() - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run(); let foo = with_default(subscriber1, || { @@ -122,9 +122,9 @@ fn spans_always_go_to_the_subscriber_that_tagged_them_even_across_threads() { #[test] fn dropping_a_span_calls_drop_span() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -140,10 +140,10 @@ fn dropping_a_span_calls_drop_span() { #[test] fn span_closes_after_event() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .event(event::expect()) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .event(expect::event()) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -159,13 +159,13 @@ fn span_closes_after_event() { #[test] fn new_span_after_event() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .event(event::expect()) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) - .enter(span::expect().named("bar")) - .exit(span::expect().named("bar")) - .drop_span(span::expect().named("bar")) + .enter(expect::span().named("foo")) + .event(expect::event()) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) + .enter(expect::span().named("bar")) + .exit(expect::span().named("bar")) + .drop_span(expect::span().named("bar")) .only() .run_with_handle(); with_default(subscriber, || { @@ -182,10 +182,10 @@ fn new_span_after_event() { #[test] fn event_outside_of_span() { let (subscriber, handle) = subscriber::mock() - .event(event::expect()) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .event(expect::event()) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -200,7 +200,7 @@ fn event_outside_of_span() { #[test] fn cloning_a_span_calls_clone_span() { let (subscriber, handle) = subscriber::mock() - .clone_span(span::expect().named("foo")) + .clone_span(expect::span().named("foo")) .run_with_handle(); with_default(subscriber, || { let span = tracing::span!(Level::TRACE, "foo"); @@ -216,9 +216,9 @@ fn cloning_a_span_calls_clone_span() { #[test] fn drop_span_when_exiting_dispatchers_context() { let (subscriber, handle) = subscriber::mock() - .clone_span(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .clone_span(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .run_with_handle(); with_default(subscriber, || { let span = tracing::span!(Level::TRACE, "foo"); @@ -233,13 +233,13 @@ fn drop_span_when_exiting_dispatchers_context() { #[test] fn clone_and_drop_span_always_go_to_the_subscriber_that_tagged_the_span() { let (subscriber1, handle1) = subscriber::mock() - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .clone_span(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .clone_span(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .run_with_handle(); let subscriber2 = subscriber::mock().only().run(); @@ -264,9 +264,9 @@ fn clone_and_drop_span_always_go_to_the_subscriber_that_tagged_the_span() { #[test] fn span_closes_when_exited() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -284,10 +284,10 @@ fn span_closes_when_exited() { #[test] fn enter() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .event(event::expect()) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .event(expect::event()) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -303,10 +303,10 @@ fn enter() { #[test] fn entered() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .event(event::expect()) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .event(expect::event()) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -321,10 +321,10 @@ fn entered() { #[test] fn entered_api() { let (subscriber, handle) = subscriber::mock() - .enter(span::expect().named("foo")) - .event(event::expect()) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .event(expect::event()) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -342,15 +342,15 @@ fn entered_api() { fn moved_field() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("bar") + expect::span().named("foo").with_field( + expect::field("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); with_default(subscriber, || { @@ -371,9 +371,9 @@ fn moved_field() { fn dotted_field_name() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect() + expect::span() .named("foo") - .with_field(field::expect("fields.bar").with_value(&true).only()), + .with_field(expect::field("fields.bar").with_value(&true).only()), ) .only() .run_with_handle(); @@ -389,15 +389,15 @@ fn dotted_field_name() { fn borrowed_field() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("bar") + expect::span().named("foo").with_field( + expect::field("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); @@ -432,17 +432,17 @@ fn move_field_out_of_struct() { }; let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("x") + expect::span().named("foo").with_field( + expect::field("x") .with_value(&debug(3.234)) - .and(field::expect("y").with_value(&debug(-1.223))) + .and(expect::field("y").with_value(&debug(-1.223))) .only(), ), ) .new_span( - span::expect() + expect::span() .named("bar") - .with_field(field::expect("position").with_value(&debug(&pos)).only()), + .with_field(expect::field("position").with_value(&debug(&pos)).only()), ) .run_with_handle(); @@ -465,10 +465,10 @@ fn move_field_out_of_struct() { fn float_values() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("x") + expect::span().named("foo").with_field( + expect::field("x") .with_value(&3.234) - .and(field::expect("y").with_value(&-1.223)) + .and(expect::field("y").with_value(&-1.223)) .only(), ), ) @@ -490,18 +490,18 @@ fn float_values() { fn add_field_after_new_span() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect() + expect::span() .named("foo") - .with_field(field::expect("bar").with_value(&5) - .and(field::expect("baz").with_value).only()), + .with_field(expect::field("bar").with_value(&5) + .and(expect::field("baz").with_value).only()), ) .record( - span::expect().named("foo"), + expect::span().named("foo"), field::expect("baz").with_value(&true).only(), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); @@ -518,18 +518,18 @@ fn add_field_after_new_span() { #[test] fn add_fields_only_after_new_span() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo")) + .new_span(expect::span().named("foo")) .record( - span::expect().named("foo"), + expect::span().named("foo"), field::expect("bar").with_value(&5).only(), ) .record( - span::expect().named("foo"), + expect::span().named("foo"), field::expect("baz").with_value(&true).only(), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); @@ -549,20 +549,20 @@ fn add_fields_only_after_new_span() { fn record_new_value_for_field() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("bar") + expect::span().named("foo").with_field( + expect::field("bar") .with_value(&5) - .and(field::expect("baz").with_value(&false)) + .and(expect::field("baz").with_value(&false)) .only(), ), ) .record( - span::expect().named("foo"), - field::expect("baz").with_value(&true).only(), + expect::span().named("foo"), + expect::field("baz").with_value(&true).only(), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); @@ -580,24 +580,24 @@ fn record_new_value_for_field() { fn record_new_values_for_fields() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("bar") + expect::span().named("foo").with_field( + expect::field("bar") .with_value(&4) - .and(field::expect("baz").with_value(&false)) + .and(expect::field("baz").with_value(&false)) .only(), ), ) .record( - span::expect().named("foo"), - field::expect("bar").with_value(&5).only(), + expect::span().named("foo"), + expect::field("bar").with_value(&5).only(), ) .record( - span::expect().named("foo"), - field::expect("baz").with_value(&true).only(), + expect::span().named("foo"), + expect::field("baz").with_value(&true).only(), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); @@ -616,7 +616,7 @@ fn record_new_values_for_fields() { fn new_span_with_target_and_log_level() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect() + expect::span() .named("foo") .with_target("app_span") .at_level(Level::DEBUG), @@ -635,7 +635,7 @@ fn new_span_with_target_and_log_level() { #[test] fn explicit_root_span_is_root() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo").with_explicit_parent(None)) + .new_span(expect::span().named("foo").with_explicit_parent(None)) .only() .run_with_handle(); @@ -650,10 +650,10 @@ fn explicit_root_span_is_root() { #[test] fn explicit_root_span_is_root_regardless_of_ctx() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo")) - .enter(span::expect().named("foo")) - .new_span(span::expect().named("bar").with_explicit_parent(None)) - .exit(span::expect().named("foo")) + .new_span(expect::span().named("foo")) + .enter(expect::span().named("foo")) + .new_span(expect::span().named("bar").with_explicit_parent(None)) + .exit(expect::span().named("foo")) .only() .run_with_handle(); @@ -670,9 +670,9 @@ fn explicit_root_span_is_root_regardless_of_ctx() { #[test] fn explicit_child() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo")) + .new_span(expect::span().named("foo")) .new_span( - span::expect() + expect::span() .named("bar") .with_explicit_parent(Some("foo")), ) @@ -691,12 +691,12 @@ fn explicit_child() { #[test] fn explicit_child_at_levels() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo")) - .new_span(span::expect().named("a").with_explicit_parent(Some("foo"))) - .new_span(span::expect().named("b").with_explicit_parent(Some("foo"))) - .new_span(span::expect().named("c").with_explicit_parent(Some("foo"))) - .new_span(span::expect().named("d").with_explicit_parent(Some("foo"))) - .new_span(span::expect().named("e").with_explicit_parent(Some("foo"))) + .new_span(expect::span().named("foo")) + .new_span(expect::span().named("a").with_explicit_parent(Some("foo"))) + .new_span(expect::span().named("b").with_explicit_parent(Some("foo"))) + .new_span(expect::span().named("c").with_explicit_parent(Some("foo"))) + .new_span(expect::span().named("d").with_explicit_parent(Some("foo"))) + .new_span(expect::span().named("e").with_explicit_parent(Some("foo"))) .only() .run_with_handle(); @@ -716,15 +716,15 @@ fn explicit_child_at_levels() { #[test] fn explicit_child_regardless_of_ctx() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo")) - .new_span(span::expect().named("bar")) - .enter(span::expect().named("bar")) + .new_span(expect::span().named("foo")) + .new_span(expect::span().named("bar")) + .enter(expect::span().named("bar")) .new_span( - span::expect() + expect::span() .named("baz") .with_explicit_parent(Some("foo")), ) - .exit(span::expect().named("bar")) + .exit(expect::span().named("bar")) .only() .run_with_handle(); @@ -741,7 +741,7 @@ fn explicit_child_regardless_of_ctx() { #[test] fn contextual_root() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo").with_contextual_parent(None)) + .new_span(expect::span().named("foo").with_contextual_parent(None)) .only() .run_with_handle(); @@ -756,14 +756,14 @@ fn contextual_root() { #[test] fn contextual_child() { let (subscriber, handle) = subscriber::mock() - .new_span(span::expect().named("foo")) - .enter(span::expect().named("foo")) + .new_span(expect::span().named("foo")) + .enter(expect::span().named("foo")) .new_span( - span::expect() + expect::span() .named("bar") .with_contextual_parent(Some("foo")), ) - .exit(span::expect().named("foo")) + .exit(expect::span().named("foo")) .only() .run_with_handle(); @@ -781,8 +781,8 @@ fn contextual_child() { fn display_shorthand() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("my_span").with_field( - field::expect("my_field") + expect::span().named("my_span").with_field( + expect::field("my_field") .with_value(&display("hello world")) .only(), ), @@ -801,8 +801,8 @@ fn display_shorthand() { fn debug_shorthand() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("my_span").with_field( - field::expect("my_field") + expect::span().named("my_span").with_field( + expect::field("my_field") .with_value(&debug("hello world")) .only(), ), @@ -821,10 +821,10 @@ fn debug_shorthand() { fn both_shorthands() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("my_span").with_field( - field::expect("display_field") + expect::span().named("my_span").with_field( + expect::field("display_field") .with_value(&display("hello world")) - .and(field::expect("debug_field").with_value(&debug("hello world"))) + .and(expect::field("debug_field").with_value(&debug("hello world"))) .only(), ), ) diff --git a/tracing/tests/subscriber.rs b/tracing/tests/subscriber.rs index 0357d61ac7..f676efeee8 100644 --- a/tracing/tests/subscriber.rs +++ b/tracing/tests/subscriber.rs @@ -11,8 +11,7 @@ use tracing::{ subscriber::{with_default, Interest, Subscriber}, Event, Level, Metadata, }; - -use tracing_mock::*; +use tracing_mock::{expect, subscriber}; #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] @@ -61,15 +60,15 @@ fn event_macros_dont_infinite_loop() { fn boxed_subscriber() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("bar") + expect::span().named("foo").with_field( + expect::field("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .only() .run_with_handle(); let subscriber: Box = Box::new(subscriber); @@ -94,18 +93,18 @@ fn arced_subscriber() { let (subscriber, handle) = subscriber::mock() .new_span( - span::expect().named("foo").with_field( - field::expect("bar") + expect::span().named("foo").with_field( + expect::field("bar") .with_value(&display("hello from my span")) .only(), ), ) - .enter(span::expect().named("foo")) - .exit(span::expect().named("foo")) - .drop_span(span::expect().named("foo")) + .enter(expect::span().named("foo")) + .exit(expect::span().named("foo")) + .drop_span(expect::span().named("foo")) .event( - event::expect() - .with_fields(field::expect("message").with_value(&display("hello from my event"))), + expect::event() + .with_fields(expect::field("message").with_value(&display("hello from my event"))), ) .only() .run_with_handle(); From 9c6ffce1e83a10c5cc1e86c91785ea448ca7ac90 Mon Sep 17 00:00:00 2001 From: Hayden Stainsby Date: Tue, 15 Nov 2022 23:18:13 +0100 Subject: [PATCH 03/34] mock: add README to tracing-mock (#2362) There has been interest around publishing `tracing-mock` to crates.io for some time. In order to make this possible, documentation and some code clean up is needed. Specifically **I** want to have access to `tracing-mock` within parts of `tokio` to write tests that ensure that the correct calling location is picked up for all `spawn*` functions when the `tracing` feature is enabled. This change starts that process by adding a README for `tracing-mock`. The README follows the standard format for all `tracing` crates and includes 2 examples. The README is included in the `lib.rs` docs using `#[doc = include_str!(...)]`, so that the same documentation is included in the crate, and the examples are tested when running doctests. The README describes steps when using the `tracing` 1.0 from crates.io and `tracing-mock` from the `v0.1.x` branch. The tests target the current branch. Co-authored-by: David Barsky Co-authored-by: Eliza Weisman --- tracing-mock/README.md | 176 ++++++++++++++++++++++++++++++++++++++++ tracing-mock/src/lib.rs | 1 + 2 files changed, 177 insertions(+) create mode 100644 tracing-mock/README.md diff --git a/tracing-mock/README.md b/tracing-mock/README.md new file mode 100644 index 0000000000..b508db00cb --- /dev/null +++ b/tracing-mock/README.md @@ -0,0 +1,176 @@ +![Tracing — Structured, application-level diagnostics][splash] + +[splash]: https://raw.githubusercontent.com/tokio-rs/tracing/master/assets/splash.svg + +# tracing-mock + +Utilities for testing [`tracing`][tracing] and crates that uses it. + +[![Documentation (master)][docs-master-badge]][docs-master-url] +[![MIT licensed][mit-badge]][mit-url] +[![Build Status][actions-badge]][actions-url] +[![Discord chat][discord-badge]][discord-url] + +[Documentation][docs-master-url] | [Chat][discord-url] + +[docs-master-badge]: https://img.shields.io/badge/docs-master-blue +[docs-master-url]: https://tracing-rs.netlify.com/tracing_mock +[mit-badge]: https://img.shields.io/badge/license-MIT-blue.svg +[mit-url]: https://github.com/tokio-rs/tracing/blob/master/tracing-mock/LICENSE +[actions-badge]: https://github.com/tokio-rs/tracing/workflows/CI/badge.svg +[actions-url]:https://github.com/tokio-rs/tracing/actions?query=workflow%3ACI +[discord-badge]: https://img.shields.io/discord/500028886025895936?logo=discord&label=discord&logoColor=white +[discord-url]: https://discord.gg/EeF3cQw + +## Overview + +[`tracing`] is a framework for instrumenting Rust programs to collect +structured, event-based diagnostic information. `tracing-mock` provides +tools for making assertions about what `tracing` diagnostics are emitted +by code under test. + +*Compiler support: [requires `rustc` 1.49+][msrv]* + +[msrv]: #supported-rust-versions + +## Usage + +`tracing-mock` crate provides a mock +[`Collector`](https://tracing-rs.netlify.app/tracing/#collectors) +that allows asserting on the order and contents of +[spans](https://tracing-rs.netlify.app/tracing/#spans) and +[events](https://tracing-rs.netlify.app/tracing/#events). + +As `tracing-mock` isn't available on [crates.io](https://crates.io/) +yet, you must import it via git. When using `tracing-mock` with the +`tracing` `0.1` ecosystem, it is important that you also override the +source of any `tracing` crates that are transient dependencies. For +example, the `Cargo.toml` for your test crate could contain: + +```toml +[dependencies] +lib-under-test = "1.0" # depends on `tracing` + +[dev-dependencies] +tracing-mock = { git = "https://github.com/tokio-rs/tracing", branch = "v0.1.x", version = "0.1" } +tracing = { git = "https://github.com/tokio-rs/tracing", branch = "v0.1.x", version = "0.1" } + +[patch.crates-io] +tracing = { git = "https://github.com/tokio-rs/tracing", branch = "v0.1.x" } +tracing-core = { git = "https://github.com/tokio-rs/tracing", branch = "v0.1.x" } +``` + +## Examples + +The following examples are for the `master` branch. For examples that +will work with `tracing` from [crates.io], please check the +[v0.1.x](https://github.com/tokio-rs/tracing/tree/v0.1.x/tracing-mock) +branch. + +Below is an example that checks that an event contains a message: + +```rust +use tracing::collect::with_default; +use tracing_mock::{collector, expect, field}; + +fn yak_shaving() { + tracing::info!("preparing to shave yaks"); +} + +let (collector, handle) = collector::mock() + .event(expect::event().with_fields(field::msg("preparing to shave yaks"))) + .only() + .run_with_handle(); + +with_default(collector, || { + yak_shaving(); +}); + +handle.assert_finished(); + +``` + +Below is a slightly more complex example. `tracing-mock` asserts that, in order: +- a span is created with a single field/value pair +- the span is entered +- an event is created with the field `number_of_yaks`, a corresponding + value of 3, and the message "preparing to shave yaks", and nothing else +- an event is created with the field `all_yaks_shaved`, a corresponding value + of `true`, and the message "yak shaving completed" +- the span is exited +- no further traces are received + +```rust +use tracing::collect::with_default; +use tracing_mock::{collector, expect, field}; + +#[tracing::instrument] +fn yak_shaving(number_of_yaks: u32) { + tracing::info!(number_of_yaks, "preparing to shave yaks"); + + let number_shaved = number_of_yaks; // shave_all + tracing::info!( + all_yaks_shaved = number_shaved == number_of_yaks, + "yak shaving completed." + ); +} + +let yak_count: u32 = 3; +let span = expect::span().named("yak_shaving"); + +let (collector, handle) = collector::mock() + .new_span( + span.clone() + .with_field(expect::field("number_of_yaks").with_value(&yak_count).only()), + ) + .enter(span.clone()) + .event( + expect::event().with_fields( + expect::field("number_of_yaks") + .with_value(&yak_count) + .and(field::msg("preparing to shave yaks")) + .only(), + ), + ) + .event( + expect::event().with_fields( + expect::field("all_yaks_shaved") + .with_value(&true) + .and(field::msg("yak shaving completed.")) + .only(), + ), + ) + .exit(span.clone()) + .only() + .run_with_handle(); + +with_default(collector, || { + yak_shaving(yak_count); +}); + +handle.assert_finished(); +``` + +## Supported Rust Versions + +Tracing is built against the latest stable release. The minimum supported +version is 1.49. The current Tracing version is not guaranteed to build on Rust +versions earlier than the minimum supported version. + +Tracing follows the same compiler support policies as the rest of the Tokio +project. The current stable Rust compiler and the three most recent minor +versions before it will always be supported. For example, if the current stable +compiler version is 1.45, the minimum supported version will not be increased +past 1.42, three minor versions prior. Increasing the minimum supported compiler +version is not considered a semver breaking change as long as doing so complies +with this policy. + +## License + +This project is licensed under the [MIT license][mit-url]. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in Tracing by you, shall be licensed as MIT, without any additional +terms or conditions. \ No newline at end of file diff --git a/tracing-mock/src/lib.rs b/tracing-mock/src/lib.rs index e7a6e8b0e2..90cd371e35 100644 --- a/tracing-mock/src/lib.rs +++ b/tracing-mock/src/lib.rs @@ -1,3 +1,4 @@ +#![doc = include_str!("../README.md")] use std::{ pin::Pin, task::{Context, Poll}, From 5db72b63472ab2ca717d40770e28fb25a03ecbc1 Mon Sep 17 00:00:00 2001 From: Hayden Stainsby Date: Tue, 27 Dec 2022 19:38:26 +0100 Subject: [PATCH 04/34] attributes: update `async_instrument` error text for Rust 1.66 (#2427) The error message suggesting that you remove a semicolon to return a value (instead of unit) was updated slightly in rust-lang/rust#102650, which was included in Rust 1.66.0. This causes one of the tests in tracing-attributes to fail. We fix it by using the updated error message. From e8b379557c0113cf4d77bd4a825e7afefaea37a7 Mon Sep 17 00:00:00 2001 From: Hayden Stainsby Date: Thu, 5 Jan 2023 19:36:50 +0100 Subject: [PATCH 05/34] mock: document public APIs in `event` module (#2426) There has been interest around publishing tracing-mock to crates.io for some time. In order to make this possible, documentation and some code clean up is needed. The `event` module needs documentation and examples. This change adds documentation to the event module and all the public APIs within it. This includes doctests on all the methods which serve as examples. The following pattern was applied to the description of most methods: - Short description of expectation - Additional clarification (where needed) - Description of cases that cause the expectation to fail - Examples - Successful validation - Unsuccesful validation Two changes were also made in the text provided to the user when an assertion fails for `with_explicit_parent` or `with_contextual_parent`. One small API changes is also included: The method `in_scope` has been placed behind the `tracing-subscriber` feature flag as it currently only works with the `MockSubscriber`, not with the `MockCollector`. If the feature flag is active and it is used to set a non-empty scope, the `MockCollector` will panic with `unimplemented` during validation. Refs: #539 --- tracing-mock/Cargo.toml | 4 +- tracing-mock/README.md | 16 +- tracing-mock/src/event.rs | 473 ++++++++++++++++++++++++++++++++++++-- tracing-mock/src/lib.rs | 25 +- 4 files changed, 484 insertions(+), 34 deletions(-) diff --git a/tracing-mock/Cargo.toml b/tracing-mock/Cargo.toml index 2e060df78c..5cfca82b12 100644 --- a/tracing-mock/Cargo.toml +++ b/tracing-mock/Cargo.toml @@ -18,9 +18,9 @@ rust-version = "1.56.0" publish = false [dependencies] -tracing = { path = "../tracing", version = "0.1.35", default-features = false } +tracing = { path = "../tracing", version = "0.1.35", features = ["std", "attributes"], default-features = false } tracing-core = { path = "../tracing-core", version = "0.1.28", default-features = false } -tracing-subscriber = { path = "../tracing-subscriber", version = "0.3", default-features = false, optional = true } +tracing-subscriber = { path = "../tracing-subscriber", version = "0.3", default-features = false, features = ["registry"], optional = true } tokio-test = { version = "0.4.2", optional = true } # Fix minimal-versions; tokio-test fails with otherwise acceptable 0.1.0 diff --git a/tracing-mock/README.md b/tracing-mock/README.md index b508db00cb..bc0e932c74 100644 --- a/tracing-mock/README.md +++ b/tracing-mock/README.md @@ -70,19 +70,19 @@ branch. Below is an example that checks that an event contains a message: ```rust -use tracing::collect::with_default; -use tracing_mock::{collector, expect, field}; +use tracing::subscriber::with_default; +use tracing_mock::{subscriber, expect, field}; fn yak_shaving() { tracing::info!("preparing to shave yaks"); } -let (collector, handle) = collector::mock() +let (subscriber, handle) = subscriber::mock() .event(expect::event().with_fields(field::msg("preparing to shave yaks"))) .only() .run_with_handle(); -with_default(collector, || { +with_default(subscriber, || { yak_shaving(); }); @@ -101,8 +101,8 @@ Below is a slightly more complex example. `tracing-mock` asserts that, in order: - no further traces are received ```rust -use tracing::collect::with_default; -use tracing_mock::{collector, expect, field}; +use tracing::subscriber::with_default; +use tracing_mock::{subscriber, expect, field}; #[tracing::instrument] fn yak_shaving(number_of_yaks: u32) { @@ -118,7 +118,7 @@ fn yak_shaving(number_of_yaks: u32) { let yak_count: u32 = 3; let span = expect::span().named("yak_shaving"); -let (collector, handle) = collector::mock() +let (subscriber, handle) = subscriber::mock() .new_span( span.clone() .with_field(expect::field("number_of_yaks").with_value(&yak_count).only()), @@ -144,7 +144,7 @@ let (collector, handle) = collector::mock() .only() .run_with_handle(); -with_default(collector, || { +with_default(subscriber, || { yak_shaving(yak_count); }); diff --git a/tracing-mock/src/event.rs b/tracing-mock/src/event.rs index 0713ec0bae..6312b75eb1 100644 --- a/tracing-mock/src/event.rs +++ b/tracing-mock/src/event.rs @@ -1,12 +1,44 @@ +//! An [`ExpectedEvent`] defines an event to be matched by the mock +//! subscriber API in the [`subscriber`] module. +//! +//! The expected event should be created with [`expect::event`] and a +//! chain of method calls to describe the assertions we wish to make +//! about the event. +//! +//! # Examples +//! +//! ``` +//! use tracing::subscriber::with_default; +//! use tracing_mock::{subscriber, expect}; +//! +//! let event = expect::event() +//! .at_level(tracing::Level::INFO) +//! .with_fields(expect::field("field.name").with_value(&"field_value")); +//! +//! let (subscriber, handle) = subscriber::mock() +//! .event(event) +//! .run_with_handle(); +//! +//! with_default(subscriber, || { +//! tracing::info!(field.name = "field_value"); +//! }); +//! +//! handle.assert_finished(); +//! ``` +//! +//! [`subscriber`]: mod@crate::subscriber +//! [`expect::event`]: fn@crate::expect::event #![allow(missing_docs)] use super::{expect, field, metadata::ExpectedMetadata, span, Parent}; use std::fmt; -/// A mock event. +/// An expected event. /// -/// This is intended for use with the mock subscriber API in the -/// `subscriber` module. +/// For a detailed description and examples, see the documentation for +/// the methods and the [`event`] module. +/// +/// [`event`]: mod@crate::event #[derive(Default, Eq, PartialEq)] pub struct ExpectedEvent { pub(super) fields: Option, @@ -20,6 +52,20 @@ pub fn msg(message: impl fmt::Display) -> ExpectedEvent { } impl ExpectedEvent { + /// Sets a name to expect when matching an event. + /// + /// By default, an event's name takes takes the form: + /// `event :` where `` and `` refer to the + /// location in the source code where the event was generated. + /// + /// To override the name of an event, it has to be constructed + /// directly, rather than by using the `tracing` crate's macros. + /// + /// In general, there are not many use cases for expecting an + /// event with a particular name, as the value includes the file + /// name and line number. Assertions about event names are + /// therefore quite fragile, since they will change as the source + /// code is modified. pub fn named(self, name: I) -> Self where I: Into, @@ -33,6 +79,59 @@ impl ExpectedEvent { } } + /// Adds fields to expect when matching an event. + /// + /// If an event is recorded with fields that do not match the provided + /// [`ExpectedFields`], this expectation will fail. + /// + /// If the provided field is not present on the recorded event, or + /// if the value for that field is different, then the expectation + /// will fail. + /// + /// More information on the available validations is available in + /// the [`ExpectedFields`] documentation. + /// + /// # Examples + /// + /// ``` + /// use tracing::subscriber::with_default; + /// use tracing_mock::{subscriber, expect}; + /// + /// let event = expect::event() + /// .with_fields(expect::field("field.name").with_value(&"field_value")); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .event(event) + /// .run_with_handle(); + /// + /// with_default(subscriber, || { + /// tracing::info!(field.name = "field_value"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// A different field value will cause the expectation to fail: + /// + /// ```should_panic + /// use tracing::subscriber::with_default; + /// use tracing_mock::{subscriber, expect}; + /// + /// let event = expect::event() + /// .with_fields(expect::field("field.name").with_value(&"field_value")); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .event(event) + /// .run_with_handle(); + /// + /// with_default(subscriber, || { + /// tracing::info!(field.name = "different_field_value"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// [`ExpectedFields`]: struct@crate::field::ExpectedFields pub fn with_fields(self, fields: I) -> Self where I: Into, @@ -43,6 +142,51 @@ impl ExpectedEvent { } } + /// Sets the [`Level`](tracing::Level) to expect when matching an event. + /// + /// If an event is recorded at a different level, this expectation + /// will fail. + /// + /// # Examples + /// + /// ``` + /// use tracing::subscriber::with_default; + /// use tracing_mock::{subscriber, expect}; + /// + /// let event = expect::event() + /// .at_level(tracing::Level::WARN); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .event(event) + /// .run_with_handle(); + /// + /// with_default(subscriber, || { + /// tracing::warn!("this message is bad news"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// Expecting an event at `INFO` level will fail if the event is + /// recorded at any other level: + /// + /// ```should_panic + /// use tracing::subscriber::with_default; + /// use tracing_mock::{subscriber, expect}; + /// + /// let event = expect::event() + /// .at_level(tracing::Level::INFO); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .event(event) + /// .run_with_handle(); + /// + /// with_default(subscriber, || { + /// tracing::warn!("this message is bad news"); + /// }); + /// + /// handle.assert_finished(); + /// ``` pub fn at_level(self, level: tracing::Level) -> Self { Self { metadata: ExpectedMetadata { @@ -53,6 +197,49 @@ impl ExpectedEvent { } } + /// Sets the target to expect when matching events. + /// + /// If an event is recorded with a different target, this expectation will fail. + /// + /// # Examples + /// + /// ``` + /// use tracing::subscriber::with_default; + /// use tracing_mock::{subscriber, expect}; + /// + /// let event = expect::event() + /// .with_target("some_target"); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .event(event) + /// .run_with_handle(); + /// + /// with_default(subscriber, || { + /// tracing::info!(target: "some_target", field = &"value"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// The test will fail if the target is different: + /// + /// ```should_panic + /// use tracing::subscriber::with_default; + /// use tracing_mock::{subscriber, expect}; + /// + /// let event = expect::event() + /// .with_target("some_target"); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .event(event) + /// .run_with_handle(); + /// + /// with_default(subscriber, || { + /// tracing::info!(target: "a_different_target", field = &"value"); + /// }); + /// + /// handle.assert_finished(); + /// ``` pub fn with_target(self, target: I) -> Self where I: Into, @@ -66,6 +253,90 @@ impl ExpectedEvent { } } + /// Configures this `ExpectedEvent` to expect an explicit parent span + /// when matching events or to be an explicit root. + /// + /// An _explicit_ parent span is one passed to the `span!` macro in the + /// `parent:` field. + /// + /// If `Some("parent_name")` is passed to `with_explicit_parent` then + /// the provided string is the name of the parent span to expect. + /// + /// To expect that an event is recorded with `parent: None`, `None` + /// can be passed to `with_explicit_parent` instead. + /// + /// If an event is recorded without an explicit parent, or if the + /// explicit parent has a different name, this expectation will + /// fail. + /// + /// # Examples + /// + /// The explicit parent is matched by name: + /// + /// ``` + /// use tracing::subscriber::with_default; + /// use tracing_mock::{subscriber, expect}; + /// + /// let event = expect::event() + /// .with_explicit_parent(Some("parent_span")); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .event(event) + /// .run_with_handle(); + /// + /// with_default(subscriber, || { + /// let parent = tracing::info_span!("parent_span"); + /// tracing::info!(parent: parent.id(), field = &"value"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// In the following example, we expect that the matched event is + /// an explicit root: + /// + /// ``` + /// use tracing::subscriber::with_default; + /// use tracing_mock::{subscriber, expect}; + /// + /// let event = expect::event() + /// .with_explicit_parent(None); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .event(event) + /// .run_with_handle(); + /// + /// with_default(subscriber, || { + /// tracing::info!(parent: None, field = &"value"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// In the example below, the expectation fails because the + /// event is contextually (rather than explicitly) within the span + /// `parent_span`: + /// + /// ```should_panic + /// use tracing::subscriber::with_default; + /// use tracing_mock::{subscriber, expect}; + /// + /// let event = expect::event() + /// .with_explicit_parent(Some("parent_span")); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .enter(expect::span()) + /// .event(event) + /// .run_with_handle(); + /// + /// with_default(subscriber, || { + /// let parent = tracing::info_span!("parent_span"); + /// let _guard = parent.enter(); + /// tracing::info!(field = &"value"); + /// }); + /// + /// handle.assert_finished(); + /// ``` pub fn with_explicit_parent(self, parent: Option<&str>) -> ExpectedEvent { let parent = match parent { Some(name) => Parent::Explicit(name.into()), @@ -77,7 +348,190 @@ impl ExpectedEvent { } } - pub fn check( + /// Configures this `ExpectedEvent` to match an event with a + /// contextually-determined parent span. + /// + /// The provided string is the name of the parent span to expect. + /// To expect that the event is a contextually-determined root, pass + /// `None` instead. + /// + /// To expect an event with an explicit parent span, use + /// [`ExpectedEvent::with_explicit_parent`]. + /// + /// If an event is recorded which is not inside a span, has an explicitly + /// overridden parent span, or with a differently-named span as its + /// parent, this expectation will fail. + /// + /// # Examples + /// + /// The explicit parent is matched by name: + /// + /// ``` + /// use tracing::subscriber::with_default; + /// use tracing_mock::{subscriber, expect}; + /// + /// let event = expect::event() + /// .with_contextual_parent(Some("parent_span")); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .enter(expect::span()) + /// .event(event) + /// .run_with_handle(); + /// + /// with_default(subscriber, || { + /// let parent = tracing::info_span!("parent_span"); + /// let _guard = parent.enter(); + /// tracing::info!(field = &"value"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// Matching an event recorded outside of a span: + /// + /// ``` + /// use tracing::subscriber::with_default; + /// use tracing_mock::{subscriber, expect}; + /// + /// let event = expect::event() + /// .with_contextual_parent(None); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .event(event) + /// .run_with_handle(); + /// + /// with_default(subscriber, || { + /// tracing::info!(field = &"value"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// In the example below, the expectation fails because the + /// event is recorded with an explicit parent: + /// + /// ```should_panic + /// use tracing::subscriber::with_default; + /// use tracing_mock::{subscriber, expect}; + /// + /// let event = expect::event() + /// .with_contextual_parent(Some("parent_span")); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .enter(expect::span()) + /// .event(event) + /// .run_with_handle(); + /// + /// with_default(subscriber, || { + /// let parent = tracing::info_span!("parent_span"); + /// tracing::info!(parent: parent.id(), field = &"value"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + pub fn with_contextual_parent(self, parent: Option<&str>) -> ExpectedEvent { + let parent = match parent { + Some(name) => Parent::Contextual(name.into()), + None => Parent::ContextualRoot, + }; + Self { + parent: Some(parent), + ..self + } + } + + /// Validates that the event is emitted within the scope of the + /// provided `spans`. + /// + /// The spans must be provided reverse hierarchy order, so the + /// closest span to the event would be first, followed by its + /// parent, and so on. + /// + /// If the spans provided do not match the hierarchy of the + /// recorded event, the expectation will fail. + /// + /// **Note**: This validation currently only works with a + /// [`MockSubscriber`]. If used with a [`MockCollector`], the + /// expectation will fail directly as it is unimplemented. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{expect, subscriber}; + /// use tracing_subscriber::{ + /// filter::filter_fn, registry, subscribe::CollectExt, util::SubscriberInitExt, Subscribe, + /// }; + /// + /// let event = expect::event().in_scope([ + /// expect::span().named("parent_span"), + /// expect::span().named("grandparent_span") + /// ]); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .enter(expect::span()) + /// .enter(expect::span()) + /// .event(event) + /// .run_with_handle(); + /// + /// let _subscriber = registry() + /// .with(subscriber.with_filter(filter_fn(move |_meta| true))) + /// .set_default(); + /// + /// let grandparent = tracing::info_span!("grandparent_span"); + /// let _gp_guard = grandparent.enter(); + /// let parent = tracing::info_span!("parent_span"); + /// let _p_guard = parent.enter(); + /// tracing::info!(field = &"value"); + /// + /// handle.assert_finished(); + /// ``` + /// + /// The scope must match exactly, otherwise the expectation will fail: + /// + /// ```should_panic + /// use tracing_mock::{expect, subscriber}; + /// use tracing_subscriber::{ + /// filter::filter_fn, registry, subscribe::CollectExt, util::SubscriberInitExt, Subscribe, + /// }; + /// + /// let event = expect::event().in_scope([ + /// expect::span().named("parent_span"), + /// expect::span().named("grandparent_span") + /// ]); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .enter(expect::span()) + /// .event(event) + /// .run_with_handle(); + /// + /// let _subscriber = registry() + /// .with(subscriber.with_filter(filter_fn(move |_meta| true))) + /// .set_default(); + /// + /// let parent = tracing::info_span!("parent_span"); + /// let _p_guard = parent.enter(); + /// tracing::info!(field = &"value"); + /// + /// handle.assert_finished(); + /// ``` + /// [`MockSubscriber`]: struct@crate::subscriber::MockSubscriber + /// [`MockCollector`]: struct@crate::subscriber::MockCollector + #[cfg(feature = "tracing-subscriber")] + pub fn in_scope(self, spans: impl IntoIterator) -> Self { + Self { + in_spans: spans.into_iter().collect(), + ..self + } + } + + /// Provides access to the expected scope (spans) for this expected + /// event. + #[cfg(feature = "tracing-subscriber")] + pub(crate) fn scope_mut(&mut self) -> &mut [span::ExpectedSpan] { + &mut self.in_spans[..] + } + + pub(crate) fn check( &mut self, event: &tracing::Event<'_>, get_parent_name: impl FnOnce() -> Option, @@ -110,17 +564,6 @@ impl ExpectedEvent { ) } } - - pub fn in_scope(self, spans: impl IntoIterator) -> Self { - Self { - in_spans: spans.into_iter().collect(), - ..self - } - } - - pub fn scope_mut(&mut self) -> &mut [span::ExpectedSpan] { - &mut self.in_spans[..] - } } impl fmt::Display for ExpectedEvent { diff --git a/tracing-mock/src/lib.rs b/tracing-mock/src/lib.rs index 90cd371e35..720efbe30a 100644 --- a/tracing-mock/src/lib.rs +++ b/tracing-mock/src/lib.rs @@ -34,25 +34,32 @@ impl Parent { parent_name: Option<&str>, provided_parent: Option, ctx: impl std::fmt::Display, - collector_name: &str, + subscriber_name: &str, ) { match self { Parent::ExplicitRoot => { assert!( provided_parent.is_none(), "[{}] expected {} to be an explicit root, but its parent was actually {:?} (name: {:?})", - collector_name, + subscriber_name, ctx, provided_parent, parent_name, ); } Parent::Explicit(expected_parent) => { + assert!( + provided_parent.is_some(), + "[{}] expected {} to have explicit parent {}, but it has no explicit parent", + subscriber_name, + ctx, + expected_parent, + ); assert_eq!( Some(expected_parent.as_ref()), parent_name, "[{}] expected {} to have explicit parent {}, but its parent was actually {:?} (name: {:?})", - collector_name, + subscriber_name, ctx, expected_parent, provided_parent, @@ -62,8 +69,8 @@ impl Parent { Parent::ContextualRoot => { assert!( provided_parent.is_none(), - "[{}] expected {} to have a contextual parent, but its parent was actually {:?} (name: {:?})", - collector_name, + "[{}] expected {} to be a contextual root, but its parent was actually {:?} (name: {:?})", + subscriber_name, ctx, provided_parent, parent_name, @@ -71,15 +78,15 @@ impl Parent { assert!( parent_name.is_none(), "[{}] expected {} to be contextual a root, but we were inside span {:?}", - collector_name, + subscriber_name, ctx, parent_name, ); } Parent::Contextual(expected_parent) => { assert!(provided_parent.is_none(), - "[{}] expected {} to have a contextual parent\nbut its parent was actually {:?} (name: {:?})", - collector_name, + "[{}] expected {} to have a contextual parent\nbut it has the explicit parent {:?} (name: {:?})", + subscriber_name, ctx, provided_parent, parent_name, @@ -88,7 +95,7 @@ impl Parent { Some(expected_parent.as_ref()), parent_name, "[{}] expected {} to have contextual parent {:?}, but got {:?}", - collector_name, + subscriber_name, ctx, expected_parent, parent_name, From cbcfbf95083c8b6672aa114795d0cbd4df862c60 Mon Sep 17 00:00:00 2001 From: Hayden Stainsby Date: Fri, 27 Jan 2023 00:50:53 +0100 Subject: [PATCH 06/34] mock: document public APIs in `subscriber` module (#2446) There has been interest around publishing `tracing-mock` to crates.io for some time. In order to make this possible, documentation and some code clean up is needed. The `subscriber` module needs documentation and examples. This change adds documentation to the `subscriber` module and all the public APIs within it. This includes doctests on all the methods which serve as examples. The `MockSubscriberBuilder::record` method was removed as its functionality is not implemented. Previously, the `MockSubscriber` would verify the scope of an `ExpectedEvent`, even if `in_scope` hadn't been called. In this case, that would check that an event was not in a span if `in_scope` had not been called. `tracing-subscriber` all adhere to this pattern. However it is different to the behavior of all other expectation methods, where an explicit call is needed to expect something, otherwise nothing is checked. As such, the behavior has been modified to align with the rest of the crate. The previous behavior can be achieved by calling `in_scope(None)` to verify that an event has no scope. The documentation for `in_scope` has been updated with an example for this case. The tests in `tracing-subscriber` which previously verified *implicitly* that an event had no scope (by not calling `in_scope` at all) have *not* been modified. It is my opinion that this implicit behavior was never required. Refs: #539 --- tracing-mock/src/event.rs | 69 ++- tracing-mock/src/layer.rs | 777 ++++++++++++++++++++++++++++++--- tracing-mock/src/subscriber.rs | 17 +- 3 files changed, 778 insertions(+), 85 deletions(-) diff --git a/tracing-mock/src/event.rs b/tracing-mock/src/event.rs index 6312b75eb1..103d663605 100644 --- a/tracing-mock/src/event.rs +++ b/tracing-mock/src/event.rs @@ -9,7 +9,7 @@ //! //! ``` //! use tracing::subscriber::with_default; -//! use tracing_mock::{subscriber, expect}; +//! use tracing_mock::{expect, subscriber}; //! //! let event = expect::event() //! .at_level(tracing::Level::INFO) @@ -43,7 +43,7 @@ use std::fmt; pub struct ExpectedEvent { pub(super) fields: Option, pub(super) parent: Option, - pub(super) in_spans: Vec, + pub(super) in_spans: Option>, pub(super) metadata: ExpectedMetadata, } @@ -451,30 +451,28 @@ impl ExpectedEvent { /// recorded event, the expectation will fail. /// /// **Note**: This validation currently only works with a - /// [`MockSubscriber`]. If used with a [`MockCollector`], the + /// [`MockLayer`]. If used with a [`MockSubscriber`], the /// expectation will fail directly as it is unimplemented. /// /// # Examples /// /// ``` - /// use tracing_mock::{expect, subscriber}; - /// use tracing_subscriber::{ - /// filter::filter_fn, registry, subscribe::CollectExt, util::SubscriberInitExt, Subscribe, - /// }; + /// use tracing_mock::{expect, layer}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; /// /// let event = expect::event().in_scope([ /// expect::span().named("parent_span"), /// expect::span().named("grandparent_span") /// ]); /// - /// let (subscriber, handle) = subscriber::mock() + /// let (layer, handle) = layer::mock() /// .enter(expect::span()) /// .enter(expect::span()) /// .event(event) /// .run_with_handle(); /// - /// let _subscriber = registry() - /// .with(subscriber.with_filter(filter_fn(move |_meta| true))) + /// let _subscriber = tracing_subscriber::registry() + /// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) /// .set_default(); /// /// let grandparent = tracing::info_span!("grandparent_span"); @@ -489,23 +487,21 @@ impl ExpectedEvent { /// The scope must match exactly, otherwise the expectation will fail: /// /// ```should_panic - /// use tracing_mock::{expect, subscriber}; - /// use tracing_subscriber::{ - /// filter::filter_fn, registry, subscribe::CollectExt, util::SubscriberInitExt, Subscribe, - /// }; + /// use tracing_mock::{expect, layer}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; /// /// let event = expect::event().in_scope([ /// expect::span().named("parent_span"), /// expect::span().named("grandparent_span") /// ]); /// - /// let (subscriber, handle) = subscriber::mock() + /// let (layer, handle) = layer::mock() /// .enter(expect::span()) /// .event(event) /// .run_with_handle(); /// - /// let _subscriber = registry() - /// .with(subscriber.with_filter(filter_fn(move |_meta| true))) + /// let _subscriber = tracing_subscriber::registry() + /// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) /// .set_default(); /// /// let parent = tracing::info_span!("parent_span"); @@ -514,12 +510,39 @@ impl ExpectedEvent { /// /// handle.assert_finished(); /// ``` + /// + /// It is also possible to test that an event has no parent spans + /// by passing `None` to `in_scope`. If the event is within a + /// span, the test will fail: + /// + /// ```should_panic + /// use tracing_mock::{expect, layer}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; + /// + /// let event = expect::event().in_scope(None); + /// + /// let (layer, handle) = layer::mock() + /// .enter(expect::span()) + /// .event(event) + /// .run_with_handle(); + /// + /// let _subscriber = tracing_subscriber::registry() + /// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) + /// .set_default(); + /// + /// let parent = tracing::info_span!("parent_span"); + /// let _guard = parent.enter(); + /// tracing::info!(field = &"value"); + /// + /// handle.assert_finished(); + /// ``` + /// + /// [`MockLayer`]: struct@crate::layer::MockLayer /// [`MockSubscriber`]: struct@crate::subscriber::MockSubscriber - /// [`MockCollector`]: struct@crate::subscriber::MockCollector #[cfg(feature = "tracing-subscriber")] pub fn in_scope(self, spans: impl IntoIterator) -> Self { Self { - in_spans: spans.into_iter().collect(), + in_spans: Some(spans.into_iter().collect()), ..self } } @@ -527,8 +550,8 @@ impl ExpectedEvent { /// Provides access to the expected scope (spans) for this expected /// event. #[cfg(feature = "tracing-subscriber")] - pub(crate) fn scope_mut(&mut self) -> &mut [span::ExpectedSpan] { - &mut self.in_spans[..] + pub(crate) fn scope_mut(&mut self) -> Option<&mut [span::ExpectedSpan]> { + self.in_spans.as_mut().map(|s| &mut s[..]) } pub(crate) fn check( @@ -596,8 +619,8 @@ impl fmt::Debug for ExpectedEvent { s.field("parent", &format_args!("{:?}", parent)); } - if !self.in_spans.is_empty() { - s.field("in_spans", &self.in_spans); + if let Some(in_spans) = &self.in_spans { + s.field("in_spans", in_spans); } s.finish() diff --git a/tracing-mock/src/layer.rs b/tracing-mock/src/layer.rs index c577163dee..ab48171b9d 100644 --- a/tracing-mock/src/layer.rs +++ b/tracing-mock/src/layer.rs @@ -1,8 +1,123 @@ -#![allow(missing_docs, dead_code)] +//! An implementation of the [`Layer`] trait which validates that +//! the `tracing` data it recieves matches the expected output for a test. +//! +//! +//! The [`MockLayer`] is the central component in these tools. The +//! `MockLayer` has expectations set on it which are later +//! validated as the code under test is run. +//! +//! ``` +//! use tracing_mock::{expect, field, layer}; +//! use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; +//! +//! let (layer, handle) = layer::mock() +//! // Expect a single event with a specified message +//! .event(expect::event().with_fields(field::msg("droids"))) +//! .run_with_handle(); +//! +//! // Use `set_default` to apply the `MockSubscriber` until the end +//! // of the current scope (when the guard `_subscriber` is dropped). +//! let _subscriber = tracing_subscriber::registry() +//! .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) +//! .set_default(); +//! +//! // These *are* the droids we are looking for +//! tracing::info!("droids"); +//! +//! // Use the handle to check the assertions. This line will panic if an +//! // assertion is not met. +//! handle.assert_finished(); +//! ``` +//! +//! A more complex example may consider multiple spans and events with +//! their respective fields: +//! +//! ``` +//! use tracing_mock::{expect, field, layer}; +//! use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; +//! +//! let span = expect::span() +//! .named("my_span"); +//! let (layer, handle) = layer::mock() +//! // Enter a matching span +//! .enter(span.clone()) +//! // Record an event with message "collect parting message" +//! .event(expect::event().with_fields(field::msg("say hello"))) +//! // Exit a matching span +//! .exit(span) +//! // Expect no further messages to be recorded +//! .only() +//! // Return the layer and handle +//! .run_with_handle(); +//! +//! // Use `set_default` to apply the `MockLayers` until the end +//! // of the current scope (when the guard `_subscriber` is dropped). +//! let _subscriber = tracing_subscriber::registry() +//! .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) +//! .set_default(); +//! +//! { +//! let span = tracing::trace_span!( +//! "my_span", +//! greeting = "hello world", +//! ); +//! +//! let _guard = span.enter(); +//! tracing::info!("say hello"); +//! } +//! +//! // Use the handle to check the assertions. This line will panic if an +//! // assertion is not met. +//! handle.assert_finished(); +//! ``` +//! +//! If we modify the previous example so that we **don't** enter the +//! span before recording an event, the test will fail: +//! +//! ```should_panic +//! use tracing_mock::{expect, field, layer}; +//! use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; +//! +//! let span = expect::span() +//! .named("my_span"); +//! let (layer, handle) = layer::mock() +//! // Enter a matching span +//! .enter(span.clone()) +//! // Record an event with message "collect parting message" +//! .event(expect::event().with_fields(field::msg("say hello"))) +//! // Exit a matching span +//! .exit(span) +//! // Expect no further messages to be recorded +//! .only() +//! // Return the subscriber and handle +//! .run_with_handle(); +//! +//! // Use `set_default` to apply the `MockSubscriber` until the end +//! // of the current scope (when the guard `_subscriber` is dropped). +//! let _subscriber = tracing_subscriber::registry() +//! .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) +//! .set_default(); +//! +//! { +//! let span = tracing::trace_span!( +//! "my_span", +//! greeting = "hello world", +//! ); +//! +//! // Don't enter the span. +//! // let _guard = span.enter(); +//! tracing::info!("say hello"); +//! } +//! +//! // Use the handle to check the assertions. This line will panic if an +//! // assertion is not met. +//! handle.assert_finished(); +//! ``` +//! +//! [`Layer`]: trait@tracing_subscriber::layer::Layer use crate::{ event::ExpectedEvent, expect::Expect, - field::ExpectedFields, span::{ExpectedSpan, NewSpan}, subscriber::MockHandle, }; @@ -21,6 +136,55 @@ use std::{ sync::{Arc, Mutex}, }; +/// Create a [`MockLayerBuilder`] used to construct a +/// [`MockLayer`]. +/// +/// For additional information and examples, see the [`layer`] +/// module and [`MockLayerBuilder`] documentation. +/// +/// # Examples +/// +/// ``` +/// use tracing_mock::{expect, field, layer}; +/// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; +/// +/// let span = expect::span() +/// .named("my_span"); +/// let (layer, handle) = layer::mock() +/// // Enter a matching span +/// .enter(span.clone()) +/// // Record an event with message "collect parting message" +/// .event(expect::event().with_fields(field::msg("say hello"))) +/// // Exit a matching span +/// .exit(span) +/// // Expect no further messages to be recorded +/// .only() +/// // Return the subscriber and handle +/// .run_with_handle(); +/// +/// // Use `set_default` to apply the `MockSubscriber` until the end +/// // of the current scope (when the guard `_subscriber` is dropped). +/// let _subscriber = tracing_subscriber::registry() +/// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) +/// .set_default(); +/// +/// { +/// let span = tracing::trace_span!( +/// "my_span", +/// greeting = "hello world", +/// ); +/// +/// let _guard = span.enter(); +/// tracing::info!("say hello"); +/// } +/// +/// // Use the handle to check the assertions. This line will panic if an +/// // assertion is not met. +/// handle.assert_finished(); +/// ``` +/// +/// [`layer`]: mod@crate::layer +#[must_use] pub fn mock() -> MockLayerBuilder { MockLayerBuilder { expected: Default::default(), @@ -31,15 +195,81 @@ pub fn mock() -> MockLayerBuilder { } } +/// Create a [`MockLayerBuilder`] with a name already set. +/// +/// This constructor is equivalent to calling +/// [`MockLayerBuilder::named`] in the following way" +/// `layer::mock().named(name)`. +/// +/// For additional information and examples, see the [`layer`] +/// module and [`MockLayerBuilder`] documentation. +/// +/// # Examples +/// +/// The example from [`named`] could be rewritten as: +/// +/// ```should_panic +/// use tracing_mock::{expect, layer}; +/// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; +/// +/// let (layer_1, handle_1) = layer::named("subscriber-1") +/// .event(expect::event()) +/// .run_with_handle(); +/// +/// let (layer_2, handle_2) = layer::named("subscriber-2") +/// .event(expect::event()) +/// .run_with_handle(); +/// +/// let _subscriber = tracing_subscriber::registry() +/// .with( +/// layer_2.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true)) +/// ) +/// .set_default(); +/// { +/// let _subscriber = tracing_subscriber::registry() +/// .with( +/// layer_1 +/// .with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true)) +/// ) +/// .set_default(); +/// +/// tracing::info!("a"); +/// } +/// +/// handle_1.assert_finished(); +/// handle_2.assert_finished(); +/// ``` +/// +/// [`MockLayerBuilder::named`]: fn@crate::layer::MockLayerBuilder::named +/// [`layer`]: mod@crate::layer +#[must_use] pub fn named(name: impl std::fmt::Display) -> MockLayerBuilder { mock().named(name) } +/// A builder for constructing [`MockLayer`]s. +/// +/// The methods on this builder set expectations which are then +/// validated by the constructed [`MockLayer`]. +/// +/// For a detailed description and examples see the documentation +/// for the methods and the [`layer`] module. +/// +/// [`layer`]: mod@crate::layer + pub struct MockLayerBuilder { expected: VecDeque, name: String, } +/// A layer which validates the traces it receives. +/// +/// A `MockLayer` is constructed with a +/// [`MockLayerBuilder`]. For a detailed description and examples, +/// see the documentation for that struct and for the [`layer`] +/// module. +/// +/// [`layer`]: mod@crate::layer pub struct MockLayer { expected: Arc>>, current: Mutex>, @@ -58,8 +288,61 @@ impl MockLayerBuilder { /// When a test has only one mock layer, this is sufficient. However, /// some tests may include multiple layers, in order to test /// interactions between multiple layers. In that case, it can be - /// helpful to give each layer a separate name to distinguish where the + /// helpful to give each layers a separate name to distinguish where the /// debugging output comes from. + /// + /// # Examples + /// + /// In the following example, we create two layers, both + /// expecting to receive an event. As we only record a single + /// event, the test will fail: + /// + /// ```should_panic + /// use tracing_mock::{layer, expect}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; + /// + /// let (layer_1, handle_1) = layer::mock() + /// .named("layer-1") + /// .event(expect::event()) + /// .run_with_handle(); + /// + /// let (layer_2, handle_2) = layer::mock() + /// .named("layer-2") + /// .event(expect::event()) + /// .run_with_handle(); + /// + /// let _subscriber = tracing_subscriber::registry() + /// .with( + /// layer_2.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true)) + /// ) + /// .set_default(); + /// { + /// let _subscriber = tracing_subscriber::registry() + /// .with( + /// layer_1 + /// .with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true)) + /// ) + /// .set_default(); + /// + /// tracing::info!("a"); + /// } + /// + /// handle_1.assert_finished(); + /// handle_2.assert_finished(); + /// ``` + /// + /// In the test output, we see that the layer which didn't + /// received the event was the one named `layer-2`, which is + /// correct as the layer named `layer-1` was the default + /// when the event was recorded: + /// + /// ```text + /// [main::layer-2] more notifications expected: [ + /// Event( + /// MockEvent, + /// ), + /// ]', tracing-mock/src/subscriber.rs:472:13 + /// ``` pub fn named(mut self, name: impl fmt::Display) -> Self { use std::fmt::Write; if !self.name.is_empty() { @@ -70,42 +353,379 @@ impl MockLayerBuilder { self } - pub fn enter(mut self, span: ExpectedSpan) -> Self { - self.expected.push_back(Expect::Enter(span)); - self - } - + /// Adds an expectation that an event matching the [`ExpectedEvent`] + /// will be recorded next. + /// + /// The `event` can be a default mock which will match any event + /// (`expect::event()`) or can include additional expectations. + /// See the [`ExpectedEvent`] documentation for more details. + /// + /// If an event is recorded that doesn't match the `ExpectedEvent`, + /// or if something else (such as entering a span) is recorded + /// first, then the expectation will fail. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{expect, layer}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; + /// + /// let (layer, handle) = layer::mock() + /// .event(expect::event()) + /// .run_with_handle(); + /// + /// let _subscriber = tracing_subscriber::registry() + /// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) + /// .set_default(); + /// + /// tracing::info!("event"); + /// + /// handle.assert_finished(); + /// ``` + /// + /// A span is entered before the event, causing the test to fail: + /// + /// ```should_panic + /// use tracing_mock::{expect, layer}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; + /// + /// let (layer, handle) = layer::mock() + /// .event(expect::event()) + /// .run_with_handle(); + /// + /// let _subscriber = tracing_subscriber::registry() + /// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) + /// .set_default(); + /// + /// let span = tracing::info_span!("span"); + /// let _guard = span.enter(); + /// tracing::info!("event"); + /// + /// handle.assert_finished(); + /// ``` pub fn event(mut self, event: ExpectedEvent) -> Self { self.expected.push_back(Expect::Event(event)); self } - pub fn exit(mut self, span: ExpectedSpan) -> Self { - self.expected.push_back(Expect::Exit(span)); + /// Adds an expectation that the creation of a span will be + /// recorded next. + /// + /// This function accepts `Into` instead of + /// [`ExpectedSpan`] directly. [`NewSpan`] can be used to test + /// span fields and the span parent. + /// + /// The new span doesn't need to be entered for this expectation + /// to succeed. + /// + /// If a span is recorded that doesn't match the `ExpectedSpan`, + /// or if something else (such as an event) is recorded first, + /// then the expectation will fail. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{expect, layer}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; + /// + /// let span = expect::span() + /// .at_level(tracing::Level::INFO) + /// .named("the span we're testing") + /// .with_field(expect::field("testing").with_value(&"yes")); + /// let (layer, handle) = layer::mock() + /// .new_span(span) + /// .run_with_handle(); + /// + /// let _subscriber = tracing_subscriber::registry() + /// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) + /// .set_default(); + /// + /// _ = tracing::info_span!("the span we're testing", testing = "yes"); + /// + /// handle.assert_finished(); + /// ``` + /// + /// An event is recorded before the span is created, causing the + /// test to fail: + /// + /// ```should_panic + /// use tracing_mock::{expect, layer}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; + /// + /// let span = expect::span() + /// .at_level(tracing::Level::INFO) + /// .named("the span we're testing") + /// .with_field(expect::field("testing").with_value(&"yes")); + /// let (layer, handle) = layer::mock() + /// .new_span(span) + /// .run_with_handle(); + /// + /// let _subscriber = tracing_subscriber::registry() + /// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) + /// .set_default(); + /// + /// tracing::info!("an event"); + /// _ = tracing::info_span!("the span we're testing", testing = "yes"); + /// + /// handle.assert_finished(); + /// ``` + /// + /// [`ExpectedSpan`]: struct@crate::span::ExpectedSpan + /// [`NewSpan`]: struct@crate::span::NewSpan + pub fn new_span(mut self, new_span: I) -> Self + where + I: Into, + { + self.expected.push_back(Expect::NewSpan(new_span.into())); self } - pub fn only(mut self) -> Self { - self.expected.push_back(Expect::Nothing); + /// Adds an expectation that entering a span matching the + /// [`ExpectedSpan`] will be recorded next. + /// + /// This expectation is generally accompanied by a call to + /// [`exit`], since an entered span will typically be exited. If used + /// together with [`only`], this is likely necessary, because the span + /// will be dropped before the test completes (except in rare cases, + /// such as if [`std::mem::forget`] is used). + /// + /// If the span that is entered doesn't match the [`ExpectedSpan`], + /// or if something else (such as an event) is recorded first, + /// then the expectation will fail. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{expect, layer}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; + /// + /// let span = expect::span() + /// .at_level(tracing::Level::INFO) + /// .named("the span we're testing"); + /// let (layer, handle) = layer::mock() + /// .enter(span.clone()) + /// .exit(span) + /// .only() + /// .run_with_handle(); + /// + /// let _subscriber = tracing_subscriber::registry() + /// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) + /// .set_default(); + /// + /// { + /// let span = tracing::info_span!("the span we're testing"); + /// let _entered = span.enter(); + /// } + /// + /// handle.assert_finished(); + /// ``` + /// + /// An event is recorded before the span is entered, causing the + /// test to fail: + /// + /// ```should_panic + /// use tracing_mock::{expect, layer}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; + /// + /// let span = expect::span() + /// .at_level(tracing::Level::INFO) + /// .named("the span we're testing"); + /// let (layer, handle) = layer::mock() + /// .enter(span.clone()) + /// .exit(span) + /// .only() + /// .run_with_handle(); + /// + /// let _subscriber = tracing_subscriber::registry() + /// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) + /// .set_default(); + /// + /// { + /// tracing::info!("an event"); + /// let span = tracing::info_span!("the span we're testing"); + /// let _entered = span.enter(); + /// } + /// + /// handle.assert_finished(); + /// ``` + /// + /// [`exit`]: fn@Self::exit + /// [`only`]: fn@Self::only + pub fn enter(mut self, span: ExpectedSpan) -> Self { + self.expected.push_back(Expect::Enter(span)); self } - pub fn record(mut self, span: ExpectedSpan, fields: I) -> Self - where - I: Into, - { - self.expected.push_back(Expect::Visit(span, fields.into())); + /// Adds an expectation that exiting a span matching the + /// [`ExpectedSpan`] will be recorded next. + /// + /// As a span may be entered and exited multiple times, + /// this is different from the span being closed. In + /// general [`enter`] and `exit` should be paired. + /// + /// If the span that is exited doesn't match the [`ExpectedSpan`], + /// or if something else (such as an event) is recorded first, + /// then the expectation will fail. + /// + /// **Note**: Ensure that the guard returned by [`Span::enter`] + /// is dropped before calling [`MockHandle::assert_finished`]. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{expect, layer}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; + /// + /// let span = expect::span() + /// .at_level(tracing::Level::INFO) + /// .named("the span we're testing"); + /// let (layer, handle) = layer::mock() + /// .enter(span.clone()) + /// .exit(span) + /// .only() + /// .run_with_handle(); + /// + /// let _subscriber = tracing_subscriber::registry() + /// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) + /// .set_default(); + /// { + /// let span = tracing::info_span!("the span we're testing"); + /// let _entered = span.enter(); + /// } + /// + /// handle.assert_finished(); + /// ``` + /// + /// An event is recorded before the span is exited, causing the + /// test to fail: + /// + /// ```should_panic + /// use tracing_mock::{expect, layer}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; + /// + /// let span = expect::span() + /// .at_level(tracing::Level::INFO) + /// .named("the span we're testing"); + /// let (layer, handle) = layer::mock() + /// .enter(span.clone()) + /// .exit(span) + /// .only() + /// .run_with_handle(); + /// + /// let _subscriber = tracing_subscriber::registry() + /// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) + /// .set_default(); + /// + /// { + /// let span = tracing::info_span!("the span we're testing"); + /// let _entered = span.enter(); + /// tracing::info!("an event"); + /// } + /// + /// handle.assert_finished(); + /// ``` + /// + /// [`enter`]: fn@Self::enter + /// [`MockHandle::assert_finished`]: fn@crate::subscriber::MockHandle::assert_finished + /// [`Span::enter`]: fn@tracing::Span::enter + pub fn exit(mut self, span: ExpectedSpan) -> Self { + self.expected.push_back(Expect::Exit(span)); self } - pub fn new_span(mut self, new_span: I) -> Self - where - I: Into, - { - self.expected.push_back(Expect::NewSpan(new_span.into())); + /// Expects that no further traces are received. + /// + /// The call to `only` should appear immediately before the final + /// call to [`run`] or [`run_with_handle`], as any expectations which + /// are added after `only` will not be considered. + /// + /// # Examples + /// + /// Consider this simple test. It passes even though we only + /// expect a single event, but receive three: + /// + /// ``` + /// use tracing_mock::{expect, layer}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; + /// + /// let (layer, handle) = layer::mock() + /// .event(expect::event()) + /// .run_with_handle(); + /// + /// let _subscriber = tracing_subscriber::registry() + /// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) + /// .set_default(); + /// + /// tracing::info!("a"); + /// tracing::info!("b"); + /// tracing::info!("c"); + /// + /// handle.assert_finished(); + /// ``` + /// + /// After including `only`, the test will fail: + /// + /// ```should_panic + /// use tracing_mock::{expect, layer}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; + /// + /// let (layer, handle) = layer::mock() + /// .event(expect::event()) + /// .only() + /// .run_with_handle(); + /// + /// let _subscriber = tracing_subscriber::registry() + /// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) + /// .set_default(); + /// + /// tracing::info!("a"); + /// tracing::info!("b"); + /// tracing::info!("c"); + /// + /// handle.assert_finished(); + /// ``` + /// + /// [`run`]: fn@Self::run + /// [`run_with_handle`]: fn@Self::run_with_handle + pub fn only(mut self) -> Self { + self.expected.push_back(Expect::Nothing); self } + /// Consume this builder and return a [`MockLayer`] which can + /// be set as the default subscriber. + /// + /// This function is similar to [`run_with_handle`], but it doesn't + /// return a [`MockHandle`]. This is useful if the desired + /// assertions can be checked externally to the subscriber. + /// + /// # Examples + /// + /// The following test is used within the `tracing-subscriber` + /// codebase: + /// + /// ``` + /// use tracing::Subscriber; + /// use tracing_mock::layer; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; + /// + /// let unfiltered = layer::named("unfiltered").run().boxed(); + /// let info = layer::named("info") + /// .run() + /// .with_filter(tracing_core::LevelFilter::INFO) + /// .boxed(); + /// let debug = layer::named("debug") + /// .run() + /// .with_filter(tracing_core::LevelFilter::DEBUG) + /// .boxed(); + /// + /// let subscriber = tracing_subscriber::registry().with(vec![unfiltered, info, debug]); + /// + /// assert_eq!(subscriber.max_level_hint(), None); + /// ``` + /// + /// [`MockHandle`]: struct@crate::subscriber::MockHandle + /// [`run_with_handle`]: fn@Self::run_with_handle pub fn run(self) -> MockLayer { MockLayer { expected: Arc::new(Mutex::new(self.expected)), @@ -114,15 +734,40 @@ impl MockLayerBuilder { } } + /// Consume this builder and return a [`MockLayer`] which can + /// be set as the default subscriber and a [`MockHandle`] which can + /// be used to validate the provided expectations. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{expect, layer}; + /// use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Layer}; + /// + /// let (layer, handle) = layer::mock() + /// .event(expect::event()) + /// .run_with_handle(); + /// + /// let _subscriber = tracing_subscriber::registry() + /// .with(layer.with_filter(tracing_subscriber::filter::filter_fn(move |_meta| true))) + /// .set_default(); + /// + /// tracing::info!("event"); + /// + /// handle.assert_finished(); + /// ``` + /// + /// [`MockHandle`]: struct@crate::subscriber::MockHandle + /// [`MockLayer`]: struct@crate::layer::MockLayer pub fn run_with_handle(self) -> (MockLayer, MockHandle) { let expected = Arc::new(Mutex::new(self.expected)); let handle = MockHandle::new(expected.clone(), self.name.clone()); - let layer = MockLayer { + let subscriber = MockLayer { expected, name: self.name, current: Mutex::new(Vec::new()), }; - (layer, handle) + (subscriber, handle) } } @@ -185,6 +830,46 @@ impl MockLayer { ); } } + + fn check_event_scope( + &self, + current_scope: Option>, + expected_scope: &mut [ExpectedSpan], + ) where + C: for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>, + { + let mut current_scope = current_scope.into_iter().flatten(); + let mut i = 0; + for (expected, actual) in expected_scope.iter_mut().zip(&mut current_scope) { + println!( + "[{}] event_scope[{}] actual={} ({:?}); expected={}", + self.name, + i, + actual.name(), + actual.id(), + expected + ); + self.check_span_ref( + expected, + &actual, + format_args!("the {}th span in the event's scope to be", i), + ); + i += 1; + } + let remaining_expected = &expected_scope[i..]; + assert!( + remaining_expected.is_empty(), + "\n[{}] did not observe all expected spans in event scope!\n[{}] missing: {:#?}", + self.name, + self.name, + remaining_expected, + ); + assert!( + current_scope.next().is_none(), + "\n[{}] did not expect all spans in the actual event scope!", + self.name, + ); + } } impl Layer for MockLayer @@ -221,45 +906,21 @@ where Some(Expect::Event(mut expected)) => { let get_parent_name = || cx.event_span(event).map(|span| span.name().to_string()); expected.check(event, get_parent_name, &self.name); - let mut current_scope = cx.event_scope(event).into_iter().flatten(); - let expected_scope = expected.scope_mut(); - let mut i = 0; - for (expected, actual) in expected_scope.iter_mut().zip(&mut current_scope) { - println!( - "[{}] event_scope[{}] actual={} ({:?}); expected={}", - self.name, - i, - actual.name(), - actual.id(), - expected - ); - self.check_span_ref( - expected, - &actual, - format_args!("the {}th span in the event's scope to be", i), - ); - i += 1; + + if let Some(expected_scope) = expected.scope_mut() { + self.check_event_scope(cx.event_scope(event), expected_scope); } - let remaining_expected = &expected_scope[i..]; - assert!( - remaining_expected.is_empty(), - "\n[{}] did not observe all expected spans in event scope!\n[{}] missing: {:#?}", - self.name, - self.name, - remaining_expected, - ); - assert!( - current_scope.next().is_none(), - "\n[{}] did not expect all spans in the actual event scope!", - self.name, - ); } Some(ex) => ex.bad(&self.name, format_args!("observed event {:#?}", event)), } } fn on_follows_from(&self, _span: &Id, _follows: &Id, _: Context<'_, C>) { - // TODO: it should be possible to expect spans to follow from other spans + unimplemented!( + "so far, we don't have any tests that need an `on_follows_from` \ + implementation.\nif you just wrote one that does, feel free to \ + implement it!" + ); } fn on_new_span(&self, span: &Attributes<'_>, id: &Id, cx: Context<'_, C>) { @@ -377,13 +1038,13 @@ where } fn on_id_change(&self, _old: &Id, _new: &Id, _ctx: Context<'_, C>) { - panic!("well-behaved Layers should never do this to us, lol"); + panic!("well-behaved subscribers should never do this to us, lol"); } } impl fmt::Debug for MockLayer { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let mut s = f.debug_struct("Expectlayer"); + let mut s = f.debug_struct("ExpectSubscriber"); s.field("name", &self.name); if let Ok(expected) = self.expected.try_lock() { diff --git a/tracing-mock/src/subscriber.rs b/tracing-mock/src/subscriber.rs index f7e2929903..249985f3f0 100644 --- a/tracing-mock/src/subscriber.rs +++ b/tracing-mock/src/subscriber.rs @@ -155,14 +155,14 @@ where } pub fn run(self) -> impl Subscriber { - let (subscriber, _) = self.run_with_handle(); - subscriber + let (collector, _) = self.run_with_handle(); + collector } pub fn run_with_handle(self) -> (impl Subscriber, MockHandle) { let expected = Arc::new(Mutex::new(self.expected)); let handle = MockHandle(expected.clone(), self.name.clone()); - let subscriber = Running { + let collector = Running { spans: Mutex::new(HashMap::new()), expected, current: Mutex::new(Vec::new()), @@ -171,7 +171,7 @@ where max_level: self.max_level, name: self.name, }; - (subscriber, handle) + (collector, handle) } } @@ -229,6 +229,14 @@ where match self.expected.lock().unwrap().pop_front() { None => {} Some(Expect::Event(mut expected)) => { + #[cfg(feature = "tracing-subscriber")] + { + if expected.scope_mut().is_some() { + unimplemented!( + "Expected scope for events is not supported with `MockSubscriber`." + ) + } + } let get_parent_name = || { let stack = self.current.lock().unwrap(); let spans = self.spans.lock().unwrap(); @@ -454,6 +462,7 @@ where } impl MockHandle { + #[cfg(feature = "tracing-subscriber")] pub(crate) fn new(expected: Arc>>, name: String) -> Self { Self(expected, name) } From 516392ce586ea4ae06f28cd010f76ba4c4e55e0a Mon Sep 17 00:00:00 2001 From: Arif Driessen Date: Wed, 8 Feb 2023 19:26:50 +0100 Subject: [PATCH 07/34] docs: fix typo in `panic_hook` example (#2453) --- examples/examples/panic_hook.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/examples/panic_hook.rs b/examples/examples/panic_hook.rs index 20addd20b9..cb5f50bd1c 100644 --- a/examples/examples/panic_hook.rs +++ b/examples/examples/panic_hook.rs @@ -30,7 +30,7 @@ fn main() { // On nightly Rust, where the `PanicInfo` type also exposes a // `message()` method returning just the message, we could record // just the message instead of the entire `fmt::Display` - // implementation, avoiding the duplciated location + // implementation, avoiding the duplicated location tracing::error!( message = %panic, panic.file = location.file(), From d55ce3d7a7d5efffc82450af547702b171c4db51 Mon Sep 17 00:00:00 2001 From: David Barsky Date: Wed, 5 Apr 2023 14:19:55 -0400 Subject: [PATCH 08/34] chore: bump MSRV to 1.56 (#2546) As part of upgrading syn to 2.0 (e.g., https://github.com/tokio-rs/tracing/pull/2516), we need to bump the MSRV to 1.56. As part of this PR, I've: - Updated the text descriptions of what would be an in-policy MSRV bump to use more recent versions of rustc. The _niceness_ of said version numbers are purely coincidental. - I've removed some of the exceptions made in CI.yml in order to support some crates with a higher MSRV. --- tracing-mock/README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tracing-mock/README.md b/tracing-mock/README.md index bc0e932c74..c3adff3dab 100644 --- a/tracing-mock/README.md +++ b/tracing-mock/README.md @@ -29,7 +29,7 @@ structured, event-based diagnostic information. `tracing-mock` provides tools for making assertions about what `tracing` diagnostics are emitted by code under test. -*Compiler support: [requires `rustc` 1.49+][msrv]* +*Compiler support: [requires `rustc` 1.56+][msrv]* [msrv]: #supported-rust-versions @@ -154,14 +154,14 @@ handle.assert_finished(); ## Supported Rust Versions Tracing is built against the latest stable release. The minimum supported -version is 1.49. The current Tracing version is not guaranteed to build on Rust +version is 1.56. The current Tracing version is not guaranteed to build on Rust versions earlier than the minimum supported version. Tracing follows the same compiler support policies as the rest of the Tokio project. The current stable Rust compiler and the three most recent minor versions before it will always be supported. For example, if the current stable -compiler version is 1.45, the minimum supported version will not be increased -past 1.42, three minor versions prior. Increasing the minimum supported compiler +compiler version is 1.69, the minimum supported version will not be increased +past 1.66, three minor versions prior. Increasing the minimum supported compiler version is not considered a semver breaking change as long as doing so complies with this policy. From bcaeaa919ec4c33e68495f07b730531cef254ee9 Mon Sep 17 00:00:00 2001 From: James Munns Date: Tue, 7 Jun 2022 22:12:06 +0200 Subject: [PATCH 09/34] core: add `ValueSet::len` and `Record::len` (#2152) This PR adds two new accessor functions that are useful for creating a structured serde implementation for tracing. This is a sort of "distilled" version of https://github.com/tokio-rs/tracing/pull/2113, based on the `v0.1.x` branch. As it is unlikely that "structured serde" will be 1:1 compatible with the existing JSON-based `tracing-serde` (or at least - I'm not sure how to do it in a reasonable amount of effort), these functions will allow me to make a separate crate to hold me over until breaking formatting changes are possible in `tracing-serde`. CC @hawkw, as we've discussed this pretty extensively From bb81c7e93e08bbc8c275eb7a810f4f58e8958063 Mon Sep 17 00:00:00 2001 From: Hayden Stainsby Date: Sat, 24 Jun 2023 04:09:29 +0200 Subject: [PATCH 10/34] mock: document public API in collector module (#2389) There has been interest around publishing `tracing-mock` to crates.io for some time. In order to make this possible, documentation and some code clean up is needed. This change adds documentation to the collector module itself and to all the public APIs in the module. This includes doctests on all the methods that serve as examples. Additionally the implementation for the `Expect` struct has been moved into the module with the definition, this was missed in #2369. Refs: #539 --- tracing-mock/src/expect.rs | 50 ++ tracing-mock/src/subscriber.rs | 913 ++++++++++++++++++-- tracing-subscriber/tests/env_filter/main.rs | 5 +- 3 files changed, 895 insertions(+), 73 deletions(-) diff --git a/tracing-mock/src/expect.rs b/tracing-mock/src/expect.rs index a21f260e8d..044f134580 100644 --- a/tracing-mock/src/expect.rs +++ b/tracing-mock/src/expect.rs @@ -1,3 +1,5 @@ +use std::fmt; + use crate::{ event::ExpectedEvent, field::{ExpectedField, ExpectedFields, ExpectedValue}, @@ -41,3 +43,51 @@ pub fn span() -> ExpectedSpan { ..Default::default() } } + +impl Expect { + pub(crate) fn bad(&self, name: impl AsRef, what: fmt::Arguments<'_>) { + let name = name.as_ref(); + match self { + Expect::Event(e) => panic!( + "\n[{}] expected event {}\n[{}] but instead {}", + name, e, name, what, + ), + Expect::FollowsFrom { consequence, cause } => panic!( + "\n[{}] expected consequence {} to follow cause {} but instead {}", + name, consequence, cause, what, + ), + Expect::Enter(e) => panic!( + "\n[{}] expected to enter {}\n[{}] but instead {}", + name, e, name, what, + ), + Expect::Exit(e) => panic!( + "\n[{}] expected to exit {}\n[{}] but instead {}", + name, e, name, what, + ), + Expect::CloneSpan(e) => { + panic!( + "\n[{}] expected to clone {}\n[{}] but instead {}", + name, e, name, what, + ) + } + Expect::DropSpan(e) => { + panic!( + "\n[{}] expected to drop {}\n[{}] but instead {}", + name, e, name, what, + ) + } + Expect::Visit(e, fields) => panic!( + "\n[{}] expected {} to record {}\n[{}] but instead {}", + name, e, fields, name, what, + ), + Expect::NewSpan(e) => panic!( + "\n[{}] expected {}\n[{}] but instead {}", + name, e, name, what + ), + Expect::Nothing => panic!( + "\n[{}] expected nothing else to happen\n[{}] but {} instead", + name, name, what, + ), + } + } +} diff --git a/tracing-mock/src/subscriber.rs b/tracing-mock/src/subscriber.rs index 249985f3f0..ef7a93b148 100644 --- a/tracing-mock/src/subscriber.rs +++ b/tracing-mock/src/subscriber.rs @@ -1,4 +1,142 @@ -#![allow(missing_docs)] +//! An implementation of the [`Subscriber`] trait to receive and validate +//! `tracing` data. +//! +//! The [`MockSubscriber`] is the central component of this crate. The +//! `MockSubscriber` has expectations set on it which are later +//! validated as the code under test is run. +//! +//! # Examples +//! +//! ``` +//! use tracing_mock::{subscriber, expect, field}; +//! +//! let (subscriber, handle) = subscriber::mock() +//! // Expect a single event with a specified message +//! .event(expect::event().with_fields(field::msg("droids"))) +//! .only() +//! .run_with_handle(); +//! +//! // Use `with_default` to apply the `MockSubscriber` for the duration +//! // of the closure - this is what we are testing. +//! tracing::subscriber::with_default(subscriber, || { +//! // These *are* the droids we are looking for +//! tracing::info!("droids"); +//! }); +//! +//! // Use the handle to check the assertions. This line will panic if an +//! // assertion is not met. +//! handle.assert_finished(); +//! ``` +//! +//! A more complex example may consider multiple spans and events with +//! their respective fields: +//! +//! ``` +//! use tracing_mock::{subscriber, expect, field}; +//! +//! let span = expect::span() +//! .named("my_span"); +//! let (subscriber, handle) = subscriber::mock() +//! // Enter a matching span +//! .enter(span.clone()) +//! // Record an event with message "collect parting message" +//! .event(expect::event().with_fields(field::msg("collect parting message"))) +//! // Record a value for the field `parting` on a matching span +//! .record(span.clone(), expect::field("parting").with_value(&"goodbye world!")) +//! // Exit a matching span +//! .exit(span) +//! // Expect no further messages to be recorded +//! .only() +//! // Return the subscriber and handle +//! .run_with_handle(); +//! +//! // Use `with_default` to apply the `MockSubscriber` for the duration +//! // of the closure - this is what we are testing. +//! tracing::subscriber::with_default(subscriber, || { +//! let span = tracing::trace_span!( +//! "my_span", +//! greeting = "hello world", +//! parting = tracing::field::Empty +//! ); +//! +//! let _guard = span.enter(); +//! tracing::info!("collect parting message"); +//! let parting = "goodbye world!"; +//! +//! span.record("parting", &parting); +//! }); +//! +//! // Use the handle to check the assertions. This line will panic if an +//! // assertion is not met. +//! handle.assert_finished(); +//! ``` +//! +//! If we modify the previous example so that we **don't** enter the +//! span before recording an event, the test will fail: +//! +//! ```should_panic +//! use tracing_mock::{subscriber, expect, field}; +//! +//! let span = expect::span() +//! .named("my_span"); +//! let (subscriber, handle) = subscriber::mock() +//! .enter(span.clone()) +//! .event(expect::event().with_fields(field::msg("collect parting message"))) +//! .record(span.clone(), expect::field("parting").with_value(&"goodbye world!")) +//! .exit(span) +//! .only() +//! .run_with_handle(); +//! +//! // Use `with_default` to apply the `MockSubscriber` for the duration +//! // of the closure - this is what we are testing. +//! tracing::subscriber::with_default(subscriber, || { +//! let span = tracing::trace_span!( +//! "my_span", +//! greeting = "hello world", +//! parting = tracing::field::Empty +//! ); +//! +//! // Don't enter the span. +//! // let _guard = span.enter(); +//! tracing::info!("collect parting message"); +//! let parting = "goodbye world!"; +//! +//! span.record("parting", &parting); +//! }); +//! +//! // Use the handle to check the assertions. This line will panic if an +//! // assertion is not met. +//! handle.assert_finished(); +//! ``` +//! +//! This will result in an error message such as the following: +//! +//! ```text +//! thread 'main' panicked at ' +//! [main] expected to enter a span named `my_span` +//! [main] but instead observed event Event { +//! fields: ValueSet { +//! message: collect parting message, +//! callsite: Identifier(0x10eda3278), +//! }, +//! metadata: Metadata { +//! name: "event src/subscriber.rs:27", +//! target: "rust_out", +//! level: Level( +//! Info, +//! ), +//! module_path: "rust_out", +//! location: src/subscriber.rs:27, +//! fields: {message}, +//! callsite: Identifier(0x10eda3278), +//! kind: Kind(EVENT), +//! }, +//! parent: Current, +//! }', tracing/tracing-mock/src/expect.rs:59:33 +//! ``` +//! +//! [`Subscriber`]: trait@tracing::Subscriber +//! [`MockSubscriber`]: struct@crate::subscriber::MockSubscriber use crate::{ event::ExpectedEvent, expect::Expect, @@ -7,7 +145,6 @@ use crate::{ }; use std::{ collections::{HashMap, VecDeque}, - fmt, sync::{ atomic::{AtomicUsize, Ordering}, Arc, Mutex, @@ -37,6 +174,12 @@ struct Running) -> bool> { name: String, } +/// A subscriber which can validate received traces. +/// +/// For a detailed description and examples see the documentation +/// for the methods and the [`subscriber`] module. +/// +/// [`subscriber`]: mod@crate::subscriber pub struct MockSubscriber) -> bool> { expected: VecDeque, max_level: Option, @@ -44,8 +187,67 @@ pub struct MockSubscriber) -> bool> { name: String, } +/// A handle which is used to invoke validation of expectations. +/// +/// The handle is currently only used to assert that all the expected +/// events and spans were seen. +/// +/// For additional information and examples, see the [`subscriber`] +/// module documentation. +/// +/// [`subscriber`]: mod@crate::subscriber pub struct MockHandle(Arc>>, String); +/// Create a new [`MockSubscriber`]. +/// +/// For additional information and examples, see the [`subscriber`] +/// module and [`MockSubscriber`] documentation. +/// +/// # Examples +/// +/// +/// ``` +/// use tracing_mock::{subscriber, expect, field}; +/// +/// let span = expect::span() +/// .named("my_span"); +/// let (subscriber, handle) = subscriber::mock() +/// // Enter a matching span +/// .enter(span.clone()) +/// // Record an event with message "collect parting message" +/// .event(expect::event().with_fields(field::msg("collect parting message"))) +/// // Record a value for the field `parting` on a matching span +/// .record(span.clone(), expect::field("parting").with_value(&"goodbye world!")) +/// // Exit a matching span +/// .exit(span) +/// // Expect no further messages to be recorded +/// .only() +/// // Return the subscriber and handle +/// .run_with_handle(); +/// +/// // Use `with_default` to apply the `MockSubscriber` for the duration +/// // of the closure - this is what we are testing. +/// tracing::subscriber::with_default(subscriber, || { +/// let span = tracing::trace_span!( +/// "my_span", +/// greeting = "hello world", +/// parting = tracing::field::Empty +/// ); +/// +/// let _guard = span.enter(); +/// tracing::info!("collect parting message"); +/// let parting = "goodbye world!"; +/// +/// span.record("parting", &parting); +/// }); +/// +/// // Use the handle to check the assertions. This line will panic if an +/// // assertion is not met. +/// handle.assert_finished(); +/// ``` +/// +/// [`subscriber`]: mod@crate::subscriber +#[must_use] pub fn mock() -> MockSubscriber) -> bool> { MockSubscriber { expected: VecDeque::new(), @@ -75,6 +277,48 @@ where /// interactions between multiple subscribers. In that case, it can be /// helpful to give each subscriber a separate name to distinguish where the /// debugging output comes from. + /// + /// # Examples + /// + /// In the following example, we create 2 subscribers, both + /// expecting to receive an event. As we only record a single + /// event, the test will fail: + /// + /// ```should_panic + /// use tracing_mock::{subscriber, expect}; + /// + /// let (subscriber_1, handle_1) = subscriber::mock() + /// .named("subscriber-1") + /// .event(expect::event()) + /// .run_with_handle(); + /// + /// let (subscriber_2, handle_2) = subscriber::mock() + /// .named("subscriber-2") + /// .event(expect::event()) + /// .run_with_handle(); + /// + /// let _guard = tracing::subscriber::set_default(subscriber_2); + /// + /// tracing::subscriber::with_default(subscriber_1, || { + /// tracing::info!("a"); + /// }); + /// + /// handle_1.assert_finished(); + /// handle_2.assert_finished(); + /// ``` + /// + /// In the test output, we see that the subscriber which didn't + /// received the event was the one named `subscriber-2`, which is + /// correct as the subscriber named `subscriber-1` was the default + /// when the event was recorded: + /// + /// ```text + /// [subscriber-2] more notifications expected: [ + /// Event( + /// MockEvent, + /// ), + /// ]', tracing-mock/src/subscriber.rs:1276:13 + /// ``` pub fn named(self, name: impl ToString) -> Self { Self { name: name.to_string(), @@ -82,43 +326,443 @@ where } } - pub fn enter(mut self, span: ExpectedSpan) -> Self { - self.expected.push_back(Expect::Enter(span)); + /// Adds an expectation that an event matching the [`ExpectedEvent`] + /// will be recorded next. + /// + /// The `event` can be a default mock which will match any event + /// (`expect::event()`) or can include additional expectations. + /// See the [`ExpectedEvent`] documentation for more details. + /// + /// If an event is recorded that doesn't match the `ExpectedEvent`, + /// or if something else (such as entering a span) is recorded + /// first, then the expectation will fail. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{subscriber, expect}; + /// + /// let (subscriber, handle) = subscriber::mock() + /// .event(expect::event()) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// tracing::info!("a"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// A span is entered before the event, causing the test to fail: + /// + /// ```should_panic + /// use tracing_mock::{subscriber, expect}; + /// + /// let (subscriber, handle) = subscriber::mock() + /// .event(expect::event()) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// let span = tracing::info_span!("span"); + /// let _guard = span.enter(); + /// tracing::info!("a"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + pub fn event(mut self, event: ExpectedEvent) -> Self { + self.expected.push_back(Expect::Event(event)); self } - pub fn follows_from(mut self, consequence: ExpectedSpan, cause: ExpectedSpan) -> Self { - self.expected - .push_back(Expect::FollowsFrom { consequence, cause }); + /// Adds an expectation that the creation of a span will be + /// recorded next. + /// + /// This function accepts `Into` instead of + /// [`ExpectedSpan`] directly, so it can be used to test + /// span fields and the span parent. This is because a + /// subscriber only receives the span fields and parent when + /// a span is created, not when it is entered. + /// + /// The new span doesn't need to be entered for this expectation + /// to succeed. + /// + /// If a span is recorded that doesn't match the `ExpectedSpan`, + /// or if something else (such as an event) is recorded first, + /// then the expectation will fail. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{subscriber, expect}; + /// + /// let span = expect::span() + /// .at_level(tracing::Level::INFO) + /// .named("the span we're testing") + /// .with_field(expect::field("testing").with_value(&"yes")); + /// let (subscriber, handle) = subscriber::mock() + /// .new_span(span) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// _ = tracing::info_span!("the span we're testing", testing = "yes"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// An event is recorded before the span is created, causing the + /// test to fail: + /// + /// ```should_panic + /// use tracing_mock::{subscriber, expect}; + /// + /// let span = expect::span() + /// .at_level(tracing::Level::INFO) + /// .named("the span we're testing") + /// .with_field(expect::field("testing").with_value(&"yes")); + /// let (subscriber, handle) = subscriber::mock() + /// .new_span(span) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// tracing::info!("an event"); + /// _ = tracing::info_span!("the span we're testing", testing = "yes"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + pub fn new_span(mut self, new_span: I) -> Self + where + I: Into, + { + self.expected.push_back(Expect::NewSpan(new_span.into())); self } - pub fn event(mut self, event: ExpectedEvent) -> Self { - self.expected.push_back(Expect::Event(event)); + /// Adds an expectation that entering a span matching the + /// [`ExpectedSpan`] will be recorded next. + /// + /// This expectation is generally accompanied by a call to + /// [`exit`] as well. If used together with [`only`], this + /// is necessary. + /// + /// If the span that is entered doesn't match the [`ExpectedSpan`], + /// or if something else (such as an event) is recorded first, + /// then the expectation will fail. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{subscriber, expect}; + /// + /// let span = expect::span() + /// .at_level(tracing::Level::INFO) + /// .named("the span we're testing"); + /// let (subscriber, handle) = subscriber::mock() + /// .enter(span.clone()) + /// .exit(span) + /// .only() + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// let span = tracing::info_span!("the span we're testing"); + /// let _entered = span.enter(); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// An event is recorded before the span is entered, causing the + /// test to fail: + /// + /// ```should_panic + /// use tracing_mock::{subscriber, expect}; + /// + /// let span = expect::span() + /// .at_level(tracing::Level::INFO) + /// .named("the span we're testing"); + /// let (subscriber, handle) = subscriber::mock() + /// .enter(span.clone()) + /// .exit(span) + /// .only() + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// tracing::info!("an event"); + /// let span = tracing::info_span!("the span we're testing"); + /// let _entered = span.enter(); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// [`exit`]: fn@Self::exit + /// [`only`]: fn@Self::only + pub fn enter(mut self, span: ExpectedSpan) -> Self { + self.expected.push_back(Expect::Enter(span)); self } + /// Adds ab expectation that exiting a span matching the + /// [`ExpectedSpan`] will be recorded next. + /// + /// As a span may be entered and exited multiple times, + /// this is different from the span being closed. In + /// general [`enter`] and `exit` should be paired. + /// + /// If the span that is exited doesn't match the [`ExpectedSpan`], + /// or if something else (such as an event) is recorded first, + /// then the expectation will fail. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{subscriber, expect}; + /// + /// let span = expect::span() + /// .at_level(tracing::Level::INFO) + /// .named("the span we're testing"); + /// let (subscriber, handle) = subscriber::mock() + /// .enter(span.clone()) + /// .exit(span) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// let span = tracing::info_span!("the span we're testing"); + /// let _entered = span.enter(); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// An event is recorded before the span is exited, causing the + /// test to fail: + /// + /// ```should_panic + /// use tracing_mock::{subscriber, expect}; + /// + /// let span = expect::span() + /// .at_level(tracing::Level::INFO) + /// .named("the span we're testing"); + /// let (subscriber, handle) = subscriber::mock() + /// .enter(span.clone()) + /// .exit(span) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// let span = tracing::info_span!("the span we're testing"); + /// let _entered = span.enter(); + /// tracing::info!("an event"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// [`enter`]: fn@Self::enter pub fn exit(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::Exit(span)); self } + /// Adds an expectation that cloning a span matching the + /// [`ExpectedSpan`] will be recorded next. + /// + /// The cloned span does need to be entered. + /// + /// If the span that is cloned doesn't match the [`ExpectedSpan`], + /// or if something else (such as an event) is recorded first, + /// then the expectation will fail. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{subscriber, expect}; + /// + /// let span = expect::span() + /// .at_level(tracing::Level::INFO) + /// .named("the span we're testing"); + /// let (subscriber, handle) = subscriber::mock() + /// .clone_span(span) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// let span = tracing::info_span!("the span we're testing"); + /// _ = span.clone(); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// An event is recorded before the span is cloned, causing the + /// test to fail: + /// + /// ```should_panic + /// use tracing_mock::{subscriber, expect}; + /// + /// let span = expect::span() + /// .at_level(tracing::Level::INFO) + /// .named("the span we're testing"); + /// let (subscriber, handle) = subscriber::mock() + /// .clone_span(span) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// let span = tracing::info_span!("the span we're testing"); + /// tracing::info!("an event"); + /// _ = span.clone(); + /// }); + /// + /// handle.assert_finished(); + /// ``` pub fn clone_span(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::CloneSpan(span)); self } + /// **This method is deprecated.** + /// + /// Adds an expectation that a span matching the [`ExpectedSpan`] + /// getting dropped via the deprecated function + /// [`Subscriber::drop_span`] will be recorded next. + /// + /// Instead [`Subscriber::try_close`] should be used on the subscriber + /// and should be asserted with `close_span` (which hasn't been + /// implemented yet, but will be done as part of #539). + /// + /// [`Subscriber::drop_span`]: fn@tracing::Subscriber::drop_span #[allow(deprecated)] pub fn drop_span(mut self, span: ExpectedSpan) -> Self { self.expected.push_back(Expect::DropSpan(span)); self } - pub fn only(mut self) -> Self { - self.expected.push_back(Expect::Nothing); + /// Adds an expectation that a `follows_from` relationship will be + /// recorded next. Specifically that a span matching `consequence` + /// follows from a span matching `cause`. + /// + /// For further details on what this causal relationship means, see + /// [`Span::follows_from`]. + /// + /// If either of the 2 spans don't match their respective + /// [`ExpectedSpan`] or if something else (such as an event) is + /// recorded first, then the expectation will fail. + /// + /// **Note**: The 2 spans, `consequence` and `cause` are matched + /// by `name` only. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{subscriber, expect}; + /// + /// let cause = expect::span().named("cause"); + /// let consequence = expect::span().named("consequence"); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .follows_from(consequence, cause) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// let cause = tracing::info_span!("cause"); + /// let consequence = tracing::info_span!("consequence"); + /// + /// consequence.follows_from(&cause); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// The `cause` span doesn't match, it is actually recorded at + /// `Level::WARN` instead of the expected `Level::INFO`, causing + /// this test to fail: + /// + /// ```should_panic + /// use tracing_mock::{subscriber, expect}; + /// + /// let cause = expect::span().named("cause"); + /// let consequence = expect::span().named("consequence"); + /// + /// let (subscriber, handle) = subscriber::mock() + /// .follows_from(consequence, cause) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// let cause = tracing::info_span!("another cause"); + /// let consequence = tracing::info_span!("consequence"); + /// + /// consequence.follows_from(&cause); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// [`Span::follows_from`]: fn@tracing::Span::follows_from + pub fn follows_from(mut self, consequence: ExpectedSpan, cause: ExpectedSpan) -> Self { + self.expected + .push_back(Expect::FollowsFrom { consequence, cause }); self } + /// Adds an expectation that `fields` are recorded on a span + /// matching the [`ExpectedSpan`] will be recorded next. + /// + /// For further information on how to specify the expected + /// fields, see the documentation on the [`field`] module. + /// + /// If either the span doesn't match the [`ExpectedSpan`], the + /// fields don't match the expected fields, or if something else + /// (such as an event) is recorded first, then the expectation + /// will fail. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{subscriber, expect}; + /// + /// let span = expect::span() + /// .named("my_span"); + /// let (subscriber, handle) = subscriber::mock() + /// .record(span, expect::field("parting").with_value(&"goodbye world!")) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// let span = tracing::trace_span!( + /// "my_span", + /// greeting = "hello world", + /// parting = tracing::field::Empty + /// ); + /// span.record("parting", "goodbye world!"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// The value of the recorded field doesn't match the expectation, + /// causing the test to fail: + /// + /// ```should_panic + /// use tracing_mock::{subscriber, expect}; + /// + /// let span = expect::span() + /// .named("my_span"); + /// let (subscriber, handle) = subscriber::mock() + /// .record(span, expect::field("parting").with_value(&"goodbye world!")) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// let span = tracing::trace_span!( + /// "my_span", + /// greeting = "hello world", + /// parting = tracing::field::Empty + /// ); + /// span.record("parting", "goodbye universe!"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// [`field`]: mod@crate::field pub fn record(mut self, span: ExpectedSpan, fields: I) -> Self where I: Into, @@ -127,14 +771,31 @@ where self } - pub fn new_span(mut self, new_span: I) -> Self - where - I: Into, - { - self.expected.push_back(Expect::NewSpan(new_span.into())); - self - } - + /// Filter the traces evaluated by the `MockSubscriber`. + /// + /// The filter will be applied to all traces received before + /// any validation occurs - so its position in the call chain + /// is not important. The filter does not perform any validation + /// itself. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{subscriber, expect}; + /// + /// let (subscriber, handle) = subscriber::mock() + /// .with_filter(|meta| meta.level() <= &tracing::Level::WARN) + /// .event(expect::event()) + /// .only() + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// tracing::info!("a"); + /// tracing::warn!("b"); + /// }); + /// + /// handle.assert_finished(); + /// ``` pub fn with_filter(self, filter: G) -> MockSubscriber where G: Fn(&Metadata<'_>) -> bool + 'static, @@ -147,6 +808,39 @@ where } } + /// Sets the max level that will be provided to the `tracing` + /// system. + /// + /// This method can be used to test the internals of `tracing`, + /// but it is also useful to filter out traces on more verbose + /// levels if you only want to verify above a certain level. + /// + /// **Note**: this value determines a global filter, if + /// `with_max_level_hint` is called on multiple subscribers, the + /// global filter will be the least restrictive of all subscribers. + /// To filter the events evaluated by a specific `MockSubscriber`, + /// use [`with_filter`] instead. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{subscriber, expect}; + /// + /// let (subscriber, handle) = subscriber::mock() + /// .with_max_level_hint(tracing::Level::INFO) + /// .event(expect::event().at_level(tracing::Level::INFO)) + /// .only() + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// tracing::debug!("a message we don't care about"); + /// tracing::info!("a message we want to validate"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// [`with_filter`]: fn@Self::with_filter pub fn with_max_level_hint(self, hint: impl Into) -> Self { Self { max_level: Some(hint.into()), @@ -154,15 +848,112 @@ where } } + /// Expects that no further traces are received. + /// + /// The call to `only` should appear immediately before the final + /// call to `run` or `run_with_handle`, as any expectations which + /// are added after `only` will not be considered. + /// + /// # Examples + /// + /// Consider this simple test. It passes even though we only + /// expect a single event, but receive three: + /// + /// ``` + /// use tracing_mock::{subscriber, expect}; + /// + /// let (subscriber, handle) = subscriber::mock() + /// .event(expect::event()) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// tracing::info!("a"); + /// tracing::info!("b"); + /// tracing::info!("c"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// After including `only`, the test will fail: + /// + /// ```should_panic + /// use tracing_mock::{subscriber, expect}; + /// + /// let (subscriber, handle) = subscriber::mock() + /// .event(expect::event()) + /// .only() + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// tracing::info!("a"); + /// tracing::info!("b"); + /// tracing::info!("c"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + pub fn only(mut self) -> Self { + self.expected.push_back(Expect::Nothing); + self + } + + /// Consume the receiver and return an `impl` [`Subscriber`] which can + /// be set as the default subscriber. + /// + /// This function is similar to [`run_with_handle`], but it doesn't + /// return a [`MockHandle`]. This is useful if the desired + /// assertions can be checked externally to the subscriber. + /// + /// # Examples + /// + /// The following test is used within the `tracing` + /// codebase: + /// + /// ``` + /// use tracing_mock::subscriber; + /// + /// tracing::subscriber::with_default(subscriber::mock().run(), || { + /// let foo1 = tracing::span!(tracing::Level::TRACE, "foo"); + /// let foo2 = foo1.clone(); + /// // Two handles that point to the same span are equal. + /// assert_eq!(foo1, foo2); + /// }); + /// ``` + /// + /// [`Subscriber`]: tracing::Subscriber + /// [`run_with_handle`]: fn@Self::run_with_handle pub fn run(self) -> impl Subscriber { - let (collector, _) = self.run_with_handle(); - collector + let (subscriber, _) = self.run_with_handle(); + subscriber } + /// Consume the receiver and return an `impl` [`Subscriber`] which can + /// be set as the default subscriber and a [`MockHandle`] which can + /// be used to validate the provided expectations. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{subscriber, expect}; + /// + /// // subscriber and handle are returned from `run_with_handle()` + /// let (subscriber, handle) = subscriber::mock() + /// .event(expect::event()) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// tracing::info!("a"); + /// }); + /// + /// handle.assert_finished(); + /// ``` + /// + /// [`Subscriber`]: tracing::Subscriber pub fn run_with_handle(self) -> (impl Subscriber, MockHandle) { let expected = Arc::new(Mutex::new(self.expected)); let handle = MockHandle(expected.clone(), self.name.clone()); - let collector = Running { + let subscriber = Running { spans: Mutex::new(HashMap::new()), expected, current: Mutex::new(Vec::new()), @@ -171,7 +962,7 @@ where max_level: self.max_level, name: self.name, }; - (collector, handle) + (subscriber, handle) } } @@ -267,9 +1058,11 @@ where cause: ref expected_cause, }) => { if let Some(name) = expected_consequence.name() { + // TODO(hds): Write proper assertion text. assert_eq!(name, consequence_span.name); } if let Some(name) = expected_cause.name() { + // TODO(hds): Write proper assertion text. assert_eq!(name, cause_span.name); } } @@ -467,6 +1260,32 @@ impl MockHandle { Self(expected, name) } + /// Checks the expectations which were set on the + /// [`MockSubscriber`]. + /// + /// Calling `assert_finished` is usually the final part of a test. + /// + /// # Panics + /// + /// This method will panic if any of the provided expectations are + /// not met. + /// + /// # Examples + /// + /// ``` + /// use tracing_mock::{subscriber, expect}; + /// + /// let (subscriber, handle) = subscriber::mock() + /// .event(expect::event()) + /// .run_with_handle(); + /// + /// tracing::subscriber::with_default(subscriber, || { + /// tracing::info!("a"); + /// }); + /// + /// // Check assertions set on the mock subscriber + /// handle.assert_finished(); + /// ``` pub fn assert_finished(&self) { if let Ok(ref expected) = self.0.lock() { assert!( @@ -478,51 +1297,3 @@ impl MockHandle { } } } - -impl Expect { - pub fn bad(&self, name: impl AsRef, what: fmt::Arguments<'_>) { - let name = name.as_ref(); - match self { - Expect::Event(e) => panic!( - "\n[{}] expected event {}\n[{}] but instead {}", - name, e, name, what, - ), - Expect::FollowsFrom { consequence, cause } => panic!( - "\n[{}] expected consequence {} to follow cause {} but instead {}", - name, consequence, cause, what, - ), - Expect::Enter(e) => panic!( - "\n[{}] expected to enter {}\n[{}] but instead {}", - name, e, name, what, - ), - Expect::Exit(e) => panic!( - "\n[{}] expected to exit {}\n[{}] but instead {}", - name, e, name, what, - ), - Expect::CloneSpan(e) => { - panic!( - "\n[{}] expected to clone {}\n[{}] but instead {}", - name, e, name, what, - ) - } - Expect::DropSpan(e) => { - panic!( - "\n[{}] expected to drop {}\n[{}] but instead {}", - name, e, name, what, - ) - } - Expect::Visit(e, fields) => panic!( - "\n[{}] expected {} to record {}\n[{}] but instead {}", - name, e, fields, name, what, - ), - Expect::NewSpan(e) => panic!( - "\n[{}] expected {}\n[{}] but instead {}", - name, e, name, what - ), - Expect::Nothing => panic!( - "\n[{}] expected nothing else to happen\n[{}] but {} instead", - name, name, what, - ), - } - } -} diff --git a/tracing-subscriber/tests/env_filter/main.rs b/tracing-subscriber/tests/env_filter/main.rs index 21dbc1d37c..16921814c1 100644 --- a/tracing-subscriber/tests/env_filter/main.rs +++ b/tracing-subscriber/tests/env_filter/main.rs @@ -7,6 +7,7 @@ use tracing_mock::{expect, layer, span, subscriber}; use tracing_subscriber::{ filter::{EnvFilter, LevelFilter}, prelude::*, + Registry, }; #[test] @@ -95,7 +96,7 @@ fn level_filter_event_with_target_and_span_global() { let cool_span = span::named("cool_span"); let uncool_span = span::named("uncool_span"); - let (subscriber, handle) = subscriber::mock() + let (layer, handle) = layer::mock() .enter(cool_span.clone()) .event( expect::event() @@ -108,7 +109,7 @@ fn level_filter_event_with_target_and_span_global() { .only() .run_with_handle(); - let subscriber = subscriber.with(filter); + let subscriber = Registry::default().with(filter).with(layer); with_default(subscriber, || { { From 0b31599e0020259966cd2d42a822ebea8920da2b Mon Sep 17 00:00:00 2001 From: Harry Barber <106155934+hlbarber@users.noreply.github.com> Date: Tue, 11 Jul 2023 20:39:10 +0100 Subject: [PATCH 11/34] tracing: use fully qualified names in macros for items exported from std prelude (#2621) Currently, in many places, macros do not use fully qualified names for items exported from the prelude. This means that naming collisions (`struct Some`) or the removal of the std library prelude will cause compilation errors. - Identify and use fully qualified names in macros were we previously assumed the Rust std prelude. We use `::core` rather than `::std`. - Add [`no_implicit_prelude`](https://doc.rust-lang.org/reference/names/preludes.html#the-no_implicit_prelude-attribute) to `tracing/tests/macros.rs`. I'm unsure if this is giving us good coverage - can we improve on this approach? I'm not confident I've caught everything. --- tracing-core/src/field.rs | 2 +- tracing-core/src/lib.rs | 6 +- tracing-log/src/lib.rs | 6 +- tracing-subscriber/src/fmt/fmt_layer.rs | 2 +- tracing-subscriber/src/macros.rs | 2 +- tracing/src/macros.rs | 40 +-- tracing/tests/macros.rs | 320 ++++++++++++------------ 7 files changed, 191 insertions(+), 187 deletions(-) diff --git a/tracing-core/src/field.rs b/tracing-core/src/field.rs index 84936c51a0..a134e0dc2f 100644 --- a/tracing-core/src/field.rs +++ b/tracing-core/src/field.rs @@ -1086,7 +1086,7 @@ macro_rules! impl_valid_len { ( $( $len:tt ),+ ) => { $( impl<'a> private::ValidLen<'a> for - [(&'a Field, Option<&'a (dyn Value + 'a)>); $len] {} + [(&'a Field, ::core::option::Option<&'a (dyn Value + 'a)>); $len] {} )+ } } diff --git a/tracing-core/src/lib.rs b/tracing-core/src/lib.rs index f5de4eeba9..d43a6b8b04 100644 --- a/tracing-core/src/lib.rs +++ b/tracing-core/src/lib.rs @@ -243,9 +243,9 @@ macro_rules! metadata { $name, $target, $level, - Some(file!()), - Some(line!()), - Some(module_path!()), + ::core::option::Option::Some(file!()), + ::core::option::Option::Some(line!()), + ::core::option::Option::Some(module_path!()), $crate::field::FieldSet::new($fields, $crate::identify_callsite!($callsite)), $kind, ) diff --git a/tracing-log/src/lib.rs b/tracing-log/src/lib.rs index 768d4f6922..d2637545c1 100644 --- a/tracing-log/src/lib.rs +++ b/tracing-log/src/lib.rs @@ -307,9 +307,9 @@ macro_rules! log_cs { "log event", "log", $level, - None, - None, - None, + ::core::option::Option::None, + ::core::option::Option::None, + ::core::option::Option::None, field::FieldSet::new(FIELD_NAMES, identify_callsite!(&$cs)), Kind::EVENT, ); diff --git a/tracing-subscriber/src/fmt/fmt_layer.rs b/tracing-subscriber/src/fmt/fmt_layer.rs index 1e0923a547..e2f7cc8f98 100644 --- a/tracing-subscriber/src/fmt/fmt_layer.rs +++ b/tracing-subscriber/src/fmt/fmt_layer.rs @@ -775,7 +775,7 @@ macro_rules! with_event_from_span { #[allow(unused)] let mut iter = fs.iter(); let v = [$( - (&iter.next().unwrap(), Some(&$value as &dyn field::Value)), + (&iter.next().unwrap(), ::core::option::Option::Some(&$value as &dyn field::Value)), )*]; let vs = fs.value_set(&v); let $event = Event::new_child_of($id, meta, &vs); diff --git a/tracing-subscriber/src/macros.rs b/tracing-subscriber/src/macros.rs index 81351132f5..5b461d0a0a 100644 --- a/tracing-subscriber/src/macros.rs +++ b/tracing-subscriber/src/macros.rs @@ -4,7 +4,7 @@ macro_rules! try_lock { try_lock!($lock, else return) }; ($lock:expr, else $els:expr) => { - if let Ok(l) = $lock { + if let ::core::result::Result::Ok(l) = $lock { l } else if std::thread::panicking() { $els diff --git a/tracing/src/macros.rs b/tracing/src/macros.rs index a737348cbc..e1f43f436b 100644 --- a/tracing/src/macros.rs +++ b/tracing/src/macros.rs @@ -2193,79 +2193,79 @@ macro_rules! valueset { // }; (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = ?$val:expr, $($rest:tt)*) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&debug(&$val) as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&debug(&$val) as &dyn Value)) }, $next, $($rest)* ) }; (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = %$val:expr, $($rest:tt)*) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&display(&$val) as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&display(&$val) as &dyn Value)) }, $next, $($rest)* ) }; (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = $val:expr, $($rest:tt)*) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&$val as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&$val as &dyn Value)) }, $next, $($rest)* ) }; (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+, $($rest:tt)*) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&$($k).+ as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&$($k).+ as &dyn Value)) }, $next, $($rest)* ) }; (@ { $(,)* $($out:expr),* }, $next:expr, ?$($k:ident).+, $($rest:tt)*) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&debug(&$($k).+) as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&debug(&$($k).+) as &dyn Value)) }, $next, $($rest)* ) }; (@ { $(,)* $($out:expr),* }, $next:expr, %$($k:ident).+, $($rest:tt)*) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&display(&$($k).+) as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&display(&$($k).+) as &dyn Value)) }, $next, $($rest)* ) }; (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = ?$val:expr) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&debug(&$val) as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&debug(&$val) as &dyn Value)) }, $next, ) }; (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = %$val:expr) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&display(&$val) as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&display(&$val) as &dyn Value)) }, $next, ) }; (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+ = $val:expr) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&$val as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&$val as &dyn Value)) }, $next, ) }; (@ { $(,)* $($out:expr),* }, $next:expr, $($k:ident).+) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&$($k).+ as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&$($k).+ as &dyn Value)) }, $next, ) }; (@ { $(,)* $($out:expr),* }, $next:expr, ?$($k:ident).+) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&debug(&$($k).+) as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&debug(&$($k).+) as &dyn Value)) }, $next, ) }; (@ { $(,)* $($out:expr),* }, $next:expr, %$($k:ident).+) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&display(&$($k).+) as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&display(&$($k).+) as &dyn Value)) }, $next, ) }; @@ -2273,47 +2273,47 @@ macro_rules! valueset { // Handle literal names (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = ?$val:expr, $($rest:tt)*) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&debug(&$val) as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&debug(&$val) as &dyn Value)) }, $next, $($rest)* ) }; (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = %$val:expr, $($rest:tt)*) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&display(&$val) as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&display(&$val) as &dyn Value)) }, $next, $($rest)* ) }; (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = $val:expr, $($rest:tt)*) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&$val as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&$val as &dyn Value)) }, $next, $($rest)* ) }; (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = ?$val:expr) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&debug(&$val) as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&debug(&$val) as &dyn Value)) }, $next, ) }; (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = %$val:expr) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&display(&$val) as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&display(&$val) as &dyn Value)) }, $next, ) }; (@ { $(,)* $($out:expr),* }, $next:expr, $k:literal = $val:expr) => { $crate::valueset!( - @ { $($out),*, (&$next, Some(&$val as &dyn Value)) }, + @ { $($out),*, (&$next, ::core::option::Option::Some(&$val as &dyn Value)) }, $next, ) }; // Remainder is unparsable, but exists --- must be format args! (@ { $(,)* $($out:expr),* }, $next:expr, $($rest:tt)+) => { - $crate::valueset!(@ { (&$next, Some(&format_args!($($rest)+) as &dyn Value)), $($out),* }, $next, ) + $crate::valueset!(@ { (&$next, ::core::option::Option::Some(&format_args!($($rest)+) as &dyn Value)), $($out),* }, $next, ) }; // === entry === @@ -2324,7 +2324,7 @@ macro_rules! valueset { let mut iter = $fields.iter(); $fields.value_set($crate::valueset!( @ { }, - iter.next().expect("FieldSet corrupted (this is a bug)"), + ::core::iter::Iterator::next(&mut iter).expect("FieldSet corrupted (this is a bug)"), $($kvs)+ )) } diff --git a/tracing/tests/macros.rs b/tracing/tests/macros.rs index a9679a3e94..423984da27 100644 --- a/tracing/tests/macros.rs +++ b/tracing/tests/macros.rs @@ -1,4 +1,8 @@ #![deny(warnings)] +// We call all macros in this module with `no_implicit_prelude` to ensure they do not depend on the standard prelude. +#![no_implicit_prelude] +extern crate tracing; + use tracing::{ callsite, debug, debug_span, enabled, error, error_span, event, event_enabled, info, info_span, span, span_enabled, trace, trace_span, warn, warn_span, Level, @@ -111,80 +115,80 @@ fn error_span() { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] fn span_root() { - span!(target: "foo_events", parent: None, Level::TRACE, "foo", bar.baz = 2, quux = 3); - span!(target: "foo_events", parent: None, Level::TRACE, "foo", bar.baz = 2, quux = 3); - span!(target: "foo_events", parent: None, Level::TRACE, "foo", bar.baz = 2, quux = 4,); - span!(target: "foo_events", parent: None, Level::TRACE, "foo"); - span!(target: "foo_events", parent: None, Level::TRACE, "bar",); - span!(parent: None, Level::DEBUG, "foo", bar.baz = 2, quux = 3); - span!(parent: None, Level::DEBUG, "foo", bar.baz = 2, quux = 4,); - span!(parent: None, Level::DEBUG, "foo"); - span!(parent: None, Level::DEBUG, "bar",); + span!(target: "foo_events", parent: ::core::option::Option::None, Level::TRACE, "foo", bar.baz = 2, quux = 3); + span!(target: "foo_events", parent: ::core::option::Option::None, Level::TRACE, "foo", bar.baz = 2, quux = 3); + span!(target: "foo_events", parent: ::core::option::Option::None, Level::TRACE, "foo", bar.baz = 2, quux = 4,); + span!(target: "foo_events", parent: ::core::option::Option::None, Level::TRACE, "foo"); + span!(target: "foo_events", parent: ::core::option::Option::None, Level::TRACE, "bar",); + span!(parent: ::core::option::Option::None, Level::DEBUG, "foo", bar.baz = 2, quux = 3); + span!(parent: ::core::option::Option::None, Level::DEBUG, "foo", bar.baz = 2, quux = 4,); + span!(parent: ::core::option::Option::None, Level::DEBUG, "foo"); + span!(parent: ::core::option::Option::None, Level::DEBUG, "bar",); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] fn trace_span_root() { - trace_span!(target: "foo_events", parent: None, "foo", bar.baz = 2, quux = 3); - trace_span!(target: "foo_events", parent: None, "foo", bar.baz = 2, quux = 4,); - trace_span!(target: "foo_events", parent: None, "foo"); - trace_span!(target: "foo_events", parent: None, "bar",); - trace_span!(parent: None, "foo", bar.baz = 2, quux = 3); - trace_span!(parent: None, "foo", bar.baz = 2, quux = 4,); - trace_span!(parent: None, "foo"); - trace_span!(parent: None, "bar",); + trace_span!(target: "foo_events", parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 3); + trace_span!(target: "foo_events", parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 4,); + trace_span!(target: "foo_events", parent: ::core::option::Option::None, "foo"); + trace_span!(target: "foo_events", parent: ::core::option::Option::None, "bar",); + trace_span!(parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 3); + trace_span!(parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 4,); + trace_span!(parent: ::core::option::Option::None, "foo"); + trace_span!(parent: ::core::option::Option::None, "bar",); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] fn debug_span_root() { - debug_span!(target: "foo_events", parent: None, "foo", bar.baz = 2, quux = 3); - debug_span!(target: "foo_events", parent: None, "foo", bar.baz = 2, quux = 4,); - debug_span!(target: "foo_events", parent: None, "foo"); - debug_span!(target: "foo_events", parent: None, "bar",); - debug_span!(parent: None, "foo", bar.baz = 2, quux = 3); - debug_span!(parent: None, "foo", bar.baz = 2, quux = 4,); - debug_span!(parent: None, "foo"); - debug_span!(parent: None, "bar",); + debug_span!(target: "foo_events", parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 3); + debug_span!(target: "foo_events", parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 4,); + debug_span!(target: "foo_events", parent: ::core::option::Option::None, "foo"); + debug_span!(target: "foo_events", parent: ::core::option::Option::None, "bar",); + debug_span!(parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 3); + debug_span!(parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 4,); + debug_span!(parent: ::core::option::Option::None, "foo"); + debug_span!(parent: ::core::option::Option::None, "bar",); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] fn info_span_root() { - info_span!(target: "foo_events", parent: None, "foo", bar.baz = 2, quux = 3); - info_span!(target: "foo_events", parent: None, "foo", bar.baz = 2, quux = 4,); - info_span!(target: "foo_events", parent: None, "foo"); - info_span!(target: "foo_events", parent: None, "bar",); - info_span!(parent: None, "foo", bar.baz = 2, quux = 3); - info_span!(parent: None, "foo", bar.baz = 2, quux = 4,); - info_span!(parent: None, "foo"); - info_span!(parent: None, "bar",); + info_span!(target: "foo_events", parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 3); + info_span!(target: "foo_events", parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 4,); + info_span!(target: "foo_events", parent: ::core::option::Option::None, "foo"); + info_span!(target: "foo_events", parent: ::core::option::Option::None, "bar",); + info_span!(parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 3); + info_span!(parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 4,); + info_span!(parent: ::core::option::Option::None, "foo"); + info_span!(parent: ::core::option::Option::None, "bar",); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] fn warn_span_root() { - warn_span!(target: "foo_events", parent: None, "foo", bar.baz = 2, quux = 3); - warn_span!(target: "foo_events", parent: None, "foo", bar.baz = 2, quux = 4,); - warn_span!(target: "foo_events", parent: None, "foo"); - warn_span!(target: "foo_events", parent: None, "bar",); - warn_span!(parent: None, "foo", bar.baz = 2, quux = 3); - warn_span!(parent: None, "foo", bar.baz = 2, quux = 4,); - warn_span!(parent: None, "foo"); - warn_span!(parent: None, "bar",); + warn_span!(target: "foo_events", parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 3); + warn_span!(target: "foo_events", parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 4,); + warn_span!(target: "foo_events", parent: ::core::option::Option::None, "foo"); + warn_span!(target: "foo_events", parent: ::core::option::Option::None, "bar",); + warn_span!(parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 3); + warn_span!(parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 4,); + warn_span!(parent: ::core::option::Option::None, "foo"); + warn_span!(parent: ::core::option::Option::None, "bar",); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] fn error_span_root() { - error_span!(target: "foo_events", parent: None, "foo", bar.baz = 2, quux = 3); - error_span!(target: "foo_events", parent: None, "foo", bar.baz = 2, quux = 4,); - error_span!(target: "foo_events", parent: None, "foo"); - error_span!(target: "foo_events", parent: None, "bar",); - error_span!(parent: None, "foo", bar.baz = 2, quux = 3); - error_span!(parent: None, "foo", bar.baz = 2, quux = 4,); - error_span!(parent: None, "foo"); - error_span!(parent: None, "bar",); + error_span!(target: "foo_events", parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 3); + error_span!(target: "foo_events", parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 4,); + error_span!(target: "foo_events", parent: ::core::option::Option::None, "foo"); + error_span!(target: "foo_events", parent: ::core::option::Option::None, "bar",); + error_span!(parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 3); + error_span!(parent: ::core::option::Option::None, "foo", bar.baz = 2, quux = 4,); + error_span!(parent: ::core::option::Option::None, "foo"); + error_span!(parent: ::core::option::Option::None, "bar",); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] @@ -605,144 +609,144 @@ fn error() { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] fn event_root() { - event!(parent: None, Level::DEBUG, foo = ?3, bar.baz = %2, quux = false); + event!(parent: ::core::option::Option::None, Level::DEBUG, foo = ?3, bar.baz = %2, quux = false); event!( - parent: None, + parent: ::core::option::Option::None, Level::DEBUG, foo = 3, bar.baz = 2, quux = false ); - event!(parent: None, Level::DEBUG, foo = 3, bar.baz = 3,); - event!(parent: None, Level::DEBUG, "foo"); - event!(parent: None, Level::DEBUG, "foo: {}", 3); - event!(parent: None, Level::DEBUG, { foo = 3, bar.baz = 80 }, "quux"); - event!(parent: None, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}", true); - event!(parent: None, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); - event!(parent: None, Level::DEBUG, { foo = ?2, bar.baz = %78 }, "quux"); - event!(target: "foo_events", parent: None, Level::DEBUG, foo = 3, bar.baz = 2, quux = false); - event!(target: "foo_events", parent: None, Level::DEBUG, foo = 3, bar.baz = 3,); - event!(target: "foo_events", parent: None, Level::DEBUG, "foo"); - event!(target: "foo_events", parent: None, Level::DEBUG, "foo: {}", 3); - event!(target: "foo_events", parent: None, Level::DEBUG, { foo = 3, bar.baz = 80 }, "quux"); - event!(target: "foo_events", parent: None, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}", true); - event!(target: "foo_events", parent: None, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); - event!(target: "foo_events", parent: None, Level::DEBUG, { foo = 2, bar.baz = 78, }, "quux"); + event!(parent: ::core::option::Option::None, Level::DEBUG, foo = 3, bar.baz = 3,); + event!(parent: ::core::option::Option::None, Level::DEBUG, "foo"); + event!(parent: ::core::option::Option::None, Level::DEBUG, "foo: {}", 3); + event!(parent: ::core::option::Option::None, Level::DEBUG, { foo = 3, bar.baz = 80 }, "quux"); + event!(parent: ::core::option::Option::None, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}", true); + event!(parent: ::core::option::Option::None, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); + event!(parent: ::core::option::Option::None, Level::DEBUG, { foo = ?2, bar.baz = %78 }, "quux"); + event!(target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, foo = 3, bar.baz = 2, quux = false); + event!(target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, foo = 3, bar.baz = 3,); + event!(target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, "foo"); + event!(target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, "foo: {}", 3); + event!(target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, { foo = 3, bar.baz = 80 }, "quux"); + event!(target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}", true); + event!(target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); + event!(target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, { foo = 2, bar.baz = 78, }, "quux"); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] fn trace_root() { - trace!(parent: None, foo = ?3, bar.baz = %2, quux = false); - trace!(parent: None, foo = 3, bar.baz = 2, quux = false); - trace!(parent: None, foo = 3, bar.baz = 3,); - trace!(parent: None, "foo"); - trace!(parent: None, "foo: {}", 3); - trace!(parent: None, { foo = 3, bar.baz = 80 }, "quux"); - trace!(parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); - trace!(parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); - trace!(parent: None, { foo = 2, bar.baz = 78 }, "quux"); - trace!(parent: None, { foo = ?2, bar.baz = %78 }, "quux"); - trace!(target: "foo_events", parent: None, foo = 3, bar.baz = 2, quux = false); - trace!(target: "foo_events", parent: None, foo = 3, bar.baz = 3,); - trace!(target: "foo_events", parent: None, "foo"); - trace!(target: "foo_events", parent: None, "foo: {}", 3); - trace!(target: "foo_events", parent: None, { foo = 3, bar.baz = 80 }, "quux"); - trace!(target: "foo_events", parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); - trace!(target: "foo_events", parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); - trace!(target: "foo_events", parent: None, { foo = 2, bar.baz = 78, }, "quux"); + trace!(parent: ::core::option::Option::None, foo = ?3, bar.baz = %2, quux = false); + trace!(parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false); + trace!(parent: ::core::option::Option::None, foo = 3, bar.baz = 3,); + trace!(parent: ::core::option::Option::None, "foo"); + trace!(parent: ::core::option::Option::None, "foo: {}", 3); + trace!(parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux"); + trace!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); + trace!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); + trace!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 78 }, "quux"); + trace!(parent: ::core::option::Option::None, { foo = ?2, bar.baz = %78 }, "quux"); + trace!(target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false); + trace!(target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 3,); + trace!(target: "foo_events", parent: ::core::option::Option::None, "foo"); + trace!(target: "foo_events", parent: ::core::option::Option::None, "foo: {}", 3); + trace!(target: "foo_events", parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux"); + trace!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); + trace!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); + trace!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux"); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] fn debug_root() { - debug!(parent: None, foo = ?3, bar.baz = %2, quux = false); - debug!(parent: None, foo = 3, bar.baz = 2, quux = false); - debug!(parent: None, foo = 3, bar.baz = 3,); - debug!(parent: None, "foo"); - debug!(parent: None, "foo: {}", 3); - debug!(parent: None, { foo = 3, bar.baz = 80 }, "quux"); - debug!(parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); - debug!(parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); - debug!(parent: None, { foo = 2, bar.baz = 78 }, "quux"); - debug!(parent: None, { foo = ?2, bar.baz = %78 }, "quux"); - debug!(target: "foo_events", parent: None, foo = 3, bar.baz = 2, quux = false); - debug!(target: "foo_events", parent: None, foo = 3, bar.baz = 3,); - debug!(target: "foo_events", parent: None, "foo"); - debug!(target: "foo_events", parent: None, "foo: {}", 3); - debug!(target: "foo_events", parent: None, { foo = 3, bar.baz = 80 }, "quux"); - debug!(target: "foo_events", parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); - debug!(target: "foo_events", parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); - debug!(target: "foo_events", parent: None, { foo = 2, bar.baz = 78, }, "quux"); + debug!(parent: ::core::option::Option::None, foo = ?3, bar.baz = %2, quux = false); + debug!(parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false); + debug!(parent: ::core::option::Option::None, foo = 3, bar.baz = 3,); + debug!(parent: ::core::option::Option::None, "foo"); + debug!(parent: ::core::option::Option::None, "foo: {}", 3); + debug!(parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux"); + debug!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); + debug!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); + debug!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 78 }, "quux"); + debug!(parent: ::core::option::Option::None, { foo = ?2, bar.baz = %78 }, "quux"); + debug!(target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false); + debug!(target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 3,); + debug!(target: "foo_events", parent: ::core::option::Option::None, "foo"); + debug!(target: "foo_events", parent: ::core::option::Option::None, "foo: {}", 3); + debug!(target: "foo_events", parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux"); + debug!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); + debug!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); + debug!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux"); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] fn info_root() { - info!(parent: None, foo = ?3, bar.baz = %2, quux = false); - info!(parent: None, foo = 3, bar.baz = 2, quux = false); - info!(parent: None, foo = 3, bar.baz = 3,); - info!(parent: None, "foo"); - info!(parent: None, "foo: {}", 3); - info!(parent: None, { foo = 3, bar.baz = 80 }, "quux"); - info!(parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); - info!(parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); - info!(parent: None, { foo = 2, bar.baz = 78 }, "quux"); - info!(parent: None, { foo = ?2, bar.baz = %78 }, "quux"); - info!(target: "foo_events", parent: None, foo = 3, bar.baz = 2, quux = false); - info!(target: "foo_events", parent: None, foo = 3, bar.baz = 3,); - info!(target: "foo_events", parent: None, "foo"); - info!(target: "foo_events", parent: None, "foo: {}", 3); - info!(target: "foo_events", parent: None, { foo = 3, bar.baz = 80 }, "quux"); - info!(target: "foo_events", parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); - info!(target: "foo_events", parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); - info!(target: "foo_events", parent: None, { foo = 2, bar.baz = 78, }, "quux"); + info!(parent: ::core::option::Option::None, foo = ?3, bar.baz = %2, quux = false); + info!(parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false); + info!(parent: ::core::option::Option::None, foo = 3, bar.baz = 3,); + info!(parent: ::core::option::Option::None, "foo"); + info!(parent: ::core::option::Option::None, "foo: {}", 3); + info!(parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux"); + info!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); + info!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); + info!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 78 }, "quux"); + info!(parent: ::core::option::Option::None, { foo = ?2, bar.baz = %78 }, "quux"); + info!(target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false); + info!(target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 3,); + info!(target: "foo_events", parent: ::core::option::Option::None, "foo"); + info!(target: "foo_events", parent: ::core::option::Option::None, "foo: {}", 3); + info!(target: "foo_events", parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux"); + info!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); + info!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); + info!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux"); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] fn warn_root() { - warn!(parent: None, foo = ?3, bar.baz = %2, quux = false); - warn!(parent: None, foo = 3, bar.baz = 2, quux = false); - warn!(parent: None, foo = 3, bar.baz = 3,); - warn!(parent: None, "foo"); - warn!(parent: None, "foo: {}", 3); - warn!(parent: None, { foo = 3, bar.baz = 80 }, "quux"); - warn!(parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); - warn!(parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); - warn!(parent: None, { foo = 2, bar.baz = 78 }, "quux"); - warn!(parent: None, { foo = ?2, bar.baz = %78 }, "quux"); - warn!(target: "foo_events", parent: None, foo = 3, bar.baz = 2, quux = false); - warn!(target: "foo_events", parent: None, foo = 3, bar.baz = 3,); - warn!(target: "foo_events", parent: None, "foo"); - warn!(target: "foo_events", parent: None, "foo: {}", 3); - warn!(target: "foo_events", parent: None, { foo = 3, bar.baz = 80 }, "quux"); - warn!(target: "foo_events", parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); - warn!(target: "foo_events", parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); - warn!(target: "foo_events", parent: None, { foo = 2, bar.baz = 78, }, "quux"); + warn!(parent: ::core::option::Option::None, foo = ?3, bar.baz = %2, quux = false); + warn!(parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false); + warn!(parent: ::core::option::Option::None, foo = 3, bar.baz = 3,); + warn!(parent: ::core::option::Option::None, "foo"); + warn!(parent: ::core::option::Option::None, "foo: {}", 3); + warn!(parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux"); + warn!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); + warn!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); + warn!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 78 }, "quux"); + warn!(parent: ::core::option::Option::None, { foo = ?2, bar.baz = %78 }, "quux"); + warn!(target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false); + warn!(target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 3,); + warn!(target: "foo_events", parent: ::core::option::Option::None, "foo"); + warn!(target: "foo_events", parent: ::core::option::Option::None, "foo: {}", 3); + warn!(target: "foo_events", parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux"); + warn!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); + warn!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); + warn!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux"); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] #[test] fn error_root() { - error!(parent: None, foo = ?3, bar.baz = %2, quux = false); - error!(parent: None, foo = 3, bar.baz = 2, quux = false); - error!(parent: None, foo = 3, bar.baz = 3,); - error!(parent: None, "foo"); - error!(parent: None, "foo: {}", 3); - error!(parent: None, { foo = 3, bar.baz = 80 }, "quux"); - error!(parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); - error!(parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); - error!(parent: None, { foo = 2, bar.baz = 78 }, "quux"); - error!(parent: None, { foo = ?2, bar.baz = %78 }, "quux"); - error!(target: "foo_events", parent: None, foo = 3, bar.baz = 2, quux = false); - error!(target: "foo_events", parent: None, foo = 3, bar.baz = 3,); - error!(target: "foo_events", parent: None, "foo"); - error!(target: "foo_events", parent: None, "foo: {}", 3); - error!(target: "foo_events", parent: None, { foo = 3, bar.baz = 80 }, "quux"); - error!(target: "foo_events", parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); - error!(target: "foo_events", parent: None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); - error!(target: "foo_events", parent: None, { foo = 2, bar.baz = 78, }, "quux"); + error!(parent: ::core::option::Option::None, foo = ?3, bar.baz = %2, quux = false); + error!(parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false); + error!(parent: ::core::option::Option::None, foo = 3, bar.baz = 3,); + error!(parent: ::core::option::Option::None, "foo"); + error!(parent: ::core::option::Option::None, "foo: {}", 3); + error!(parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux"); + error!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); + error!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); + error!(parent: ::core::option::Option::None, { foo = 2, bar.baz = 78 }, "quux"); + error!(parent: ::core::option::Option::None, { foo = ?2, bar.baz = %78 }, "quux"); + error!(target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false); + error!(target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 3,); + error!(target: "foo_events", parent: ::core::option::Option::None, "foo"); + error!(target: "foo_events", parent: ::core::option::Option::None, "foo: {}", 3); + error!(target: "foo_events", parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux"); + error!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true); + error!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false); + error!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux"); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)] @@ -913,7 +917,7 @@ fn field_shorthand_only() { #[test] fn borrow_val_events() { // Reproduces https://github.com/tokio-rs/tracing/issues/954 - let mut foo = (String::new(), String::new()); + let mut foo = (::std::string::String::new(), ::std::string::String::new()); let zero = &mut foo.0; trace!(one = ?foo.1); debug!(one = ?foo.1); @@ -927,7 +931,7 @@ fn borrow_val_events() { #[test] fn borrow_val_spans() { // Reproduces https://github.com/tokio-rs/tracing/issues/954 - let mut foo = (String::new(), String::new()); + let mut foo = (::std::string::String::new(), ::std::string::String::new()); let zero = &mut foo.0; let _span = trace_span!("span", one = ?foo.1); let _span = debug_span!("span", one = ?foo.1); From ddb1b8a0dae94547d69268c63338782ded99bd7d Mon Sep 17 00:00:00 2001 From: David Barsky Date: Thu, 3 Aug 2023 18:38:14 -0400 Subject: [PATCH 12/34] chores: fix clippy lints (#2673) --- tracing-journald/src/socket.rs | 2 +- tracing-subscriber/src/fmt/time/mod.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tracing-journald/src/socket.rs b/tracing-journald/src/socket.rs index bba53d8658..6803bf34e0 100644 --- a/tracing-journald/src/socket.rs +++ b/tracing-journald/src/socket.rs @@ -68,7 +68,7 @@ pub fn send_one_fd_to>(socket: &UnixDatagram, fd: RawFd, path: P) msg.msg_control = unsafe { cmsg_buffer.buffer.as_mut_ptr() as _ }; msg.msg_controllen = unsafe { CMSG_SPACE(size_of::() as _) as _ }; - let mut cmsg: &mut cmsghdr = + let cmsg: &mut cmsghdr = unsafe { CMSG_FIRSTHDR(&msg).as_mut() }.expect("Control message buffer exhausted"); cmsg.cmsg_level = SOL_SOCKET; diff --git a/tracing-subscriber/src/fmt/time/mod.rs b/tracing-subscriber/src/fmt/time/mod.rs index 1d1bba2406..5ba6698194 100644 --- a/tracing-subscriber/src/fmt/time/mod.rs +++ b/tracing-subscriber/src/fmt/time/mod.rs @@ -52,7 +52,7 @@ pub trait FormatTime { /// # } /// ``` pub fn time() -> SystemTime { - SystemTime::default() + SystemTime } /// Returns a new `Uptime` timestamp provider. From 8e77a431fdc176c75319d6bf03b3acd7ed49b3f4 Mon Sep 17 00:00:00 2001 From: Yuta Yamaguchi Date: Tue, 8 Aug 2023 03:28:05 +0900 Subject: [PATCH 13/34] tracing: add tracing-cloudwatch to related cates in README (#2667) --- README.md | 2 ++ tracing/src/lib.rs | 2 ++ 2 files changed, 4 insertions(+) diff --git a/README.md b/README.md index cfe1be8a19..1a1858a1bb 100644 --- a/README.md +++ b/README.md @@ -401,6 +401,7 @@ are not maintained by the `tokio` project. These include: - [`tracing-logfmt`] provides a layer that formats events and spans into the logfmt format. - [`tracing-chrome`] provides a layer that exports trace data that can be viewed in `chrome://tracing`. - [`reqwest-tracing`] provides a middleware to trace [`reqwest`] HTTP requests. +- [`tracing-cloudwatch`] provides a layer that sends events to AWS CloudWatch Logs. (if you're the maintainer of a `tracing` ecosystem crate not in this list, please let us know!) @@ -443,6 +444,7 @@ please let us know!) [`tracing-chrome`]: https://crates.io/crates/tracing-chrome [`reqwest-tracing`]: https://crates.io/crates/reqwest-tracing [`reqwest`]: https://crates.io/crates/reqwest +[`tracing-cloudwatch`]: https://crates.io/crates/tracing-cloudwatch **Note:** that some of the ecosystem crates are currently unreleased and undergoing active development. They may be less stable than `tracing` and diff --git a/tracing/src/lib.rs b/tracing/src/lib.rs index 9bb8f46942..15e0ad98cb 100644 --- a/tracing/src/lib.rs +++ b/tracing/src/lib.rs @@ -747,6 +747,7 @@ //! - [`tracing-loki`] provides a layer for shipping logs to [Grafana Loki]. //! - [`tracing-logfmt`] provides a layer that formats events and spans into the logfmt format. //! - [`reqwest-tracing`] provides a middleware to trace [`reqwest`] HTTP requests. +//! - [`tracing-cloudwatch`] provides a layer that sends events to AWS CloudWatch Logs. //! //! If you're the maintainer of a `tracing` ecosystem crate not listed above, //! please let us know! We'd love to add your project to the list! @@ -787,6 +788,7 @@ //! [`tracing-logfmt`]: https://crates.io/crates/tracing-logfmt //! [`reqwest-tracing`]: https://crates.io/crates/reqwest-tracing //! [`reqwest`]: https://crates.io/crates/reqwest +//! [`tracing-cloudwatch`]: https://crates.io/crates/tracing-cloudwatch //! //! 
 //!     Note: Some of these ecosystem crates are currently

From 5952e36cf53155e91707437281870ada6129a66c Mon Sep 17 00:00:00 2001
From: Ana Hobden 
Date: Wed, 9 Aug 2023 11:52:16 -0700
Subject: [PATCH 14/34] documentation: Add article and talk by hoverbear
 (#2679)

---
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/README.md b/README.md
index 1a1858a1bb..ba4628a5a7 100644
--- a/README.md
+++ b/README.md
@@ -460,14 +460,17 @@ Tracing.
 * [Diagnostics with Tracing][tokio-blog-2019-08] on the Tokio blog, August 2019
 * [Production-Grade Logging in Rust Applications][production-logging-2020], November 2020
 * [Custom Logging in Rust using `tracing` and `tracing-subscriber`, part 1][custom-logging-part-1] and [part 2][custom-logging-part-2], October 2021
+* [Instrumenting Axum projects][detsys-blog-2023-08], August 2023
 
 [tokio-blog-2019-08]: https://tokio.rs/blog/2019-08-tracing/
+[detsys-blog-2023-08]: https://determinate.systems/posts/instrumenting-axum
 
 #### Talks
 
 * [Bay Area Rust Meetup talk and Q&A][bay-rust-2019-03], March 2019
 * [RustConf 2019 talk][rust-conf-2019-08-video] and [slides][rust-conf-2019-08-slides], August 2019
 * [Are we observable yet? @ RustyDays talk][rusty-days-2020-08-video] and [slides][rusty-days-2020-08-slides], August 2020
+* [Crabs with instruments!][tremorcon-2021-09], September 2021
 
 [bay-rust-2019-03]: https://www.youtube.com/watch?v=j_kXRg3zlec
 [rust-conf-2019-08-video]: https://www.youtube.com/watch?v=JjItsfqFIdo
@@ -477,6 +480,7 @@ Tracing.
 [production-logging-2020]: https://medium.com/better-programming/production-grade-logging-in-rust-applications-2c7fffd108a6
 [custom-logging-part-1]: https://burgers.io/custom-logging-in-rust-using-tracing
 [custom-logging-part-2]: https://burgers.io/custom-logging-in-rust-using-tracing-part-2
+[tremorcon-2021-09]: https://www.youtube.com/watch?v=ZC7fyqshun8
 
 Help us expand this list! If you've written or spoken about Tracing, or
 know of resources that aren't listed, please open a pull request adding them.

From 8cb22ff5057b01af6375db8039445e20ddadb24d Mon Sep 17 00:00:00 2001
From: Nikita Popov 
Date: Mon, 14 Aug 2023 19:08:45 +0200
Subject: [PATCH 15/34] core: ensure callsites in test have unique addresses
 (#2681)

The test relies on TEST_CALLSITE_1 and TEST_CALLSITE_2 to have
different addresses. However, as they are zero-sized types, this
is not guaranteed.

This fixes the test failure with LLVM 17 and certain optimization
options reported at https://github.com/rust-lang/rust/issues/114699.
---
 tracing-core/src/field.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/tracing-core/src/field.rs b/tracing-core/src/field.rs
index a134e0dc2f..2d6ec13cde 100644
--- a/tracing-core/src/field.rs
+++ b/tracing-core/src/field.rs
@@ -1102,8 +1102,9 @@ mod test {
     use crate::metadata::{Kind, Level, Metadata};
     use crate::stdlib::{borrow::ToOwned, string::String};
 
-    struct TestCallsite1;
-    static TEST_CALLSITE_1: TestCallsite1 = TestCallsite1;
+    // Make sure TEST_CALLSITE_* have non-zero size, so they can't be located at the same address.
+    struct TestCallsite1(u8);
+    static TEST_CALLSITE_1: TestCallsite1 = TestCallsite1(0);
     static TEST_META_1: Metadata<'static> = metadata! {
         name: "field_test1",
         target: module_path!(),
@@ -1123,8 +1124,8 @@ mod test {
         }
     }
 
-    struct TestCallsite2;
-    static TEST_CALLSITE_2: TestCallsite2 = TestCallsite2;
+    struct TestCallsite2(u8);
+    static TEST_CALLSITE_2: TestCallsite2 = TestCallsite2(0);
     static TEST_META_2: Metadata<'static> = metadata! {
         name: "field_test2",
         target: module_path!(),

From 2ee84b3c27bd95ddd84c23b0fae4204ee8b26073 Mon Sep 17 00:00:00 2001
From: Alexander Tesfamichael 
Date: Mon, 14 Aug 2023 19:09:18 +0200
Subject: [PATCH 16/34] docs(field): remove duplicate wording (#2674)

---
 tracing-core/src/field.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tracing-core/src/field.rs b/tracing-core/src/field.rs
index 2d6ec13cde..61e26f9534 100644
--- a/tracing-core/src/field.rs
+++ b/tracing-core/src/field.rs
@@ -1,8 +1,8 @@
 //! `Span` and `Event` key-value data.
 //!
-//! Spans and events may be annotated with key-value data, referred to as known
-//! as _fields_. These fields consist of a mapping from a key (corresponding to
-//! a `&str` but represented internally as an array index) to a [`Value`].
+//! Spans and events may be annotated with key-value data, known as _fields_.
+//! These fields consist of a mapping from a key (corresponding to a `&str` but
+//! represented internally as an array index) to a [`Value`].
 //!
 //! # `Value`s and `Subscriber`s
 //!

From 1fa24df0a562c0ea78ce7bcc455d8eb930b1d795 Mon Sep 17 00:00:00 2001
From: Jonathan Woollett-Light 
Date: Mon, 14 Aug 2023 18:11:28 +0100
Subject: [PATCH 17/34] docs: Add `clippy-tracing` to related crates (#2628)

## Motivation

Sharing tooling.

## Solution

Adds `clippy-tracing` to related crates.

Closes #2627
---
 README.md          | 2 ++
 tracing/src/lib.rs | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/README.md b/README.md
index ba4628a5a7..2656fe04a1 100644
--- a/README.md
+++ b/README.md
@@ -402,6 +402,7 @@ are not maintained by the `tokio` project. These include:
 - [`tracing-chrome`] provides a layer that exports trace data that can be viewed in `chrome://tracing`.
 - [`reqwest-tracing`] provides a middleware to trace [`reqwest`] HTTP requests.
 - [`tracing-cloudwatch`] provides a layer that sends events to AWS CloudWatch Logs.
+- [`clippy-tracing`] provides a tool to add, remove and check for `tracing::instrument`.
 
 (if you're the maintainer of a `tracing` ecosystem crate not in this list,
 please let us know!)
@@ -445,6 +446,7 @@ please let us know!)
 [`reqwest-tracing`]: https://crates.io/crates/reqwest-tracing
 [`reqwest`]: https://crates.io/crates/reqwest
 [`tracing-cloudwatch`]: https://crates.io/crates/tracing-cloudwatch
+[`clippy-tracing`]: https://crates.io/crates/clippy-tracing
 
 **Note:** that some of the ecosystem crates are currently unreleased and
 undergoing active development. They may be less stable than `tracing` and
diff --git a/tracing/src/lib.rs b/tracing/src/lib.rs
index 15e0ad98cb..53ca1253ce 100644
--- a/tracing/src/lib.rs
+++ b/tracing/src/lib.rs
@@ -748,6 +748,7 @@
 //!  - [`tracing-logfmt`] provides a layer that formats events and spans into the logfmt format.
 //!  - [`reqwest-tracing`] provides a middleware to trace [`reqwest`] HTTP requests.
 //!  - [`tracing-cloudwatch`] provides a layer that sends events to AWS CloudWatch Logs.
+//!  - [`clippy-tracing`] provides a tool to add, remove and check for `tracing::instrument`.
 //!
 //! If you're the maintainer of a `tracing` ecosystem crate not listed above,
 //! please let us know! We'd love to add your project to the list!
@@ -789,6 +790,7 @@
 //! [`reqwest-tracing`]: https://crates.io/crates/reqwest-tracing
 //! [`reqwest`]: https://crates.io/crates/reqwest
 //! [`tracing-cloudwatch`]: https://crates.io/crates/tracing-cloudwatch
+//! [`clippy-tracing`]: https://crates.io/crates/clippy-tracing
 //!
 //! 
 //!     Note: Some of these ecosystem crates are currently

From 5da779920894122438e0544fe97d22ca37721e43 Mon Sep 17 00:00:00 2001
From: Harry Barber <106155934+hlbarber@users.noreply.github.com>
Date: Thu, 17 Aug 2023 17:36:34 +0100
Subject: [PATCH 18/34] tracing: fix `wasm_bindgen_test` macros (#2675)

## Motivation

Tests involving `wasm_bindgen_test` currently fail:

https://github.com/tokio-rs/tracing/actions/runs/5756318807/job/15605512576

## Solution

- [x] Use `extern crate wasm_bindgen_test` to side-step `no_implicit_prelude`.
- [x] https://github.com/rustwasm/wasm-bindgen/pull/3549
- [ ] Consume the release `wasm_bindgen_test` containing said change.
---
 tracing/tests/macros.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tracing/tests/macros.rs b/tracing/tests/macros.rs
index 423984da27..6d9a333b68 100644
--- a/tracing/tests/macros.rs
+++ b/tracing/tests/macros.rs
@@ -2,6 +2,12 @@
 // We call all macros in this module with `no_implicit_prelude` to ensure they do not depend on the standard prelude.
 #![no_implicit_prelude]
 extern crate tracing;
+#[cfg(target_arch = "wasm32")]
+extern crate wasm_bindgen_test;
+
+// TODO: remove this once https://github.com/tokio-rs/tracing/pull/2675#issuecomment-1667628907 is resolved
+#[cfg(target_arch = "wasm32")]
+use ::core::option::Option::None;
 
 use tracing::{
     callsite, debug, debug_span, enabled, error, error_span, event, event_enabled, info, info_span,

From bbc87fea2751792d5141b755747f83aa6062fdbb Mon Sep 17 00:00:00 2001
From: "David M. Lary" 
Date: Thu, 17 Aug 2023 11:56:29 -0500
Subject: [PATCH 19/34] subscriber: support `NO_COLOR` in `fmt::Layer` (#2647)

It's necessary at times to be able to disable ANSI color output for
rust utilities using `tracing`.  The informal standard for this is the
`NO_COLOR` environment variable described here: https://no-color.org/

Further details/discussion in #2388

This commit updates `fmt::Layer` to check the `NO_COLOR`
environment variable when determining whether ANSI color output is
enabled by default. As described in the spec, any non-empty value set
for `NO_COLOR` will cause ANSI color support to be disabled by default.

If the user manually overrides ANSI color support, such as by calling
`with_ansi(true)`, this will still enable ANSI colors, even if
`NO_COLOR` is set. The `NO_COLOR` env var only effects the default
behavior.

Fixes #2388
---
 tracing-subscriber/src/fmt/fmt_layer.rs | 108 ++++++++++++++++++++++--
 1 file changed, 102 insertions(+), 6 deletions(-)

diff --git a/tracing-subscriber/src/fmt/fmt_layer.rs b/tracing-subscriber/src/fmt/fmt_layer.rs
index e2f7cc8f98..d3cb8c1ed5 100644
--- a/tracing-subscriber/src/fmt/fmt_layer.rs
+++ b/tracing-subscriber/src/fmt/fmt_layer.rs
@@ -5,7 +5,9 @@ use crate::{
     registry::{self, LookupSpan, SpanRef},
 };
 use format::{FmtSpan, TimingDisplay};
-use std::{any::TypeId, cell::RefCell, fmt, io, marker::PhantomData, ops::Deref, time::Instant};
+use std::{
+    any::TypeId, cell::RefCell, env, fmt, io, marker::PhantomData, ops::Deref, time::Instant,
+};
 use tracing_core::{
     field,
     span::{Attributes, Current, Id, Record},
@@ -276,6 +278,15 @@ impl Layer {
     /// Sets whether or not the formatter emits ANSI terminal escape codes
     /// for colors and other text formatting.
     ///
+    /// When the "ansi" crate feature flag is enabled, ANSI colors are enabled
+    /// by default unless the [`NO_COLOR`] environment variable is set to
+    /// a non-empty value.  If the [`NO_COLOR`] environment variable is set to
+    /// any non-empty value, then ANSI colors will be suppressed by default.
+    /// The [`with_ansi`] and [`set_ansi`] methods can be used to forcibly
+    /// enable ANSI colors, overriding any [`NO_COLOR`] environment variable.
+    ///
+    /// [`NO_COLOR`]: https://no-color.org/
+    ///
     /// Enabling ANSI escapes (calling `with_ansi(true)`) requires the "ansi"
     /// crate feature flag. Calling `with_ansi(true)` without the "ansi"
     /// feature flag enabled will panic if debug assertions are enabled, or
@@ -288,6 +299,9 @@ impl Layer {
     /// ANSI escape codes can ensure that they are not used, regardless of
     /// whether or not other crates in the dependency graph enable the "ansi"
     /// feature flag.
+    ///
+    /// [`with_ansi`]: Subscriber::with_ansi
+    /// [`set_ansi`]: Subscriber::set_ansi
     pub fn with_ansi(self, ansi: bool) -> Self {
         #[cfg(not(feature = "ansi"))]
         if ansi {
@@ -311,10 +325,10 @@ impl Layer {
     /// By default, `fmt::Layer` will write any `FormatEvent`-internal errors to
     /// the writer. These errors are unlikely and will only occur if there is a
     /// bug in the `FormatEvent` implementation or its dependencies.
-    /// 
+    ///
     /// If writing to the writer fails, the error message is printed to stderr
     /// as a fallback.
-    /// 
+    ///
     /// [`FormatEvent`]: crate::fmt::FormatEvent
     pub fn log_internal_errors(self, log_internal_errors: bool) -> Self {
         Self {
@@ -677,12 +691,16 @@ impl Layer {
 
 impl Default for Layer {
     fn default() -> Self {
+        // only enable ANSI when the feature is enabled, and the NO_COLOR
+        // environment variable is unset or empty.
+        let ansi = cfg!(feature = "ansi") && env::var("NO_COLOR").map_or(true, |v| v.is_empty());
+
         Layer {
             fmt_fields: format::DefaultFields::default(),
             fmt_event: format::Format::default(),
             fmt_span: format::FmtSpanConfig::default(),
             make_writer: io::stdout,
-            is_ansi: cfg!(feature = "ansi"),
+            is_ansi: ansi,
             log_internal_errors: false,
             _inner: PhantomData,
         }
@@ -1288,8 +1306,17 @@ mod test {
         let actual = sanitize_timings(make_writer.get_string());
 
         // Only assert the start because the line number and callsite may change.
-        let expected = concat!("Unable to format the following event. Name: event ", file!(), ":");
-        assert!(actual.as_str().starts_with(expected), "\nactual = {}\nshould start with expected = {}\n", actual, expected);
+        let expected = concat!(
+            "Unable to format the following event. Name: event ",
+            file!(),
+            ":"
+        );
+        assert!(
+            actual.as_str().starts_with(expected),
+            "\nactual = {}\nshould start with expected = {}\n",
+            actual,
+            expected
+        );
     }
 
     #[test]
@@ -1491,4 +1518,73 @@ mod test {
             actual.as_str()
         );
     }
+
+    // Because we need to modify an environment variable for these test cases,
+    // we do them all in a single test.
+    #[cfg(feature = "ansi")]
+    #[test]
+    fn layer_no_color() {
+        const NO_COLOR: &str = "NO_COLOR";
+
+        // Restores the previous value of the `NO_COLOR` env variable when
+        // dropped.
+        //
+        // This is done in a `Drop` implementation, rather than just resetting
+        // the value at the end of the test, so that the previous value is
+        // restored even if the test panics.
+        struct RestoreEnvVar(Result);
+        impl Drop for RestoreEnvVar {
+            fn drop(&mut self) {
+                match self.0 {
+                    Ok(ref var) => env::set_var(NO_COLOR, var),
+                    Err(_) => env::remove_var(NO_COLOR),
+                }
+            }
+        }
+
+        let _saved_no_color = RestoreEnvVar(env::var(NO_COLOR));
+
+        let cases: Vec<(Option<&str>, bool)> = vec![
+            (Some("0"), false),   // any non-empty value disables ansi
+            (Some("off"), false), // any non-empty value disables ansi
+            (Some("1"), false),
+            (Some(""), true), // empty value does not disable ansi
+            (None, true),
+        ];
+
+        for (var, ansi) in cases {
+            if let Some(value) = var {
+                env::set_var(NO_COLOR, value);
+            } else {
+                env::remove_var(NO_COLOR);
+            }
+
+            let layer: Layer<()> = fmt::Layer::default();
+            assert_eq!(
+                layer.is_ansi, ansi,
+                "NO_COLOR={:?}; Layer::default().is_ansi should be {}",
+                var, ansi
+            );
+
+            // with_ansi should override any `NO_COLOR` value
+            let layer: Layer<()> = fmt::Layer::default().with_ansi(true);
+            assert!(
+                layer.is_ansi,
+                "NO_COLOR={:?}; Layer::default().with_ansi(true).is_ansi should be true",
+                var
+            );
+
+            // set_ansi should override any `NO_COLOR` value
+            let mut layer: Layer<()> = fmt::Layer::default();
+            layer.set_ansi(true);
+            assert!(
+                layer.is_ansi,
+                "NO_COLOR={:?}; layer.set_ansi(true); layer.is_ansi should be true",
+                var
+            );
+        }
+
+        // dropping `_saved_no_color` will restore the previous value of
+        // `NO_COLOR`.
+    }
 }

From 95b1d5ce74f0bd3305a8e25ad79edee2326fda6b Mon Sep 17 00:00:00 2001
From: Eliza Weisman 
Date: Tue, 29 Aug 2023 11:16:59 -0700
Subject: [PATCH 20/34] chore: fix new warnings in Rust 1.72.0 (#2700)

This branch fixes a handful of new warnings which have shown up after
updating to Rust 1.72.0.

This includes:

* `clippy::redundant_closure_call` in macros --- allowed because the
  macro sometimes calls a function that isn't a closure, and the closure
  is just used in the case where it's not a function.
* Unnecessary uses of `#` in raw string literals that don't contain `"`
  characters.
* Dead code warnings with specific feature flag combinations in
  `tracing-subscriber`.

In addition, I've fixed a broken RustDoc link that was making the
Netlify build sad.
---
 netlify.toml                                  |  1 +
 tracing-core/src/field.rs                     |  8 +++++++
 tracing-subscriber/src/field/mod.rs           |  3 +--
 tracing-subscriber/src/filter/directive.rs    |  5 ++--
 .../src/filter/env/directive.rs               | 23 ++++++++++++-------
 tracing-subscriber/src/fmt/format/mod.rs      | 13 ++++++++---
 tracing-subscriber/src/fmt/mod.rs             | 11 +++++----
 tracing-subscriber/src/fmt/writer.rs          |  9 ++++----
 tracing-subscriber/src/registry/mod.rs        |  6 ++---
 9 files changed, 51 insertions(+), 28 deletions(-)

diff --git a/netlify.toml b/netlify.toml
index 6e3beff1a6..2437d8c3b9 100644
--- a/netlify.toml
+++ b/netlify.toml
@@ -8,6 +8,7 @@
 [build.environment]
   RUSTDOCFLAGS="""
     -D warnings \
+    --force-warn rustdoc::redundant-explicit-links \
     --force-warn renamed-and-removed-lints \
     --cfg docsrs \
     --cfg tracing_unstable
diff --git a/tracing-core/src/field.rs b/tracing-core/src/field.rs
index 61e26f9534..2a11a7ee2d 100644
--- a/tracing-core/src/field.rs
+++ b/tracing-core/src/field.rs
@@ -470,6 +470,10 @@ macro_rules! impl_one_value {
         impl $crate::sealed::Sealed for $value_ty {}
         impl $crate::field::Value for $value_ty {
             fn record(&self, key: &$crate::field::Field, visitor: &mut dyn $crate::field::Visit) {
+                // `op` is always a function; the closure is used because
+                // sometimes there isn't a real function corresponding to that
+                // operation. the clippy warning is not that useful here.
+                #[allow(clippy::redundant_closure_call)]
                 visitor.$record(key, $op(*self))
             }
         }
@@ -485,6 +489,10 @@ macro_rules! impl_one_value {
         impl $crate::sealed::Sealed for ty_to_nonzero!($value_ty) {}
         impl $crate::field::Value for ty_to_nonzero!($value_ty) {
             fn record(&self, key: &$crate::field::Field, visitor: &mut dyn $crate::field::Visit) {
+                // `op` is always a function; the closure is used because
+                // sometimes there isn't a real function corresponding to that
+                // operation. the clippy warning is not that useful here.
+                #[allow(clippy::redundant_closure_call)]
                 visitor.$record(key, $op(self.get()))
             }
         }
diff --git a/tracing-subscriber/src/field/mod.rs b/tracing-subscriber/src/field/mod.rs
index 5dfddb3626..03b9146ba6 100644
--- a/tracing-subscriber/src/field/mod.rs
+++ b/tracing-subscriber/src/field/mod.rs
@@ -55,7 +55,7 @@ pub trait VisitOutput: Visit {
 /// Extension trait implemented by types which can be recorded by a [visitor].
 ///
 /// This allows writing code that is generic over `tracing_core`'s
-/// [`span::Attributes`][attr], [`span::Record`][rec], and [`Event`][event]
+/// [`span::Attributes`][attr], [`span::Record`][rec], and [`Event`]
 /// types. These types all provide inherent `record` methods that allow a
 /// visitor to record their fields, but there is no common trait representing this.
 ///
@@ -85,7 +85,6 @@ pub trait VisitOutput: Visit {
 /// [visitor]: tracing_core::field::Visit
 /// [attr]: tracing_core::span::Attributes
 /// [rec]: tracing_core::span::Record
-/// [event]: tracing_core::event::Event
 pub trait RecordFields: crate::sealed::Sealed {
     /// Record all the fields in `self` with the provided `visitor`.
     fn record(&self, visitor: &mut dyn Visit);
diff --git a/tracing-subscriber/src/filter/directive.rs b/tracing-subscriber/src/filter/directive.rs
index 2ae3f0f24a..9ee2ce5ad0 100644
--- a/tracing-subscriber/src/filter/directive.rs
+++ b/tracing-subscriber/src/filter/directive.rs
@@ -49,7 +49,8 @@ enum ParseErrorKind {
 // === impl DirectiveSet ===
 
 impl DirectiveSet {
-    #[cfg(feature = "env-filter")]
+    // this is only used by `env-filter`.
+    #[cfg(all(feature = "std", feature = "env-filter"))]
     pub(crate) fn is_empty(&self) -> bool {
         self.directives.is_empty()
     }
@@ -397,7 +398,7 @@ impl FromStr for StaticDirective {
 // === impl ParseError ===
 
 impl ParseError {
-    #[cfg(feature = "env-filter")]
+    #[cfg(all(feature = "std", feature = "env-filter"))]
     pub(crate) fn new() -> Self {
         ParseError {
             kind: ParseErrorKind::Other(None),
diff --git a/tracing-subscriber/src/filter/env/directive.rs b/tracing-subscriber/src/filter/env/directive.rs
index f062e6ef93..d095065f88 100644
--- a/tracing-subscriber/src/filter/env/directive.rs
+++ b/tracing-subscriber/src/filter/env/directive.rs
@@ -120,8 +120,9 @@ impl Directive {
     }
 
     pub(super) fn parse(from: &str, regex: bool) -> Result {
-        static DIRECTIVE_RE: Lazy = Lazy::new(|| Regex::new(
-            r"(?x)
+        static DIRECTIVE_RE: Lazy = Lazy::new(|| {
+            Regex::new(
+                r"(?x)
             ^(?P(?i:trace|debug|info|warn|error|off|[0-5]))$ |
                 #                 ^^^.
                 #                     `note: we match log level names case-insensitively
@@ -135,15 +136,18 @@ impl Directive {
                     #              `note: we match log level names case-insensitively
             )?
             $
-            "
-        )
-        .unwrap());
+            ",
+            )
+            .unwrap()
+        });
         static SPAN_PART_RE: Lazy =
-            Lazy::new(|| Regex::new(r#"(?P[^\]\{]+)?(?:\{(?P[^\}]*)\})?"#).unwrap());
+            Lazy::new(|| Regex::new(r"(?P[^\]\{]+)?(?:\{(?P[^\}]*)\})?").unwrap());
         static FIELD_FILTER_RE: Lazy =
             // TODO(eliza): this doesn't _currently_ handle value matchers that include comma
             // characters. We should fix that.
-            Lazy::new(|| Regex::new(r#"(?x)
+            Lazy::new(|| {
+                Regex::new(
+                    r"(?x)
                 (
                     # field name
                     [[:word:]][[[:word:]]\.]*
@@ -152,7 +156,10 @@ impl Directive {
                 )
                 # trailing comma or EOS
                 (?:,\s?|$)
-            "#).unwrap());
+            ",
+                )
+                .unwrap()
+            });
 
         let caps = DIRECTIVE_RE.captures(from).ok_or_else(ParseError::new)?;
 
diff --git a/tracing-subscriber/src/fmt/format/mod.rs b/tracing-subscriber/src/fmt/format/mod.rs
index fa22c78ec8..ee56c5c2d1 100644
--- a/tracing-subscriber/src/fmt/format/mod.rs
+++ b/tracing-subscriber/src/fmt/format/mod.rs
@@ -326,8 +326,10 @@ pub struct FieldFnVisitor<'a, F> {
 /// Marker for [`Format`] that indicates that the compact log format should be used.
 ///
 /// The compact format includes fields from all currently entered spans, after
-/// the event's fields. Span names are listed in order before fields are
-/// displayed.
+/// the event's fields. Span fields are ordered (but not grouped) by
+/// span, and span names are  not shown. A more compact representation of the
+/// event's [`Level`] is used, and additional information—such as the event's
+/// target—is disabled by default.
 ///
 /// # Example Output
 ///
@@ -1086,7 +1088,12 @@ where
 
         let mut needs_space = false;
         if self.display_target {
-            write!(writer, "{}{}", dimmed.paint(meta.target()), dimmed.paint(":"))?;
+            write!(
+                writer,
+                "{}{}",
+                dimmed.paint(meta.target()),
+                dimmed.paint(":")
+            )?;
             needs_space = true;
         }
 
diff --git a/tracing-subscriber/src/fmt/mod.rs b/tracing-subscriber/src/fmt/mod.rs
index cfe4704758..163b56da3f 100644
--- a/tracing-subscriber/src/fmt/mod.rs
+++ b/tracing-subscriber/src/fmt/mod.rs
@@ -762,7 +762,7 @@ where
 
     /// Sets the subscriber being built to use a JSON formatter.
     ///
-    /// See [`format::Json`][super::fmt::format::Json]
+    /// See [`format::Json`] for details.
     #[cfg(feature = "json")]
     #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
     pub fn json(
@@ -783,7 +783,7 @@ where
 impl SubscriberBuilder, F, W> {
     /// Sets the json subscriber being built to flatten event metadata.
     ///
-    /// See [`format::Json`][super::fmt::format::Json]
+    /// See [`format::Json`] for details.
     pub fn flatten_event(
         self,
         flatten_event: bool,
@@ -797,7 +797,7 @@ impl SubscriberBuilder SubscriberBuilder MutexGuard<'_, Vec> {
             self.buf.lock().unwrap()
diff --git a/tracing-subscriber/src/fmt/writer.rs b/tracing-subscriber/src/fmt/writer.rs
index 2b9f9e973e..bbc1c4a298 100644
--- a/tracing-subscriber/src/fmt/writer.rs
+++ b/tracing-subscriber/src/fmt/writer.rs
@@ -16,7 +16,7 @@ use tracing_core::Metadata;
 /// This trait is already implemented for function pointers and
 /// immutably-borrowing closures that return an instance of [`io::Write`], such
 /// as [`io::stdout`] and [`io::stderr`]. Additionally, it is implemented for
-/// [`std::sync::Mutex`][mutex] when the type inside the mutex implements
+/// [`std::sync::Mutex`] when the type inside the mutex implements
 /// [`io::Write`].
 ///
 /// # Examples
@@ -66,7 +66,7 @@ use tracing_core::Metadata;
 /// ```
 ///
 /// A single instance of a type implementing [`io::Write`] may be used as a
-/// `MakeWriter` by wrapping it in a [`Mutex`][mutex]. For example, we could
+/// `MakeWriter` by wrapping it in a [`Mutex`]. For example, we could
 /// write to a file like so:
 ///
 /// ```
@@ -88,7 +88,6 @@ use tracing_core::Metadata;
 /// [`Event`]: tracing_core::event::Event
 /// [`io::stdout`]: std::io::stdout()
 /// [`io::stderr`]: std::io::stderr()
-/// [mutex]: std::sync::Mutex
 /// [`MakeWriter::make_writer_for`]: MakeWriter::make_writer_for
 /// [`Metadata`]: tracing_core::Metadata
 /// [levels]: tracing_core::Level
@@ -325,7 +324,7 @@ pub trait MakeWriterExt<'a>: MakeWriter<'a> {
 
     /// Wraps `self` with a predicate that takes a span or event's [`Metadata`]
     /// and returns a `bool`. The returned [`MakeWriter`]'s
-    /// [`MakeWriter::make_writer_for`][mwf] method will check the predicate to
+    /// [`MakeWriter::make_writer_for`] method will check the predicate to
     /// determine if  a writer should be produced for a given span or event.
     ///
     /// If the predicate returns `false`, the wrapped [`MakeWriter`]'s
@@ -544,7 +543,7 @@ pub struct BoxMakeWriter {
     name: &'static str,
 }
 
-/// A [writer] that is one of two types implementing [`io::Write`][writer].
+/// A [writer] that is one of two types implementing [`io::Write`].
 ///
 /// This may be used by [`MakeWriter`] implementations that may conditionally
 /// return one of two writers.
diff --git a/tracing-subscriber/src/registry/mod.rs b/tracing-subscriber/src/registry/mod.rs
index 38af53e8ad..1617f5ce4f 100644
--- a/tracing-subscriber/src/registry/mod.rs
+++ b/tracing-subscriber/src/registry/mod.rs
@@ -200,11 +200,9 @@ pub trait SpanData<'a> {
 
 /// A reference to [span data] and the associated [registry].
 ///
-/// This type implements all the same methods as [`SpanData`][span data], and
-/// provides additional methods for querying the registry based on values from
-/// the span.
+/// This type implements all the same methods as [`SpanData`], and provides
+/// additional methods for querying the registry based on values from the span.
 ///
-/// [span data]: SpanData
 /// [registry]: LookupSpan
 #[derive(Debug)]
 pub struct SpanRef<'a, R: LookupSpan<'a>> {

From 316c5a150e6e531ba24b722b4e17defbd6fd4214 Mon Sep 17 00:00:00 2001
From: Michael Wigard 
Date: Tue, 5 Sep 2023 19:18:40 +0200
Subject: [PATCH 21/34] attributes: fix instrument with "log" feature (#2599)

## Motivation

The instrument macro currently doesn't work with the "log" crate
feature: #2585

## Solution

Change the generated code to create a span if either
`tracing::if_log_enabled!` or `tracing::level_enabled!`. I'm not sure
how to add a test for this or if this is the best solution.

Fixes #2585
---
 tracing-attributes/src/expand.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tracing-attributes/src/expand.rs b/tracing-attributes/src/expand.rs
index eb7be8f47e..01b25f84aa 100644
--- a/tracing-attributes/src/expand.rs
+++ b/tracing-attributes/src/expand.rs
@@ -343,7 +343,7 @@ fn gen_block(
         // regression in case the level is enabled.
         let __tracing_attr_span;
         let __tracing_attr_guard;
-        if tracing::level_enabled!(#level) {
+        if tracing::level_enabled!(#level) || tracing::if_log_enabled!(#level, {true} else {false}) {
             __tracing_attr_span = #span;
             #follows_from
             __tracing_attr_guard = __tracing_attr_span.enter();

From 7d63c84468a21a7192dc16d1018c740bf3996d43 Mon Sep 17 00:00:00 2001
From: C L Eckhardt <29362105+CLEckhardt@users.noreply.github.com>
Date: Tue, 5 Sep 2023 12:20:06 -0500
Subject: [PATCH 22/34] appender: clarify file appender docs (#2689)

## Motivation

There are a few errors in the file appender docs - this fixes them.

It also wasn't clear/apparent to me that you can create a non-rolling
file appender with the `rolling` module - this calls that out more
clearly.

## Solution

Updates to docs.
---
 tracing-appender/src/lib.rs     | 26 ++++++++++++++++++++------
 tracing-appender/src/rolling.rs | 10 +++++-----
 2 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/tracing-appender/src/lib.rs b/tracing-appender/src/lib.rs
index 25279fb0ec..9fe789e50a 100644
--- a/tracing-appender/src/lib.rs
+++ b/tracing-appender/src/lib.rs
@@ -26,20 +26,34 @@
 //!  - Using a combination of [`NonBlocking`][non_blocking] and [`RollingFileAppender`][rolling_struct] to allow writes to a log file
 //! without blocking.
 //!
-//! ## Rolling File Appender
+//! ## File Appender
+//!
+//! The [`rolling` module][rolling] provides functions to create rolling and non-rolling file
+//! appenders.
+//!
+//! Rolling file appender rotation options are [`Rotation::MINUTELY`](rolling::Rotation::MINUTELY),
+//! [`Rotation::HOURLY`](rolling::Rotation::HOURLY), and
+//! [`Rotation::DAILY`](rolling::Rotation::DAILY).
+//!
+//! To create a non-rolling file appender, use
+//! [`tracing_appender::rolling::never(/*...*/)`](rolling::never) or
+//! [`Rotation::NEVER`](rolling::Rotation::NEVER).
+//!
+//! The following example creates an hourly rotating file appender that writes to
+//! `/some/directory/prefix.log.YYYY-MM-DD-HH`:
 //!
 //! ```rust
 //! # fn docs() {
 //! let file_appender = tracing_appender::rolling::hourly("/some/directory", "prefix.log");
 //! # }
 //! ```
-//! This creates an hourly rotating file appender that writes to `/some/directory/prefix.log.YYYY-MM-DD-HH`.
-//! [`Rotation::DAILY`](rolling::Rotation::DAILY) and [`Rotation::NEVER`](rolling::Rotation::NEVER) are the other available options.
 //!
-//! The file appender implements [`std::io::Write`][write]. To be used with [`tracing_subscriber::FmtSubscriber`][fmt_subscriber],
-//! it must be combined with a [`MakeWriter`][make_writer] implementation to be able to record tracing spans/event.
+//! The file appender implements [`std::io::Write`][write]. To be used with
+//! [`tracing_subscriber::FmtSubscriber`][fmt_subscriber], it must be combined with a
+//! [`MakeWriter`][make_writer] implementation to be able to record tracing spans/event.
 //!
-//! The [`rolling` module][rolling]'s documentation provides more detail on how to use this file appender.
+//! See the [`rolling` module][rolling]'s documentation for more detail on how to use this file
+//! appender.
 //!
 //! ## Non-Blocking Writer
 //!
diff --git a/tracing-appender/src/rolling.rs b/tracing-appender/src/rolling.rs
index 15ae35ba06..cce6139871 100644
--- a/tracing-appender/src/rolling.rs
+++ b/tracing-appender/src/rolling.rs
@@ -264,7 +264,7 @@ impl fmt::Debug for RollingFileAppender {
     }
 }
 
-/// Creates a minutely, rolling file appender. This will rotate the log file once per minute.
+/// Creates a minutely-rotating file appender. This will rotate the log file once per minute.
 ///
 /// The appender returned by `rolling::minutely` can be used with `non_blocking` to create
 /// a non-blocking, minutely file appender.
@@ -299,7 +299,7 @@ pub fn minutely(
     RollingFileAppender::new(Rotation::MINUTELY, directory, file_name_prefix)
 }
 
-/// Creates an hourly, rolling file appender.
+/// Creates an hourly-rotating file appender.
 ///
 /// The appender returned by `rolling::hourly` can be used with `non_blocking` to create
 /// a non-blocking, hourly file appender.
@@ -334,7 +334,7 @@ pub fn hourly(
     RollingFileAppender::new(Rotation::HOURLY, directory, file_name_prefix)
 }
 
-/// Creates a file appender that rotates daily.
+/// Creates a daily-rotating file appender.
 ///
 /// The appender returned by `rolling::daily` can be used with `non_blocking` to create
 /// a non-blocking, daily file appender.
@@ -370,13 +370,13 @@ pub fn daily(
     RollingFileAppender::new(Rotation::DAILY, directory, file_name_prefix)
 }
 
-/// Creates a non-rolling, file appender
+/// Creates a non-rolling file appender.
 ///
 /// The appender returned by `rolling::never` can be used with `non_blocking` to create
 /// a non-blocking, non-rotating appender.
 ///
 /// The location of the log file will be specified the `directory` passed in.
-/// `file_name` specifies the prefix of the log file. No date or time is appended.
+/// `file_name` specifies the complete name of the log file (no date or time is appended).
 ///
 /// # Examples
 ///

From e4bb09383038ac8eb61b27fba2b86abb9b540329 Mon Sep 17 00:00:00 2001
From: Gabi 
Date: Tue, 5 Sep 2023 14:26:03 -0300
Subject: [PATCH 23/34] flame: fix folded formatting (#2710)

## Motivation

The `.folded` format expects a `;`-separated list of the stack function,
optionally followed up by a sample count.

The implementation before this commit added a blank space after each `;`
which made parsers, such as `inferno-flamegraph` mis-interpret the data.

Furthermore, normally one wouldn't expect the filename and line-number
in such stack trace.

## Solution

Remove white-space between `;` for the generated file and remove
filename and line-number by default.
---
 tracing-flame/src/lib.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tracing-flame/src/lib.rs b/tracing-flame/src/lib.rs
index 5805850555..a4731dd154 100644
--- a/tracing-flame/src/lib.rs
+++ b/tracing-flame/src/lib.rs
@@ -233,7 +233,7 @@ impl Default for Config {
             empty_samples: true,
             threads_collapsed: false,
             module_path: true,
-            file_and_line: true,
+            file_and_line: false,
         }
     }
 }
@@ -404,7 +404,7 @@ where
 
         if let Some(second) = first.parent() {
             for parent in second.scope().from_root() {
-                stack += "; ";
+                stack += ";";
                 write(&mut stack, parent, &self.config)
                     .expect("expected: write to String never fails");
             }
@@ -446,7 +446,7 @@ where
         }
 
         for parent in first.scope().from_root() {
-            stack += "; ";
+            stack += ";";
             expect!(
                 write(&mut stack, parent, &self.config),
                 "expected: write to String never fails"

From b658b1f5aae67a0dcfad3dd9c221c5ca3366cdd5 Mon Sep 17 00:00:00 2001
From: Kornel 
Date: Tue, 5 Sep 2023 18:37:53 +0100
Subject: [PATCH 24/34] attributes: generate less dead code for async block
 return type hint (#2709)

## Motivation

`#[tracing::instrument]` uses `unreachable!()` macro which needlessly
expands to panicking and formatting code. It only needs any `!` type.

## Solution

`loop {}` works just as well for a `!` type, and it crates less work for
the compiler. The code is truly unreachable, so the message would never
be useful. Rust used to be concerned about semantics of empty loops in
LLVM, but this [has been solved](https://reviews.llvm.org/D85393).
---
 tracing-attributes/src/expand.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tracing-attributes/src/expand.rs b/tracing-attributes/src/expand.rs
index 01b25f84aa..a7123e5239 100644
--- a/tracing-attributes/src/expand.rs
+++ b/tracing-attributes/src/expand.rs
@@ -66,11 +66,11 @@ pub(crate) fn gen_function<'a, B: ToTokens + 'a>(
     let fake_return_edge = quote_spanned! {return_span=>
         #[allow(
             unknown_lints, unreachable_code, clippy::diverging_sub_expression,
-            clippy::let_unit_value, clippy::unreachable, clippy::let_with_type_underscore
+            clippy::let_unit_value, clippy::unreachable, clippy::let_with_type_underscore,
+            clippy::empty_loop
         )]
         if false {
-            let __tracing_attr_fake_return: #return_type =
-                unreachable!("this is just for type inference, and is unreachable code");
+            let __tracing_attr_fake_return: #return_type = loop {};
             return __tracing_attr_fake_return;
         }
     };

From b0e3c718685e254ae0830c2a4c13d1af3e551da3 Mon Sep 17 00:00:00 2001
From: Ethan Brierley 
Date: Tue, 5 Sep 2023 18:57:39 +0100
Subject: [PATCH 25/34] core: allow `ValueSet`s of any length (#2508)

## Motivation

Fixes: #1566

## Solution

This change removes the maximum of 32 fields limitation using const
generics.

Having this arbitrary restriction in place to prevent stack overflows
feels a little misplaced to me since stack size varies between
environments.
---
 tracing-core/src/field.rs | 25 ++---------------------
 tracing/src/lib.rs        | 16 ---------------
 tracing/src/span.rs       |  2 +-
 tracing/tests/macros.rs   | 42 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 45 insertions(+), 40 deletions(-)

diff --git a/tracing-core/src/field.rs b/tracing-core/src/field.rs
index 2a11a7ee2d..90c4eaa85d 100644
--- a/tracing-core/src/field.rs
+++ b/tracing-core/src/field.rs
@@ -879,9 +879,6 @@ impl FieldSet {
     }
 
     /// Returns a new `ValueSet` with entries for this `FieldSet`'s values.
-    ///
-    /// Note that a `ValueSet` may not be constructed with arrays of over 32
-    /// elements.
     #[doc(hidden)]
     pub fn value_set<'v, V>(&'v self, values: &'v V) -> ValueSet<'v>
     where
@@ -1080,28 +1077,10 @@ impl<'a> fmt::Display for ValueSet<'a> {
 mod private {
     use super::*;
 
-    /// Marker trait implemented by arrays which are of valid length to
-    /// construct a `ValueSet`.
-    ///
-    /// `ValueSet`s may only be constructed from arrays containing 32 or fewer
-    /// elements, to ensure the array is small enough to always be allocated on the
-    /// stack. This trait is only implemented by arrays of an appropriate length,
-    /// ensuring that the correct size arrays are used at compile-time.
+    /// Restrictions on `ValueSet` lengths were removed in #2508 but this type remains for backwards compatibility.
     pub trait ValidLen<'a>: Borrow<[(&'a Field, Option<&'a (dyn Value + 'a)>)]> {}
-}
-
-macro_rules! impl_valid_len {
-    ( $( $len:tt ),+ ) => {
-        $(
-            impl<'a> private::ValidLen<'a> for
-                [(&'a Field, ::core::option::Option<&'a (dyn Value + 'a)>); $len] {}
-        )+
-    }
-}
 
-impl_valid_len! {
-    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
-    21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32
+    impl<'a, const N: usize> ValidLen<'a> for [(&'a Field, Option<&'a (dyn Value + 'a)>); N] {}
 }
 
 #[cfg(test)]
diff --git a/tracing/src/lib.rs b/tracing/src/lib.rs
index 53ca1253ce..a200c840b7 100644
--- a/tracing/src/lib.rs
+++ b/tracing/src/lib.rs
@@ -386,22 +386,6 @@
 //! span.record("parting", &"goodbye world!");
 //! ```
 //!
-//! Note that a span may have up to 32 fields. The following will not compile:
-//!
-//! ```rust,compile_fail
-//! # use tracing::Level;
-//! # fn main() {
-//! let bad_span = span!(
-//!     Level::TRACE,
-//!     "too many fields!",
-//!     a = 1, b = 2, c = 3, d = 4, e = 5, f = 6, g = 7, h = 8, i = 9,
-//!     j = 10, k = 11, l = 12, m = 13, n = 14, o = 15, p = 16, q = 17,
-//!     r = 18, s = 19, t = 20, u = 21, v = 22, w = 23, x = 24, y = 25,
-//!     z = 26, aa = 27, bb = 28, cc = 29, dd = 30, ee = 31, ff = 32, gg = 33
-//! );
-//! # }
-//! ```
-//!
 //! Finally, events may also include human-readable messages, in the form of a
 //! [format string][fmt] and (optional) arguments, **after** the event's
 //! key-value fields. If a format string and arguments are provided,
diff --git a/tracing/src/span.rs b/tracing/src/span.rs
index 579116ace5..3c235dc792 100644
--- a/tracing/src/span.rs
+++ b/tracing/src/span.rs
@@ -22,7 +22,7 @@
 //!   override their default values.
 //! - The span's [verbosity level]
 //! - A string literal providing the span's name.
-//! - Finally, between zero and 32 arbitrary key/value fields.
+//! - Finally, zero or more arbitrary key/value fields.
 //!
 //! [`target`]: super::Metadata::target
 //!
diff --git a/tracing/tests/macros.rs b/tracing/tests/macros.rs
index 6d9a333b68..6844315305 100644
--- a/tracing/tests/macros.rs
+++ b/tracing/tests/macros.rs
@@ -308,6 +308,48 @@ fn span_with_non_rust_symbol() {
     span!(Level::TRACE, "non-rust", "guid:x-request-id" = "abcdef");
 }
 
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+#[test]
+fn large_span() {
+    span!(
+        Level::TRACE,
+        "spans with more than 32 fields have been supported since #2508",
+        a = 1,
+        b = 2,
+        c = 3,
+        d = 4,
+        e = 5,
+        f = 6,
+        g = 7,
+        h = 8,
+        i = 9,
+        j = 10,
+        k = 11,
+        l = 12,
+        m = 13,
+        n = 14,
+        o = 15,
+        p = 16,
+        q = 17,
+        r = 18,
+        s = 19,
+        t = 20,
+        u = 21,
+        v = 22,
+        w = 23,
+        x = 24,
+        y = 25,
+        z = 26,
+        aa = 27,
+        bb = 28,
+        cc = 29,
+        dd = 30,
+        ee = 31,
+        ff = 32,
+        gg = 33
+    );
+}
+
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
 #[test]
 fn event() {

From 3b1851de72f3e9d85e58407deccb3d3ebd3e291c Mon Sep 17 00:00:00 2001
From: Aaron Roney 
Date: Tue, 5 Sep 2023 13:09:00 -0700
Subject: [PATCH 26/34] tracing: allow setting event names in macros (#2699)

## Motivation

The motivation is #1426.  Currently, event names are set to a default
value of `event file:line`, which (1) doesn't allow for customization,
and (2) prevents events from working for some opentelemetry endpoints
(they often use the event name `exception` to designate something like a
panic).

## Solution

Went through the event macros, and added new parameterization that
allows for setting the `name`.  In addition, added some comments, and
reordering, to make life a bit better for the next person that comes
along to edit those macros.  Finally, added tests for the macro
expansion alongside the existing tests with a reasonable amount of
coverage (though, admittedly, more could be added for all of the macro
invocation types

Fixes #1426
---
 tracing/src/lib.rs      |  13 +-
 tracing/src/macros.rs   | 767 +++++++++++++++++++++++++++++++++++-----
 tracing/tests/macros.rs | 143 ++++++++
 3 files changed, 842 insertions(+), 81 deletions(-)

diff --git a/tracing/src/lib.rs b/tracing/src/lib.rs
index a200c840b7..bcd0c6356c 100644
--- a/tracing/src/lib.rs
+++ b/tracing/src/lib.rs
@@ -214,7 +214,7 @@
 //! ### Configuring Attributes
 //!
 //! Both macros require a [`Level`] specifying the verbosity of the span or
-//! event. Optionally, the [target] and [parent span] may be overridden. If the
+//! event. Optionally, the, [target] and [parent span] may be overridden. If the
 //! target and parent span are not overridden, they will default to the
 //! module path where the macro was invoked and the current span (as determined
 //! by the subscriber), respectively.
@@ -237,7 +237,16 @@
 //! ```
 //!
 //! The span macros also take a string literal after the level, to set the name
-//! of the span.
+//! of the span (as above).  In the case of the event macros, the name of the event can
+//! be overridden (the default is `event file:line`) using the `name:` specifier.
+//!
+//! ```
+//! # use tracing::{span, event, Level};
+//! # fn main() {
+//! span!(Level::TRACE, "my span");
+//! event!(name: "some_info", Level::INFO, "something has happened!");
+//! # }
+//! ```
 //!
 //! ### Recording Fields
 //!
diff --git a/tracing/src/macros.rs b/tracing/src/macros.rs
index e1f43f436b..b5f232bf0e 100644
--- a/tracing/src/macros.rs
+++ b/tracing/src/macros.rs
@@ -564,6 +564,7 @@ macro_rules! error_span {
 ///     "App warning: {}",
 ///     error
 /// );
+/// event!(name: "answer", Level::INFO, the_answer = data.0);
 /// event!(Level::INFO, the_answer = data.0);
 /// # }
 /// ```
@@ -582,6 +583,112 @@ macro_rules! error_span {
 // /// ```
 #[macro_export]
 macro_rules! event {
+    // Name / target / parent.
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* } )=> ({
+        use $crate::__macro_support::Callsite as _;
+        static CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
+            name: $name,
+            kind: $crate::metadata::Kind::EVENT,
+            target: $target,
+            level: $lvl,
+            fields: $($fields)*
+        };
+
+        let enabled = $crate::level_enabled!($lvl) && {
+            let interest = CALLSITE.interest();
+            !interest.is_never() && CALLSITE.is_enabled(interest)
+        };
+        if enabled {
+            (|value_set: $crate::field::ValueSet| {
+                $crate::__tracing_log!(
+                    $lvl,
+                    CALLSITE,
+                    &value_set
+                );
+                let meta = CALLSITE.metadata();
+                // event with explicit parent
+                $crate::Event::child_of(
+                    $parent,
+                    meta,
+                    &value_set
+                );
+            })($crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
+        } else {
+            $crate::__tracing_log!(
+                $lvl,
+                CALLSITE,
+                &$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*)
+            );
+        }
+    });
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
+        $crate::event!(
+            name: $name,
+            target: $target,
+            parent: $parent,
+            $lvl,
+            { message = format_args!($($arg)+), $($fields)* }
+        )
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, $lvl:expr, $($k:ident).+ = $($fields:tt)* ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $lvl, { $($k).+ = $($fields)* })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, $lvl:expr, $($arg:tt)+) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $lvl, { $($arg)+ })
+    );
+
+    // Name / target.
+    (name: $name:expr, target: $target:expr, $lvl:expr, { $($fields:tt)* } )=> ({
+        use $crate::__macro_support::Callsite as _;
+        static CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
+            name: $name,
+            kind: $crate::metadata::Kind::EVENT,
+            target: $target,
+            level: $lvl,
+            fields: $($fields)*
+        };
+        let enabled = $crate::level_enabled!($lvl) && {
+            let interest = CALLSITE.interest();
+            !interest.is_never() && CALLSITE.is_enabled(interest)
+        };
+        if enabled {
+            (|value_set: $crate::field::ValueSet| {
+                let meta = CALLSITE.metadata();
+                // event with contextual parent
+                $crate::Event::dispatch(
+                    meta,
+                    &value_set
+                );
+                $crate::__tracing_log!(
+                    $lvl,
+                    CALLSITE,
+                    &value_set
+                );
+            })($crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
+        } else {
+            $crate::__tracing_log!(
+                $lvl,
+                CALLSITE,
+                &$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*)
+            );
+        }
+    });
+    (name: $name:expr, target: $target:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
+        $crate::event!(
+            name: $name,
+            target: $target,
+            $lvl,
+            { message = format_args!($($arg)+), $($fields)* }
+        )
+    );
+    (name: $name:expr, target: $target:expr, $lvl:expr, $($k:ident).+ = $($fields:tt)* ) => (
+        $crate::event!(name: $name, target: $target, $lvl, { $($k).+ = $($fields)* })
+    );
+    (name: $name:expr, target: $target:expr, $lvl:expr, $($arg:tt)+) => (
+        $crate::event!(name: $name, target: $target, $lvl, { $($arg)+ })
+    );
+
+    // Target / parent.
     (target: $target:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* } )=> ({
         use $crate::__macro_support::Callsite as _;
         static CALLSITE: $crate::callsite::DefaultCallsite = $crate::callsite2! {
@@ -624,7 +731,6 @@ macro_rules! event {
             );
         }
     });
-
     (target: $target:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
         $crate::event!(
             target: $target,
@@ -639,6 +745,111 @@ macro_rules! event {
     (target: $target:expr, parent: $parent:expr, $lvl:expr, $($arg:tt)+) => (
         $crate::event!(target: $target, parent: $parent, $lvl, { $($arg)+ })
     );
+
+    // Name / parent.
+    (name: $name:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* } )=> ({
+        use $crate::__macro_support::Callsite as _;
+        static CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
+            name: $name,
+            kind: $crate::metadata::Kind::EVENT,
+            target: module_path!(),
+            level: $lvl,
+            fields: $($fields)*
+        };
+
+        let enabled = $crate::level_enabled!($lvl) && {
+            let interest = CALLSITE.interest();
+            !interest.is_never() && CALLSITE.is_enabled(interest)
+        };
+        if enabled {
+            (|value_set: $crate::field::ValueSet| {
+                $crate::__tracing_log!(
+                    $lvl,
+                    CALLSITE,
+                    &value_set
+                );
+                let meta = CALLSITE.metadata();
+                // event with explicit parent
+                $crate::Event::child_of(
+                    $parent,
+                    meta,
+                    &value_set
+                );
+            })($crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
+        } else {
+            $crate::__tracing_log!(
+                $lvl,
+                CALLSITE,
+                &$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*)
+            );
+        }
+    });
+    (name: $name:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
+        $crate::event!(
+            name: $name,
+            parent: $parent,
+            $lvl,
+            { message = format_args!($($arg)+), $($fields)* }
+        )
+    );
+    (name: $name:expr, parent: $parent:expr, $lvl:expr, $($k:ident).+ = $($fields:tt)* ) => (
+        $crate::event!(name: $name, parent: $parent, $lvl, { $($k).+ = $($fields)* })
+    );
+    (name: $name:expr, parent: $parent:expr, $lvl:expr, $($arg:tt)+) => (
+        $crate::event!(name: $name, parent: $parent, $lvl, { $($arg)+ })
+    );
+
+    // Name.
+    (name: $name:expr, $lvl:expr, { $($fields:tt)* } )=> ({
+        use $crate::__macro_support::Callsite as _;
+        static CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
+            name: $name,
+            kind: $crate::metadata::Kind::EVENT,
+            target: module_path!(),
+            level: $lvl,
+            fields: $($fields)*
+        };
+        let enabled = $crate::level_enabled!($lvl) && {
+            let interest = CALLSITE.interest();
+            !interest.is_never() && CALLSITE.is_enabled(interest)
+        };
+        if enabled {
+            (|value_set: $crate::field::ValueSet| {
+                let meta = CALLSITE.metadata();
+                // event with contextual parent
+                $crate::Event::dispatch(
+                    meta,
+                    &value_set
+                );
+                $crate::__tracing_log!(
+                    $lvl,
+                    CALLSITE,
+                    &value_set
+                );
+            })($crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
+        } else {
+            $crate::__tracing_log!(
+                $lvl,
+                CALLSITE,
+                &$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*)
+            );
+        }
+    });
+    (name: $name:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
+        $crate::event!(
+            name: $name,
+            $lvl,
+            { message = format_args!($($arg)+), $($fields)* }
+        )
+    );
+    (name: $name:expr, $lvl:expr, $($k:ident).+ = $($fields:tt)* ) => (
+        $crate::event!(name: $name, $lvl, { $($k).+ = $($fields)* })
+    );
+    (name: $name:expr, $lvl:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, $lvl, { $($arg)+ })
+    );
+
+    // Target.
     (target: $target:expr, $lvl:expr, { $($fields:tt)* } )=> ({
         use $crate::__macro_support::Callsite as _;
         static CALLSITE: $crate::callsite::DefaultCallsite = $crate::callsite2! {
@@ -692,6 +903,8 @@ macro_rules! event {
     (target: $target:expr, $lvl:expr, $($arg:tt)+ ) => (
         $crate::event!(target: $target, $lvl, { $($arg)+ })
     );
+
+    // Parent.
     (parent: $parent:expr, $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
         $crate::event!(
             target: module_path!(),
@@ -751,6 +964,8 @@ macro_rules! event {
     (parent: $parent:expr, $lvl:expr, $($arg:tt)+ ) => (
         $crate::event!(target: module_path!(), parent: $parent, $lvl, { $($arg)+ })
     );
+
+    // ...
     ( $lvl:expr, { $($fields:tt)* }, $($arg:tt)+ ) => (
         $crate::event!(
             target: module_path!(),
@@ -1081,10 +1296,46 @@ macro_rules! enabled {
 ///     if pos.x >= 0.0 { "positive" } else { "negative" },
 ///     if pos.y >= 0.0 { "positive" } else { "negative" }
 /// );
+/// trace!(name: "completed", position = ?pos);
 /// # }
 /// ```
 #[macro_export]
 macro_rules! trace {
+    // Name / target / parent.
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::TRACE, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::TRACE, {}, $($arg)+)
+    );
+
+    // Name / target.
+    (name: $name:expr, target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::TRACE, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, target: $target:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::TRACE, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::TRACE, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::TRACE, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::TRACE, {}, $($arg)+)
+    );
+
+    // Target / parent.
     (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
         $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, { $($field)* }, $($arg)*)
     );
@@ -1100,6 +1351,59 @@ macro_rules! trace {
     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
         $crate::event!(target: $target, parent: $parent, $crate::Level::TRACE, {}, $($arg)+)
     );
+
+    // Name / parent.
+    (name: $name:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::TRACE, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::TRACE, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::TRACE, {}, $($arg)+)
+    );
+
+    // Name.
+    (name: $name:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::TRACE, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, $($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::TRACE, { $($k).+ $($field)* })
+    );
+    (name: $name:expr, ?$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::TRACE, { ?$($k).+ $($field)* })
+    );
+    (name: $name:expr, %$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::TRACE, { %$($k).+ $($field)* })
+    );
+    (name: $name:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, $crate::Level::TRACE, {}, $($arg)+)
+    );
+
+    // Target.
+    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::TRACE, { $($field)* }, $($arg)*)
+    );
+    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::TRACE, { $($k).+ $($field)* })
+    );
+    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::TRACE, { ?$($k).+ $($field)* })
+    );
+    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::TRACE, { %$($k).+ $($field)* })
+    );
+    (target: $target:expr, $($arg:tt)+ ) => (
+        $crate::event!(target: $target, $crate::Level::TRACE, {}, $($arg)+)
+    );
+
+    // Parent.
     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
         $crate::event!(
             target: module_path!(),
@@ -1166,21 +1470,8 @@ macro_rules! trace {
             $($arg)+
         )
     );
-    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::TRACE, { $($field)* }, $($arg)*)
-    );
-    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::TRACE, { $($k).+ $($field)* })
-    );
-    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::TRACE, { ?$($k).+ $($field)* })
-    );
-    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::TRACE, { %$($k).+ $($field)* })
-    );
-    (target: $target:expr, $($arg:tt)+ ) => (
-        $crate::event!(target: $target, $crate::Level::TRACE, {}, $($arg)+)
-    );
+
+    // ...
     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
         $crate::event!(
             target: module_path!(),
@@ -1196,6 +1487,20 @@ macro_rules! trace {
             { $($k).+ = $($field)*}
         )
     );
+    (?$($k:ident).+ = $($field:tt)*) => (
+        $crate::event!(
+            target: module_path!(),
+            $crate::Level::TRACE,
+            { ?$($k).+ = $($field)*}
+        )
+    );
+    (%$($k:ident).+ = $($field:tt)*) => (
+        $crate::event!(
+            target: module_path!(),
+            $crate::Level::TRACE,
+            { %$($k).+ = $($field)*}
+        )
+    );
     ($($k:ident).+, $($field:tt)*) => (
         $crate::event!(
             target: module_path!(),
@@ -1268,10 +1573,46 @@ macro_rules! trace {
 ///
 /// debug!(?pos.x, ?pos.y);
 /// debug!(target: "app_events", position = ?pos, "New position");
+/// debug!(name: "completed", position = ?pos);
 /// # }
 /// ```
 #[macro_export]
 macro_rules! debug {
+    // Name / target / parent.
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, {}, $($arg)+)
+    );
+
+    // Name / target.
+    (name: $name:expr, target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, target: $target:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, {}, $($arg)+)
+    );
+
+    // Target / parent.
     (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
         $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
     );
@@ -1287,6 +1628,59 @@ macro_rules! debug {
     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
         $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, {}, $($arg)+)
     );
+
+    // Name / parent.
+    (name: $name:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, {}, $($arg)+)
+    );
+
+    // Name.
+    (name: $name:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, $($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::DEBUG, { $($k).+ $($field)* })
+    );
+    (name: $name:expr, ?$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
+    );
+    (name: $name:expr, %$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::DEBUG, { %$($k).+ $($field)* })
+    );
+    (name: $name:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, $crate::Level::DEBUG, {}, $($arg)+)
+    );
+
+    // Target.
+    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
+    );
+    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::DEBUG, { $($k).+ $($field)* })
+    );
+    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
+    );
+    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::DEBUG, { %$($k).+ $($field)* })
+    );
+    (target: $target:expr, $($arg:tt)+ ) => (
+        $crate::event!(target: $target, $crate::Level::DEBUG, {}, $($arg)+)
+    );
+
+    // Parent.
     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
         $crate::event!(
             target: module_path!(),
@@ -1353,21 +1747,8 @@ macro_rules! debug {
             $($arg)+
         )
     );
-    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
-    );
-    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::DEBUG, { $($k).+ $($field)* })
-    );
-    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
-    );
-    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::DEBUG, { %$($k).+ $($field)* })
-    );
-    (target: $target:expr, $($arg:tt)+ ) => (
-        $crate::event!(target: $target, $crate::Level::DEBUG, {}, $($arg)+)
-    );
+
+    // ...
     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
         $crate::event!(
             target: module_path!(),
@@ -1480,11 +1861,47 @@ macro_rules! debug {
 ///     conn.port,
 ///     ?conn.speed,
 /// );
+/// info!(name: "completed", "completed connection to {:?}", addr);
 /// # }
 /// ```
 #[macro_export]
 macro_rules! info {
-     (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+    // Name / target / parent.
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::INFO, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::INFO, {}, $($arg)+)
+    );
+
+    // Name / target.
+    (name: $name:expr, target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::INFO, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, target: $target:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::INFO, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::INFO, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::INFO, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::INFO, {}, $($arg)+)
+    );
+
+    // Target / parent.
+    (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
         $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, { $($field)* }, $($arg)*)
     );
     (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
@@ -1499,6 +1916,59 @@ macro_rules! info {
     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
         $crate::event!(target: $target, parent: $parent, $crate::Level::INFO, {}, $($arg)+)
     );
+
+    // Name / parent.
+    (name: $name:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::INFO, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::INFO, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::INFO, {}, $($arg)+)
+    );
+
+    // Name.
+    (name: $name:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::INFO, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, $($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::INFO, { $($k).+ $($field)* })
+    );
+    (name: $name:expr, ?$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::INFO, { ?$($k).+ $($field)* })
+    );
+    (name: $name:expr, %$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::INFO, { %$($k).+ $($field)* })
+    );
+    (name: $name:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, $crate::Level::INFO, {}, $($arg)+)
+    );
+
+    // Target.
+    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::INFO, { $($field)* }, $($arg)*)
+    );
+    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::INFO, { $($k).+ $($field)* })
+    );
+    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::INFO, { ?$($k).+ $($field)* })
+    );
+    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::INFO, { %$($k).+ $($field)* })
+    );
+    (target: $target:expr, $($arg:tt)+ ) => (
+        $crate::event!(target: $target, $crate::Level::INFO, {}, $($arg)+)
+    );
+
+    // Parent.
     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
         $crate::event!(
             target: module_path!(),
@@ -1565,21 +2035,8 @@ macro_rules! info {
             $($arg)+
         )
     );
-    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::INFO, { $($field)* }, $($arg)*)
-    );
-    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::INFO, { $($k).+ $($field)* })
-    );
-    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::INFO, { ?$($k).+ $($field)* })
-    );
-    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::INFO, { $($k).+ $($field)* })
-    );
-    (target: $target:expr, $($arg:tt)+ ) => (
-        $crate::event!(target: $target, $crate::Level::INFO, {}, $($arg)+)
-    );
+
+    // ...
     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
         $crate::event!(
             target: module_path!(),
@@ -1685,11 +2142,47 @@ macro_rules! info {
 ///     warning = warn_description,
 ///     "Received warning for input: {:?}", input,
 /// );
+/// warn!(name: "invalid", ?input);
 /// # }
 /// ```
 #[macro_export]
 macro_rules! warn {
-     (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+    // Name / target / parent.
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::WARN, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::WARN, {}, $($arg)+)
+    );
+
+    // Name / target.
+    (name: $name:expr, target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::WARN, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, target: $target:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::WARN, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::WARN, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::WARN, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::WARN, {}, $($arg)+)
+    );
+
+    // Target / parent.
+    (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
         $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, { $($field)* }, $($arg)*)
     );
     (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
@@ -1704,6 +2197,59 @@ macro_rules! warn {
     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
         $crate::event!(target: $target, parent: $parent, $crate::Level::WARN, {}, $($arg)+)
     );
+
+    // Name / parent.
+    (name: $name:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::WARN, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::WARN, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::WARN, {}, $($arg)+)
+    );
+
+    // Name.
+    (name: $name:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::WARN, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, $($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::WARN, { $($k).+ $($field)* })
+    );
+    (name: $name:expr, ?$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::WARN, { ?$($k).+ $($field)* })
+    );
+    (name: $name:expr, %$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::WARN, { %$($k).+ $($field)* })
+    );
+    (name: $name:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, $crate::Level::WARN, {}, $($arg)+)
+    );
+
+    // Target.
+    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::WARN, { $($field)* }, $($arg)*)
+    );
+    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::WARN, { $($k).+ $($field)* })
+    );
+    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::WARN, { ?$($k).+ $($field)* })
+    );
+    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::WARN, { %$($k).+ $($field)* })
+    );
+    (target: $target:expr, $($arg:tt)+ ) => (
+        $crate::event!(target: $target, $crate::Level::WARN, {}, $($arg)+)
+    );
+
+    // Parent.
     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
         $crate::event!(
             target: module_path!(),
@@ -1770,21 +2316,8 @@ macro_rules! warn {
             $($arg)+
         )
     );
-    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::WARN, { $($field)* }, $($arg)*)
-    );
-    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::WARN, { $($k).+ $($field)* })
-    );
-    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::WARN, { ?$($k).+ $($field)* })
-    );
-    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::WARN, { %$($k).+ $($field)* })
-    );
-    (target: $target:expr, $($arg:tt)+ ) => (
-        $crate::event!(target: $target, $crate::Level::WARN, {}, $($arg)+)
-    );
+
+    // ...
     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
         $crate::event!(
             target: module_path!(),
@@ -1886,11 +2419,47 @@ macro_rules! warn {
 /// error!(port, error = %err_info);
 /// error!(target: "app_events", "App Error: {}", err_info);
 /// error!({ info = err_info }, "error on port: {}", port);
+/// error!(name: "invalid_input", "Invalid input: {}", err_info);
 /// # }
 /// ```
 #[macro_export]
 macro_rules! error {
-     (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+    // Name / target / parent.
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::ERROR, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::ERROR, {}, $($arg)+)
+    );
+
+    // Name / target.
+    (name: $name:expr, target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::ERROR, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, target: $target:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::ERROR, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::ERROR, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::ERROR, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, target: $target:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, target: $target, $crate::Level::ERROR, {}, $($arg)+)
+    );
+
+    // Target / parent.
+    (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
         $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, { $($field)* }, $($arg)*)
     );
     (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
@@ -1905,6 +2474,59 @@ macro_rules! error {
     (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
         $crate::event!(target: $target, parent: $parent, $crate::Level::ERROR, {}, $($arg)+)
     );
+
+    // Name / parent.
+    (name: $name:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::ERROR, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::ERROR, { $($k).+ $($field)+ })
+    );
+    (name: $name:expr, parent: $parent:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, parent: $parent, $crate::Level::ERROR, {}, $($arg)+)
+    );
+
+    // Name.
+    (name: $name:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::ERROR, { $($field)* }, $($arg)*)
+    );
+    (name: $name:expr, $($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::ERROR, { $($k).+ $($field)* })
+    );
+    (name: $name:expr, ?$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::ERROR, { ?$($k).+ $($field)* })
+    );
+    (name: $name:expr, %$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(name: $name, $crate::Level::ERROR, { %$($k).+ $($field)* })
+    );
+    (name: $name:expr, $($arg:tt)+ ) => (
+        $crate::event!(name: $name, $crate::Level::ERROR, {}, $($arg)+)
+    );
+
+    // Target.
+    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::ERROR, { $($field)* }, $($arg)*)
+    );
+    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::ERROR, { $($k).+ $($field)* })
+    );
+    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::ERROR, { ?$($k).+ $($field)* })
+    );
+    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
+        $crate::event!(target: $target, $crate::Level::ERROR, { %$($k).+ $($field)* })
+    );
+    (target: $target:expr, $($arg:tt)+ ) => (
+        $crate::event!(target: $target, $crate::Level::ERROR, {}, $($arg)+)
+    );
+
+    // Parent.
     (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
         $crate::event!(
             target: module_path!(),
@@ -1971,21 +2593,8 @@ macro_rules! error {
             $($arg)+
         )
     );
-    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::ERROR, { $($field)* }, $($arg)*)
-    );
-    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::ERROR, { $($k).+ $($field)* })
-    );
-    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::ERROR, { ?$($k).+ $($field)* })
-    );
-    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
-        $crate::event!(target: $target, $crate::Level::ERROR, { %$($k).+ $($field)* })
-    );
-    (target: $target:expr, $($arg:tt)+ ) => (
-        $crate::event!(target: $target, $crate::Level::ERROR, {}, $($arg)+)
-    );
+
+    // ...
     ({ $($field:tt)+ }, $($arg:tt)+ ) => (
         $crate::event!(
             target: module_path!(),
diff --git a/tracing/tests/macros.rs b/tracing/tests/macros.rs
index 6844315305..5c993ccffa 100644
--- a/tracing/tests/macros.rs
+++ b/tracing/tests/macros.rs
@@ -451,6 +451,13 @@ fn locals_no_message() {
     let data = (42, "forty-two");
     let private_data = "private";
     let error = "a bad error";
+    event!(
+        name: "foo",
+        target: "app_events",
+        Level::WARN,
+        private_data,
+        ?data,
+    );
     event!(
         target: "app_events",
         Level::WARN,
@@ -490,6 +497,8 @@ fn trace() {
     trace!({ foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     trace!({ foo = 2, bar.baz = 78 }, "quux");
     trace!({ foo = ?2, bar.baz = %78 }, "quux");
+    trace!(name: "foo", foo = 3, bar.baz = 2, quux = false);
+    trace!(name: "foo", target: "foo_events", foo = 3, bar.baz = 2, quux = false);
     trace!(target: "foo_events", foo = 3, bar.baz = 2, quux = false);
     trace!(target: "foo_events", foo = 3, bar.baz = 3,);
     trace!(target: "foo_events", "foo");
@@ -502,6 +511,12 @@ fn trace() {
     trace!(?foo);
     trace!(%foo);
     trace!(foo);
+    trace!(name: "foo", ?foo);
+    trace!(name: "foo", %foo);
+    trace!(name: "foo", foo);
+    trace!(name: "foo", ?foo, true, "message");
+    trace!(name: "foo", %foo, true, "message");
+    trace!(name: "foo", foo, true, "message");
     trace!(target: "foo_events", ?foo);
     trace!(target: "foo_events", %foo);
     trace!(target: "foo_events", foo);
@@ -526,6 +541,8 @@ fn debug() {
     debug!({ foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     debug!({ foo = 2, bar.baz = 78 }, "quux");
     debug!({ foo = ?2, bar.baz = %78 }, "quux");
+    debug!(name: "foo", foo = 3, bar.baz = 2, quux = false);
+    debug!(name: "foo", target: "foo_events", foo = 3, bar.baz = 2, quux = false);
     debug!(target: "foo_events", foo = 3, bar.baz = 2, quux = false);
     debug!(target: "foo_events", foo = 3, bar.baz = 3,);
     debug!(target: "foo_events", "foo");
@@ -538,6 +555,12 @@ fn debug() {
     debug!(?foo);
     debug!(%foo);
     debug!(foo);
+    debug!(name: "foo", ?foo);
+    debug!(name: "foo", %foo);
+    debug!(name: "foo", foo);
+    debug!(name: "foo", ?foo, true, "message");
+    debug!(name: "foo", %foo, true, "message");
+    debug!(name: "foo", foo, true, "message");
     debug!(target: "foo_events", ?foo);
     debug!(target: "foo_events", %foo);
     debug!(target: "foo_events", foo);
@@ -562,6 +585,8 @@ fn info() {
     info!({ foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     info!({ foo = 2, bar.baz = 78 }, "quux");
     info!({ foo = ?2, bar.baz = %78 }, "quux");
+    info!(name: "foo", foo = 3, bar.baz = 2, quux = false);
+    info!(name: "foo", target: "foo_events", foo = 3, bar.baz = 2, quux = false);
     info!(target: "foo_events", foo = 3, bar.baz = 2, quux = false);
     info!(target: "foo_events", foo = 3, bar.baz = 3,);
     info!(target: "foo_events", "foo");
@@ -574,6 +599,12 @@ fn info() {
     info!(?foo);
     info!(%foo);
     info!(foo);
+    info!(name: "foo", ?foo);
+    info!(name: "foo", %foo);
+    info!(name: "foo", foo);
+    info!(name: "foo", ?foo, true, "message");
+    info!(name: "foo", %foo, true, "message");
+    info!(name: "foo", foo, true, "message");
     info!(target: "foo_events", ?foo);
     info!(target: "foo_events", %foo);
     info!(target: "foo_events", foo);
@@ -598,6 +629,8 @@ fn warn() {
     warn!({ foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     warn!({ foo = 2, bar.baz = 78 }, "quux");
     warn!({ foo = ?2, bar.baz = %78 }, "quux");
+    warn!(name: "foo", foo = 3, bar.baz = 2, quux = false);
+    warn!(name: "foo", target: "foo_events", foo = 3, bar.baz = 2, quux = false);
     warn!(target: "foo_events", foo = 3, bar.baz = 2, quux = false);
     warn!(target: "foo_events", foo = 3, bar.baz = 3,);
     warn!(target: "foo_events", "foo");
@@ -610,6 +643,12 @@ fn warn() {
     warn!(?foo);
     warn!(%foo);
     warn!(foo);
+    warn!(name: "foo", ?foo);
+    warn!(name: "foo", %foo);
+    warn!(name: "foo", foo);
+    warn!(name: "foo", ?foo, true, "message");
+    warn!(name: "foo", %foo, true, "message");
+    warn!(name: "foo", foo, true, "message");
     warn!(target: "foo_events", ?foo);
     warn!(target: "foo_events", %foo);
     warn!(target: "foo_events", foo);
@@ -634,6 +673,8 @@ fn error() {
     error!({ foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     error!({ foo = 2, bar.baz = 78, }, "quux");
     error!({ foo = ?2, bar.baz = %78 }, "quux");
+    error!(name: "foo", foo = 3, bar.baz = 2, quux = false);
+    error!(name: "foo", target: "foo_events", foo = 3, bar.baz = 2, quux = false);
     error!(target: "foo_events", foo = 3, bar.baz = 2, quux = false);
     error!(target: "foo_events", foo = 3, bar.baz = 3,);
     error!(target: "foo_events", "foo");
@@ -646,6 +687,12 @@ fn error() {
     error!(?foo);
     error!(%foo);
     error!(foo);
+    error!(name: "foo", ?foo);
+    error!(name: "foo", %foo);
+    error!(name: "foo", foo);
+    error!(name: "foo", ?foo, true, "message");
+    error!(name: "foo", %foo, true, "message");
+    error!(name: "foo", foo, true, "message");
     error!(target: "foo_events", ?foo);
     error!(target: "foo_events", %foo);
     error!(target: "foo_events", foo);
@@ -680,6 +727,14 @@ fn event_root() {
     event!(target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
     event!(target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     event!(target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, { foo = 2, bar.baz = 78, }, "quux");
+    event!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, foo = 3, bar.baz = 2, quux = false);
+    event!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, foo = 3, bar.baz = 3,);
+    event!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, "foo");
+    event!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, "foo: {}", 3);
+    event!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, { foo = 3, bar.baz = 80 }, "quux");
+    event!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
+    event!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
+    event!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, Level::DEBUG, { foo = 2, bar.baz = 78, }, "quux");
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
@@ -703,6 +758,14 @@ fn trace_root() {
     trace!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
     trace!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     trace!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux");
+    trace!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false);
+    trace!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 3,);
+    trace!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, "foo");
+    trace!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, "foo: {}", 3);
+    trace!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux");
+    trace!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
+    trace!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
+    trace!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux");
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
@@ -726,6 +789,14 @@ fn debug_root() {
     debug!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
     debug!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     debug!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux");
+    debug!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false);
+    debug!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 3,);
+    debug!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, "foo");
+    debug!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, "foo: {}", 3);
+    debug!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux");
+    debug!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
+    debug!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
+    debug!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux");
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
@@ -749,6 +820,14 @@ fn info_root() {
     info!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
     info!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     info!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux");
+    info!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false);
+    info!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 3,);
+    info!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, "foo");
+    info!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, "foo: {}", 3);
+    info!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux");
+    info!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
+    info!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
+    info!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux");
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
@@ -772,6 +851,14 @@ fn warn_root() {
     warn!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
     warn!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     warn!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux");
+    warn!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false);
+    warn!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 3,);
+    warn!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, "foo");
+    warn!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, "foo: {}", 3);
+    warn!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux");
+    warn!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
+    warn!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
+    warn!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux");
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
@@ -795,6 +882,14 @@ fn error_root() {
     error!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
     error!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     error!(target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux");
+    error!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 2, quux = false);
+    error!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, foo = 3, bar.baz = 3,);
+    error!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, "foo");
+    error!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, "foo: {}", 3);
+    error!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 3, bar.baz = 80 }, "quux");
+    error!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
+    error!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
+    error!(name: "foo", target: "foo_events", parent: ::core::option::Option::None, { foo = 2, bar.baz = 78, }, "quux");
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
@@ -818,6 +913,14 @@ fn event_with_parent() {
     event!(target: "foo_events", parent: &p, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
     event!(target: "foo_events", parent: &p, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     event!(target: "foo_events", parent: &p, Level::DEBUG, { foo = 2, bar.baz = 78, }, "quux");
+    event!(name: "foo", target: "foo_events", parent: &p, Level::DEBUG, foo = 3, bar.baz = 2, quux = false);
+    event!(name: "foo", target: "foo_events", parent: &p, Level::DEBUG, foo = 3, bar.baz = 3,);
+    event!(name: "foo", target: "foo_events", parent: &p, Level::DEBUG, "foo");
+    event!(name: "foo", target: "foo_events", parent: &p, Level::DEBUG, "foo: {}", 3);
+    event!(name: "foo", target: "foo_events", parent: &p, Level::DEBUG, { foo = 3, bar.baz = 80 }, "quux");
+    event!(name: "foo", target: "foo_events", parent: &p, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
+    event!(name: "foo", target: "foo_events", parent: &p, Level::DEBUG, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
+    event!(name: "foo", target: "foo_events", parent: &p, Level::DEBUG, { foo = 2, bar.baz = 78, }, "quux");
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
@@ -842,6 +945,14 @@ fn trace_with_parent() {
     trace!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
     trace!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     trace!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 78, }, "quux");
+    trace!(name: "foo", target: "foo_events", parent: &p, foo = 3, bar.baz = 2, quux = false);
+    trace!(name: "foo", target: "foo_events", parent: &p, foo = 3, bar.baz = 3,);
+    trace!(name: "foo", target: "foo_events", parent: &p, "foo");
+    trace!(name: "foo", target: "foo_events", parent: &p, "foo: {}", 3);
+    trace!(name: "foo", target: "foo_events", parent: &p, { foo = 3, bar.baz = 80 }, "quux");
+    trace!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
+    trace!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
+    trace!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 78, }, "quux");
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
@@ -866,6 +977,14 @@ fn debug_with_parent() {
     debug!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
     debug!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     debug!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 78, }, "quux");
+    debug!(name: "foo", target: "foo_events", parent: &p, foo = 3, bar.baz = 2, quux = false);
+    debug!(name: "foo", target: "foo_events", parent: &p, foo = 3, bar.baz = 3,);
+    debug!(name: "foo", target: "foo_events", parent: &p, "foo");
+    debug!(name: "foo", target: "foo_events", parent: &p, "foo: {}", 3);
+    debug!(name: "foo", target: "foo_events", parent: &p, { foo = 3, bar.baz = 80 }, "quux");
+    debug!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
+    debug!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
+    debug!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 78, }, "quux");
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
@@ -890,6 +1009,14 @@ fn info_with_parent() {
     info!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
     info!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     info!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 78, }, "quux");
+    info!(name: "foo", target: "foo_events", parent: &p, foo = 3, bar.baz = 2, quux = false);
+    info!(name: "foo", target: "foo_events", parent: &p, foo = 3, bar.baz = 3,);
+    info!(name: "foo", target: "foo_events", parent: &p, "foo");
+    info!(name: "foo", target: "foo_events", parent: &p, "foo: {}", 3);
+    info!(name: "foo", target: "foo_events", parent: &p, { foo = 3, bar.baz = 80 }, "quux");
+    info!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
+    info!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
+    info!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 78, }, "quux");
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
@@ -914,6 +1041,14 @@ fn warn_with_parent() {
     warn!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
     warn!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     warn!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 78, }, "quux");
+    warn!(name: "foo", target: "foo_events", parent: &p, foo = 3, bar.baz = 2, quux = false);
+    warn!(name: "foo", target: "foo_events", parent: &p, foo = 3, bar.baz = 3,);
+    warn!(name: "foo", target: "foo_events", parent: &p, "foo");
+    warn!(name: "foo", target: "foo_events", parent: &p, "foo: {}", 3);
+    warn!(name: "foo", target: "foo_events", parent: &p, { foo = 3, bar.baz = 80 }, "quux");
+    warn!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
+    warn!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
+    warn!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 78, }, "quux");
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
@@ -938,6 +1073,14 @@ fn error_with_parent() {
     error!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
     error!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
     error!(target: "foo_events", parent: &p, { foo = 2, bar.baz = 78, }, "quux");
+    error!(name: "foo", target: "foo_events", parent: &p, foo = 3, bar.baz = 2, quux = false);
+    error!(name: "foo", target: "foo_events", parent: &p, foo = 3, bar.baz = 3,);
+    error!(name: "foo", target: "foo_events", parent: &p, "foo");
+    error!(name: "foo", target: "foo_events", parent: &p, "foo: {}", 3);
+    error!(name: "foo", target: "foo_events", parent: &p, { foo = 3, bar.baz = 80 }, "quux");
+    error!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}", true);
+    error!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 79 }, "quux {:?}, {quux}", true, quux = false);
+    error!(name: "foo", target: "foo_events", parent: &p, { foo = 2, bar.baz = 78, }, "quux");
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]

From a0a176e04d83e07f36d2b387b7fc2bbb9ade2f05 Mon Sep 17 00:00:00 2001
From: Finomnis 
Date: Tue, 5 Sep 2023 22:13:43 +0200
Subject: [PATCH 27/34] journald: allow custom journal fields (#2708)

It's currently not possible to customize how messages will get send to journald.

This became apparent in #2425, where first a specific API got designed, but then
it was decided that users should not get restricted in only a subset of fields,
but should be able to simply choose by themselves what fields get set with what
values.

So in a sense, this is the successor/rework of #2425.

Allow custom fields to be set in tracing-journald.

- [x] How should we deal with fields that also get supplied by other options?
  For example, setting `SYSLOG_IDENTIFIER` here and also setting
  `.with_syslog_identifier()` will send said field twice, potentially with
  differing values. Is that a problem?
    - Answer: No, this is not a problem.

Closes #2425
---
 tracing-journald/src/lib.rs       | 37 +++++++++++++++++++++++++++++++
 tracing-journald/tests/journal.rs | 22 ++++++++++++++++++
 2 files changed, 59 insertions(+)

diff --git a/tracing-journald/src/lib.rs b/tracing-journald/src/lib.rs
index ac816058ca..fc7263086b 100644
--- a/tracing-journald/src/lib.rs
+++ b/tracing-journald/src/lib.rs
@@ -83,6 +83,7 @@ pub struct Layer {
     socket: UnixDatagram,
     field_prefix: Option,
     syslog_identifier: String,
+    additional_fields: Vec,
 }
 
 #[cfg(unix)]
@@ -107,6 +108,7 @@ impl Layer {
                     .map(|n| n.to_string_lossy().into_owned())
                     // If we fail to get the name of the current executable fall back to an empty string.
                     .unwrap_or_else(String::new),
+                additional_fields: Vec::new(),
             };
             // Check that we can talk to journald, by sending empty payload which journald discards.
             // However if the socket didn't exist or if none listened we'd get an error here.
@@ -148,6 +150,40 @@ impl Layer {
         self
     }
 
+    /// Adds fields that will get be passed to journald with every log entry.
+    ///
+    /// The input values of this function are interpreted as `(field, value)` pairs.
+    ///
+    /// This can for example be used to configure the syslog facility.
+    /// See [Journal Fields](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html)
+    /// and [journalctl](https://www.freedesktop.org/software/systemd/man/journalctl.html)
+    /// for more information.
+    ///
+    /// Fields specified using this method will be added to the journald
+    /// message alongside fields generated from the event's fields, its
+    /// metadata, and the span context. If the name of a field provided using
+    /// this method is the same as the name of a field generated by the
+    /// layer, both fields will be sent to journald.
+    ///
+    /// ```no_run
+    /// # use tracing_journald::Layer;
+    /// let layer = Layer::new()
+    ///     .unwrap()
+    ///     .with_custom_fields([("SYSLOG_FACILITY", "17")]);
+    /// ```
+    ///
+    pub fn with_custom_fields, U: AsRef<[u8]>>(
+        mut self,
+        fields: impl IntoIterator,
+    ) -> Self {
+        for (name, value) in fields {
+            put_field_length_encoded(&mut self.additional_fields, name.as_ref(), |buf| {
+                buf.extend_from_slice(value.as_ref())
+            })
+        }
+        self
+    }
+
     /// Returns the syslog identifier in use.
     pub fn syslog_identifier(&self) -> &str {
         &self.syslog_identifier
@@ -255,6 +291,7 @@ where
         put_field_length_encoded(&mut buf, "SYSLOG_IDENTIFIER", |buf| {
             write!(buf, "{}", self.syslog_identifier).unwrap()
         });
+        buf.extend_from_slice(&self.additional_fields);
 
         event.record(&mut EventVisitor::new(
             &mut buf,
diff --git a/tracing-journald/tests/journal.rs b/tracing-journald/tests/journal.rs
index 7cbcd24d15..c2f3010879 100644
--- a/tracing-journald/tests/journal.rs
+++ b/tracing-journald/tests/journal.rs
@@ -238,6 +238,28 @@ fn simple_metadata() {
     });
 }
 
+#[test]
+fn journal_fields() {
+    let sub = Layer::new()
+        .unwrap()
+        .with_field_prefix(None)
+        .with_custom_fields([("SYSLOG_FACILITY", "17")])
+        .with_custom_fields([("ABC", "dEf"), ("XYZ", "123")]);
+    with_journald_layer(sub, || {
+        info!(test.name = "journal_fields", "Hello World");
+
+        let message = retry_read_one_line_from_journal("journal_fields");
+        assert_eq!(message["MESSAGE"], "Hello World");
+        assert_eq!(message["PRIORITY"], "5");
+        assert_eq!(message["TARGET"], "journal");
+        assert_eq!(message["SYSLOG_FACILITY"], "17");
+        assert_eq!(message["ABC"], "dEf");
+        assert_eq!(message["XYZ"], "123");
+        assert!(message["CODE_FILE"].as_text().is_some());
+        assert!(message["CODE_LINE"].as_text().is_some());
+    });
+}
+
 #[test]
 fn span_metadata() {
     with_journald(|| {

From 068740345a41ef1bbb698499493eb2a984bce83d Mon Sep 17 00:00:00 2001
From: Joseph Perez 
Date: Wed, 6 Sep 2023 00:33:44 +0200
Subject: [PATCH 28/34] tracing: allow constant field names in macros (#2617)

I've found myself in the case where I wanted to have customized event field name
for different trait implementations. In fact, these implementations are
completely unrelated (in separate applications), so, in this use case, I find
more readable to have `foo="some_id"` and `bar=16` instead of `resource="foo"
value="some_id"` and `resource=bar value=16`

Because events only accept identifier or literal as field name, this is quite
cumbersome/impossible to do. A simple solution could be to make events accept
constant expression too; in my use case, I could then add a associated constant
to my trait.

This PR proposes a new syntax for using constant field names:
```rust
tracing::debug!({ CONSTANT_EXPR } = "foo");
```
This is the same syntax than constant expression, so it should be quite intuitive.

To avoid constant expression names conflict, internal variables of macro
expansion have been prefixed with `__`, e.g. `__CALLSITE`.

Co-authored-by: Joseph Perez 
Co-authored-by: Eliza Weisman 
---
 tracing/src/lib.rs     |  13 +++
 tracing/src/macros.rs  | 190 ++++++++++++++++++++++++++---------------
 tracing/tests/event.rs |  42 +++++++++
 tracing/tests/span.rs  |  30 +++++++
 4 files changed, 206 insertions(+), 69 deletions(-)

diff --git a/tracing/src/lib.rs b/tracing/src/lib.rs
index bcd0c6356c..679ca155ea 100644
--- a/tracing/src/lib.rs
+++ b/tracing/src/lib.rs
@@ -319,6 +319,19 @@
 //! # }
 //!```
 //!
+//! Constant expressions can also be used as field names. Constants
+//! must be enclosed in curly braces (`{}`) to indicate that the *value*
+//! of the constant is to be used as the field name, rather than the
+//! constant's name. For example:
+//! ```
+//! # use tracing::{span, Level};
+//! # fn main() {
+//! const RESOURCE_NAME: &str = "foo";
+//! // this span will have the field `foo = "some_id"`
+//! span!(Level::TRACE, "get", { RESOURCE_NAME } = "some_id");
+//! # }
+//!```
+//!
 //! The `?` sigil is shorthand that specifies a field should be recorded using
 //! its [`fmt::Debug`] implementation:
 //! ```
diff --git a/tracing/src/macros.rs b/tracing/src/macros.rs
index b5f232bf0e..5aa2afe2e5 100644
--- a/tracing/src/macros.rs
+++ b/tracing/src/macros.rs
@@ -24,7 +24,7 @@ macro_rules! span {
     (target: $target:expr, parent: $parent:expr, $lvl:expr, $name:expr, $($fields:tt)*) => {
         {
             use $crate::__macro_support::Callsite as _;
-            static CALLSITE: $crate::callsite::DefaultCallsite = $crate::callsite2! {
+            static __CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
                 name: $name,
                 kind: $crate::metadata::Kind::SPAN,
                 target: $target,
@@ -33,10 +33,10 @@ macro_rules! span {
             };
             let mut interest = $crate::subscriber::Interest::never();
             if $crate::level_enabled!($lvl)
-                && { interest = CALLSITE.interest(); !interest.is_never() }
-                && $crate::__macro_support::__is_enabled(CALLSITE.metadata(), interest)
+                && { interest = __CALLSITE.interest(); !interest.is_never() }
+                && $crate::__macro_support::__is_enabled(__CALLSITE.metadata(), interest)
             {
-                let meta = CALLSITE.metadata();
+                let meta = __CALLSITE.metadata();
                 // span with explicit parent
                 $crate::Span::child_of(
                     $parent,
@@ -44,9 +44,9 @@ macro_rules! span {
                     &$crate::valueset!(meta.fields(), $($fields)*),
                 )
             } else {
-                let span = $crate::__macro_support::__disabled_span(CALLSITE.metadata());
+                let span = $crate::__macro_support::__disabled_span(__CALLSITE.metadata());
                 $crate::if_log_enabled! { $lvl, {
-                    span.record_all(&$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
+                    span.record_all(&$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
                 }};
                 span
             }
@@ -55,7 +55,7 @@ macro_rules! span {
     (target: $target:expr, $lvl:expr, $name:expr, $($fields:tt)*) => {
         {
             use $crate::__macro_support::Callsite as _;
-            static CALLSITE: $crate::callsite::DefaultCallsite = $crate::callsite2! {
+            static __CALLSITE: $crate::callsite::DefaultCallsite = $crate::callsite2! {
                 name: $name,
                 kind: $crate::metadata::Kind::SPAN,
                 target: $target,
@@ -64,19 +64,19 @@ macro_rules! span {
             };
             let mut interest = $crate::subscriber::Interest::never();
             if $crate::level_enabled!($lvl)
-                && { interest = CALLSITE.interest(); !interest.is_never() }
-                && $crate::__macro_support::__is_enabled(CALLSITE.metadata(), interest)
+                && { interest = __CALLSITE.interest(); !interest.is_never() }
+                && $crate::__macro_support::__is_enabled(__CALLSITE.metadata(), interest)
             {
-                let meta = CALLSITE.metadata();
+                let meta = __CALLSITE.metadata();
                 // span with contextual parent
                 $crate::Span::new(
                     meta,
                     &$crate::valueset!(meta.fields(), $($fields)*),
                 )
             } else {
-                let span = $crate::__macro_support::__disabled_span(CALLSITE.metadata());
+                let span = $crate::__macro_support::__disabled_span(__CALLSITE.metadata());
                 $crate::if_log_enabled! { $lvl, {
-                    span.record_all(&$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
+                    span.record_all(&$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
                 }};
                 span
             }
@@ -586,7 +586,7 @@ macro_rules! event {
     // Name / target / parent.
     (name: $name:expr, target: $target:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* } )=> ({
         use $crate::__macro_support::Callsite as _;
-        static CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
+        static __CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
             name: $name,
             kind: $crate::metadata::Kind::EVENT,
             target: $target,
@@ -595,29 +595,29 @@ macro_rules! event {
         };
 
         let enabled = $crate::level_enabled!($lvl) && {
-            let interest = CALLSITE.interest();
-            !interest.is_never() && CALLSITE.is_enabled(interest)
+            let interest = __CALLSITE.interest();
+            !interest.is_never() && $crate::__macro_support::__is_enabled(__CALLSITE.metadata(), interest)
         };
         if enabled {
             (|value_set: $crate::field::ValueSet| {
                 $crate::__tracing_log!(
                     $lvl,
-                    CALLSITE,
+                    __CALLSITE,
                     &value_set
                 );
-                let meta = CALLSITE.metadata();
+                let meta = __CALLSITE.metadata();
                 // event with explicit parent
                 $crate::Event::child_of(
                     $parent,
                     meta,
                     &value_set
                 );
-            })($crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
+            })($crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
         } else {
             $crate::__tracing_log!(
                 $lvl,
-                CALLSITE,
-                &$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*)
+                __CALLSITE,
+                &$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*)
             );
         }
     });
@@ -640,7 +640,7 @@ macro_rules! event {
     // Name / target.
     (name: $name:expr, target: $target:expr, $lvl:expr, { $($fields:tt)* } )=> ({
         use $crate::__macro_support::Callsite as _;
-        static CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
+        static __CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
             name: $name,
             kind: $crate::metadata::Kind::EVENT,
             target: $target,
@@ -648,12 +648,12 @@ macro_rules! event {
             fields: $($fields)*
         };
         let enabled = $crate::level_enabled!($lvl) && {
-            let interest = CALLSITE.interest();
-            !interest.is_never() && CALLSITE.is_enabled(interest)
+            let interest = __CALLSITE.interest();
+            !interest.is_never() && $crate::__macro_support::__is_enabled(__CALLSITE.metadata(), interest)
         };
         if enabled {
             (|value_set: $crate::field::ValueSet| {
-                let meta = CALLSITE.metadata();
+                let meta = __CALLSITE.metadata();
                 // event with contextual parent
                 $crate::Event::dispatch(
                     meta,
@@ -661,15 +661,15 @@ macro_rules! event {
                 );
                 $crate::__tracing_log!(
                     $lvl,
-                    CALLSITE,
+                    __CALLSITE,
                     &value_set
                 );
-            })($crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
+            })($crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
         } else {
             $crate::__tracing_log!(
                 $lvl,
-                CALLSITE,
-                &$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*)
+                __CALLSITE,
+                &$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*)
             );
         }
     });
@@ -691,7 +691,7 @@ macro_rules! event {
     // Target / parent.
     (target: $target:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* } )=> ({
         use $crate::__macro_support::Callsite as _;
-        static CALLSITE: $crate::callsite::DefaultCallsite = $crate::callsite2! {
+        static __CALLSITE: $crate::callsite::DefaultCallsite = $crate::callsite2! {
             name: $crate::__macro_support::concat!(
                 "event ",
                 file!(),
@@ -705,29 +705,29 @@ macro_rules! event {
         };
 
         let enabled = $crate::level_enabled!($lvl) && {
-            let interest = CALLSITE.interest();
-            !interest.is_never() && $crate::__macro_support::__is_enabled(CALLSITE.metadata(), interest)
+            let interest = __CALLSITE.interest();
+            !interest.is_never() && $crate::__macro_support::__is_enabled(__CALLSITE.metadata(), interest)
         };
         if enabled {
             (|value_set: $crate::field::ValueSet| {
                 $crate::__tracing_log!(
                     $lvl,
-                    CALLSITE,
+                    __CALLSITE,
                     &value_set
                 );
-                let meta = CALLSITE.metadata();
+                let meta = __CALLSITE.metadata();
                 // event with explicit parent
                 $crate::Event::child_of(
                     $parent,
                     meta,
                     &value_set
                 );
-            })($crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
+            })($crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
         } else {
             $crate::__tracing_log!(
                 $lvl,
-                CALLSITE,
-                &$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*)
+                __CALLSITE,
+                &$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*)
             );
         }
     });
@@ -749,7 +749,7 @@ macro_rules! event {
     // Name / parent.
     (name: $name:expr, parent: $parent:expr, $lvl:expr, { $($fields:tt)* } )=> ({
         use $crate::__macro_support::Callsite as _;
-        static CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
+        static __CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
             name: $name,
             kind: $crate::metadata::Kind::EVENT,
             target: module_path!(),
@@ -758,29 +758,29 @@ macro_rules! event {
         };
 
         let enabled = $crate::level_enabled!($lvl) && {
-            let interest = CALLSITE.interest();
-            !interest.is_never() && CALLSITE.is_enabled(interest)
+            let interest = __CALLSITE.interest();
+            !interest.is_never() && __CALLSITE.is_enabled(interest)
         };
         if enabled {
             (|value_set: $crate::field::ValueSet| {
                 $crate::__tracing_log!(
                     $lvl,
-                    CALLSITE,
+                    __CALLSITE,
                     &value_set
                 );
-                let meta = CALLSITE.metadata();
+                let meta = __CALLSITE.metadata();
                 // event with explicit parent
                 $crate::Event::child_of(
                     $parent,
                     meta,
                     &value_set
                 );
-            })($crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
+            })($crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
         } else {
             $crate::__tracing_log!(
                 $lvl,
-                CALLSITE,
-                &$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*)
+                __CALLSITE,
+                &$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*)
             );
         }
     });
@@ -802,7 +802,7 @@ macro_rules! event {
     // Name.
     (name: $name:expr, $lvl:expr, { $($fields:tt)* } )=> ({
         use $crate::__macro_support::Callsite as _;
-        static CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
+        static __CALLSITE: $crate::__macro_support::MacroCallsite = $crate::callsite2! {
             name: $name,
             kind: $crate::metadata::Kind::EVENT,
             target: module_path!(),
@@ -810,12 +810,12 @@ macro_rules! event {
             fields: $($fields)*
         };
         let enabled = $crate::level_enabled!($lvl) && {
-            let interest = CALLSITE.interest();
-            !interest.is_never() && CALLSITE.is_enabled(interest)
+            let interest = __CALLSITE.interest();
+            !interest.is_never() && $crate::__macro_support::__is_enabled(__CALLSITE.metadata(), interest)
         };
         if enabled {
             (|value_set: $crate::field::ValueSet| {
-                let meta = CALLSITE.metadata();
+                let meta = __CALLSITE.metadata();
                 // event with contextual parent
                 $crate::Event::dispatch(
                     meta,
@@ -823,15 +823,15 @@ macro_rules! event {
                 );
                 $crate::__tracing_log!(
                     $lvl,
-                    CALLSITE,
+                    __CALLSITE,
                     &value_set
                 );
-            })($crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
+            })($crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
         } else {
             $crate::__tracing_log!(
                 $lvl,
-                CALLSITE,
-                &$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*)
+                __CALLSITE,
+                &$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*)
             );
         }
     });
@@ -852,7 +852,7 @@ macro_rules! event {
     // Target.
     (target: $target:expr, $lvl:expr, { $($fields:tt)* } )=> ({
         use $crate::__macro_support::Callsite as _;
-        static CALLSITE: $crate::callsite::DefaultCallsite = $crate::callsite2! {
+        static __CALLSITE: $crate::callsite::DefaultCallsite = $crate::callsite2! {
             name: $crate::__macro_support::concat!(
                 "event ",
                 file!(),
@@ -865,12 +865,12 @@ macro_rules! event {
             fields: $($fields)*
         };
         let enabled = $crate::level_enabled!($lvl) && {
-            let interest = CALLSITE.interest();
-            !interest.is_never() && $crate::__macro_support::__is_enabled(CALLSITE.metadata(), interest)
+            let interest = __CALLSITE.interest();
+            !interest.is_never() && $crate::__macro_support::__is_enabled(__CALLSITE.metadata(), interest)
         };
         if enabled {
             (|value_set: $crate::field::ValueSet| {
-                let meta = CALLSITE.metadata();
+                let meta = __CALLSITE.metadata();
                 // event with contextual parent
                 $crate::Event::dispatch(
                     meta,
@@ -878,15 +878,15 @@ macro_rules! event {
                 );
                 $crate::__tracing_log!(
                     $lvl,
-                    CALLSITE,
+                    __CALLSITE,
                     &value_set
                 );
-            })($crate::valueset!(CALLSITE.metadata().fields(), $($fields)*));
+            })($crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*));
         } else {
             $crate::__tracing_log!(
                 $lvl,
-                CALLSITE,
-                &$crate::valueset!(CALLSITE.metadata().fields(), $($fields)*)
+                __CALLSITE,
+                &$crate::valueset!(__CALLSITE.metadata().fields(), $($fields)*)
             );
         }
     });
@@ -1185,7 +1185,7 @@ macro_rules! enabled {
     (kind: $kind:expr, target: $target:expr, $lvl:expr, { $($fields:tt)* } )=> ({
         if $crate::level_enabled!($lvl) {
             use $crate::__macro_support::Callsite as _;
-            static CALLSITE: $crate::callsite::DefaultCallsite = $crate::callsite2! {
+            static __CALLSITE: $crate::callsite::DefaultCallsite = $crate::callsite2! {
                 name: $crate::__macro_support::concat!(
                     "enabled ",
                     file!(),
@@ -1197,9 +1197,9 @@ macro_rules! enabled {
                 level: $lvl,
                 fields: $($fields)*
             };
-            let interest = CALLSITE.interest();
-            if !interest.is_never() && $crate::__macro_support::__is_enabled(CALLSITE.metadata(), interest) {
-                let meta = CALLSITE.metadata();
+            let interest = __CALLSITE.interest();
+            if !interest.is_never() && $crate::__macro_support::__is_enabled(__CALLSITE.metadata(), interest) {
+                let meta = __CALLSITE.metadata();
                 $crate::dispatcher::get_default(|current| current.enabled(meta))
             } else {
                 false
@@ -2716,13 +2716,13 @@ macro_rules! callsite {
                 target: $target,
                 level: $lvl,
                 fields: $crate::fieldset!( $($fields)* ),
-                callsite: &CALLSITE,
+                callsite: &__CALLSITE,
                 kind: $kind,
             }
         };
-        static CALLSITE: $crate::callsite::DefaultCallsite = $crate::callsite::DefaultCallsite::new(&META);
-        CALLSITE.register();
-        &CALLSITE
+        static __CALLSITE: $crate::callsite::DefaultCallsite = $crate::callsite::DefaultCallsite::new(&META);
+        __CALLSITE.register();
+        &__CALLSITE
     }};
 }
 
@@ -2766,7 +2766,7 @@ macro_rules! callsite2 {
                 target: $target,
                 level: $lvl,
                 fields: $crate::fieldset!( $($fields)* ),
-                callsite: &CALLSITE,
+                callsite: &__CALLSITE,
                 kind: $kind,
             }
         };
@@ -2920,6 +2920,47 @@ macro_rules! valueset {
         )
     };
 
+    // Handle constant names
+    (@ { $(,)* $($out:expr),* }, $next:expr, { $k:expr } = ?$val:expr, $($rest:tt)*) => {
+        $crate::valueset!(
+            @ { $($out),*, (&$next, Some(&debug(&$val) as &dyn Value)) },
+            $next,
+            $($rest)*
+        )
+    };
+    (@ { $(,)* $($out:expr),* }, $next:expr, { $k:expr } = %$val:expr, $($rest:tt)*) => {
+        $crate::valueset!(
+            @ { $($out),*, (&$next, Some(&display(&$val) as &dyn Value)) },
+            $next,
+            $($rest)*
+        )
+    };
+    (@ { $(,)* $($out:expr),* }, $next:expr, { $k:expr } = $val:expr, $($rest:tt)*) => {
+        $crate::valueset!(
+            @ { $($out),*, (&$next, Some(&$val as &dyn Value)) },
+            $next,
+            $($rest)*
+        )
+    };
+    (@ { $(,)* $($out:expr),* }, $next:expr, { $k:expr } = ?$val:expr) => {
+        $crate::valueset!(
+            @ { $($out),*, (&$next, Some(&debug(&$val) as &dyn Value)) },
+            $next,
+        )
+    };
+    (@ { $(,)* $($out:expr),* }, $next:expr, { $k:expr } = %$val:expr) => {
+        $crate::valueset!(
+            @ { $($out),*, (&$next, Some(&display(&$val) as &dyn Value)) },
+            $next,
+        )
+    };
+    (@ { $(,)* $($out:expr),* }, $next:expr, { $k:expr } = $val:expr) => {
+        $crate::valueset!(
+            @ { $($out),*, (&$next, Some(&$val as &dyn Value)) },
+            $next,
+        )
+    };
+
     // Remainder is unparsable, but exists --- must be format args!
     (@ { $(,)* $($out:expr),* }, $next:expr, $($rest:tt)+) => {
         $crate::valueset!(@ { (&$next, ::core::option::Option::Some(&format_args!($($rest)+) as &dyn Value)), $($out),* }, $next, )
@@ -2989,6 +3030,17 @@ macro_rules! fieldset {
         $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
     };
 
+    // Handle constant names
+    (@ { $(,)* $($out:expr),* } { $k:expr } = ?$val:expr, $($rest:tt)*) => {
+        $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
+    };
+    (@ { $(,)* $($out:expr),* } { $k:expr } = %$val:expr, $($rest:tt)*) => {
+        $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
+    };
+    (@ { $(,)* $($out:expr),* } { $k:expr } = $val:expr, $($rest:tt)*) => {
+        $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
+    };
+
     // Remainder is unparseable, but exists --- must be format args!
     (@ { $(,)* $($out:expr),* } $($rest:tt)+) => {
         $crate::fieldset!(@ { "message", $($out),*, })
diff --git a/tracing/tests/event.rs b/tracing/tests/event.rs
index 5a0dc9ce4a..0be7c0bc56 100644
--- a/tracing/tests/event.rs
+++ b/tracing/tests/event.rs
@@ -510,3 +510,45 @@ fn string_field() {
 
     handle.assert_finished();
 }
+
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+#[test]
+fn constant_field_name() {
+    let expect_event = || {
+        expect::event().with_fields(
+            expect::field("foo")
+                .with_value(&"bar")
+                .and(expect::field("constant string").with_value(&"also works"))
+                .and(expect::field("foo.bar").with_value(&"baz"))
+                .and(expect::field("message").with_value(&debug(format_args!("quux"))))
+                .only(),
+        )
+    };
+    let (subscriber, handle) = subscriber::mock()
+        .event(expect_event())
+        .event(expect_event())
+        .only()
+        .run_with_handle();
+
+    with_default(subscriber, || {
+        const FOO: &str = "foo";
+        tracing::event!(
+            Level::INFO,
+            { std::convert::identity(FOO) } = "bar",
+            { "constant string" } = "also works",
+            foo.bar = "baz",
+            "quux"
+        );
+        tracing::event!(
+            Level::INFO,
+            {
+                { std::convert::identity(FOO) } = "bar",
+                { "constant string" } = "also works",
+                foo.bar = "baz",
+            },
+            "quux"
+        );
+    });
+
+    handle.assert_finished();
+}
diff --git a/tracing/tests/span.rs b/tracing/tests/span.rs
index d75f3a89a8..09f1be8954 100644
--- a/tracing/tests/span.rs
+++ b/tracing/tests/span.rs
@@ -836,3 +836,33 @@ fn both_shorthands() {
 
     handle.assert_finished();
 }
+
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+#[test]
+fn constant_field_name() {
+    let (subscriber, handle) = subscriber::mock()
+        .new_span(
+            expect::span().named("my_span").with_field(
+                expect::field("foo")
+                    .with_value(&"bar")
+                    .and(expect::field("constant string").with_value(&"also works"))
+                    .and(expect::field("foo.bar").with_value(&"baz"))
+                    .only(),
+            ),
+        )
+        .only()
+        .run_with_handle();
+
+    with_default(subscriber, || {
+        const FOO: &str = "foo";
+        tracing::span!(
+            Level::TRACE,
+            "my_span",
+            { std::convert::identity(FOO) } = "bar",
+            { "constant string" } = "also works",
+            foo.bar = "baz",
+        );
+    });
+
+    handle.assert_finished();
+}

From 75f0dbf7f44dad949af3234592899fd54fdbd2fb Mon Sep 17 00:00:00 2001
From: Aaron Roney 
Date: Wed, 6 Sep 2023 16:09:29 -0700
Subject: [PATCH 29/34] docs: add `axum-insights` to relevant crates. (#2713)

## Motivation

Adding a relevant library to the list of `tracing`-enabled crates.

## Solution

Added to READMEs and documentation.
---
 README.md          | 2 ++
 tracing/README.md  | 2 ++
 tracing/src/lib.rs | 2 ++
 3 files changed, 6 insertions(+)

diff --git a/README.md b/README.md
index 2656fe04a1..58a841b109 100644
--- a/README.md
+++ b/README.md
@@ -369,6 +369,7 @@ are not maintained by the `tokio` project. These include:
 - [`tracing-actix-web`] provides `tracing` integration for the `actix-web` web framework.
 - [`tracing-actix`] provides `tracing` integration for the `actix` actor
   framework.
+- [`axum-insights`] provides `tracing` integration and Application insights export for the `axum` web framework.
 - [`tracing-gelf`] implements a subscriber for exporting traces in Greylog
   GELF format.
 - [`tracing-coz`] provides integration with the [coz] causal profiler
@@ -413,6 +414,7 @@ please let us know!)
 [honeycomb.io]: https://www.honeycomb.io/
 [`tracing-actix`]: https://crates.io/crates/tracing-actix
 [`tracing-actix-web`]: https://crates.io/crates/tracing-actix-web
+[`axum-insights`]: https://crates.io/crates/axum-insights
 [`tracing-gelf`]: https://crates.io/crates/tracing-gelf
 [`tracing-coz`]: https://crates.io/crates/tracing-coz
 [coz]: https://github.com/plasma-umass/coz
diff --git a/tracing/README.md b/tracing/README.md
index 443e51458d..a42636f336 100644
--- a/tracing/README.md
+++ b/tracing/README.md
@@ -379,6 +379,7 @@ maintained by the `tokio` project. These include:
 - [`tracing-distributed`] Provides a generic implementation of a layer that reports traces spanning multiple machines to some backend.
 - [`tracing-actix`] provides `tracing` integration for the `actix` actor
   framework.
+- [`axum-insights`] provides `tracing` integration and Application insights export for the `axum` web framework.
 - [`tracing-gelf`] implements a subscriber for exporting traces in Greylog
   GELF format.
 - [`tracing-coz`] provides integration with the [coz] causal profiler
@@ -407,6 +408,7 @@ please let us know! We'd love to add your project to the list!
 [`tracing-distributed`]: https://crates.io/crates/tracing-distributed
 [honeycomb.io]: https://www.honeycomb.io/
 [`tracing-actix`]: https://crates.io/crates/tracing-actix
+[`axum-insights`]: https://crates.io/crates/axum-insights
 [`tracing-gelf`]: https://crates.io/crates/tracing-gelf
 [`tracing-coz`]: https://crates.io/crates/tracing-coz
 [coz]: https://github.com/plasma-umass/coz
diff --git a/tracing/src/lib.rs b/tracing/src/lib.rs
index 679ca155ea..258cbe5906 100644
--- a/tracing/src/lib.rs
+++ b/tracing/src/lib.rs
@@ -725,6 +725,7 @@
 //!  - [`tracing-actix-web`] provides `tracing` integration for the `actix-web` web framework.
 //!  - [`tracing-actix`] provides `tracing` integration for the `actix` actor
 //!    framework.
+//!  - [`axum-insights`] provides `tracing` integration and Application insights export for the `axum` web framework.
 //!  - [`tracing-gelf`] implements a subscriber for exporting traces in Greylog
 //!    GELF format.
 //!  - [`tracing-coz`] provides integration with the [coz] causal profiler
@@ -766,6 +767,7 @@
 //! [honeycomb.io]: https://www.honeycomb.io/
 //! [`tracing-actix-web`]: https://crates.io/crates/tracing-actix-web
 //! [`tracing-actix`]: https://crates.io/crates/tracing-actix
+//! [`axum-insights`]: https://crates.io/crates/axum-insights
 //! [`tracing-gelf`]: https://crates.io/crates/tracing-gelf
 //! [`tracing-coz`]: https://crates.io/crates/tracing-coz
 //! [coz]: https://github.com/plasma-umass/coz

From 66d96cdb576d477d7e6a225320d1ed3b5ff56ddd Mon Sep 17 00:00:00 2001
From: Shayne Fletcher 
Date: Mon, 25 Sep 2023 13:51:03 -0400
Subject: [PATCH 30/34] [tracing-subscriber]: add chrono crate implementations
 of FormatTime (#2690)

Issue https://github.com/tokio-rs/tracing/issues/2080 explains that it's not
possible to soundly use
[`tracing_subscriber::fmt::time::LocalTime`](https://docs.rs/tracing-subscriber/latest/tracing_subscriber/fmt/time/struct.LocalTime.html)
in a multithreaded context. It proposes adding alternative time formatters that
use the [chrono crate](https://docs.rs/chrono/latest/chrono/) to workaround
which is what this PR offers.

A new source file 'chrono_crate.rs' is added to the 'tracing-subscriber'
package implementing `mod chrono_crate` providing two new tag types `LocalTime`
and `Utc` with associated `time::FormatTime` trait implementations that call
`chrono::Local::now().to_rfc3339()` and `chrono::Utc::now().to_rfc3339()`
respectively. Simple unit-tests of the new functionality accompany the
additions.
---------

Co-authored-by: David Barsky 
Co-authored-by: Shayne Fletcher 
---
 tracing-subscriber/Cargo.toml                 |   1 +
 .../src/fmt/time/chrono_crate.rs              | 177 ++++++++++++++++++
 tracing-subscriber/src/fmt/time/mod.rs        |  13 ++
 3 files changed, 191 insertions(+)
 create mode 100644 tracing-subscriber/src/fmt/time/chrono_crate.rs

diff --git a/tracing-subscriber/Cargo.toml b/tracing-subscriber/Cargo.toml
index 3fbeb2feab..3ee5a99e41 100644
--- a/tracing-subscriber/Cargo.toml
+++ b/tracing-subscriber/Cargo.toml
@@ -59,6 +59,7 @@ tracing-serde = { path = "../tracing-serde", version = "0.1.3", optional = true
 
 # opt-in deps
 parking_lot = { version = "0.12.1", optional = true }
+chrono = { version = "0.4.26", default-features = false, features = ["clock", "std"], optional = true }
 
 # registry
 sharded-slab = { version = "0.1.4", optional = true }
diff --git a/tracing-subscriber/src/fmt/time/chrono_crate.rs b/tracing-subscriber/src/fmt/time/chrono_crate.rs
new file mode 100644
index 0000000000..1a831efa1b
--- /dev/null
+++ b/tracing-subscriber/src/fmt/time/chrono_crate.rs
@@ -0,0 +1,177 @@
+use crate::fmt::format::Writer;
+use crate::fmt::time::FormatTime;
+
+use std::sync::Arc;
+
+/// Formats [local time]s and [UTC time]s with `FormatTime` implementations
+/// that use the [`chrono` crate].
+///
+/// [local time]: [`chrono::offset::Local`]
+/// [UTC time]: [`chrono::offset::Utc`]
+/// [`chrono` crate]: [`chrono`]
+
+/// Formats the current [local time] using a [formatter] from the [`chrono`] crate.
+///
+/// [local time]: chrono::Local::now()
+/// [formatter]: chrono::format
+#[cfg_attr(docsrs, doc(cfg(feature = "chrono")))]
+#[derive(Debug, Clone, Eq, PartialEq, Default)]
+pub struct ChronoLocal {
+    format: Arc,
+}
+
+impl ChronoLocal {
+    /// Format the time using the [`RFC 3339`] format
+    /// (a subset of [`ISO 8601`]).
+    ///
+    /// [`RFC 3339`]: https://tools.ietf.org/html/rfc3339
+    /// [`ISO 8601`]: https://en.wikipedia.org/wiki/ISO_8601
+    pub fn rfc_3339() -> Self {
+        Self {
+            format: Arc::new(ChronoFmtType::Rfc3339),
+        }
+    }
+
+    /// Format the time using the given format string.
+    ///
+    /// See [`chrono::format::strftime`] for details on the supported syntax.
+    pub fn new(format_string: String) -> Self {
+        Self {
+            format: Arc::new(ChronoFmtType::Custom(format_string)),
+        }
+    }
+}
+
+impl FormatTime for ChronoLocal {
+    fn format_time(&self, w: &mut Writer<'_>) -> alloc::fmt::Result {
+        let t = chrono::Local::now();
+        match self.format.as_ref() {
+            ChronoFmtType::Rfc3339 => {
+                use chrono::format::{Fixed, Item};
+                write!(
+                    w,
+                    "{}",
+                    t.format_with_items(core::iter::once(Item::Fixed(Fixed::RFC3339)))
+                )
+            }
+            ChronoFmtType::Custom(fmt) => {
+                write!(w, "{}", t.format(fmt))
+            }
+        }
+    }
+}
+
+/// Formats the current [UTC time] using a [formatter] from the [`chrono`] crate.
+///
+/// [UTC time]: chrono::Utc::now()
+/// [formatter]: chrono::format
+#[cfg_attr(docsrs, doc(cfg(feature = "chrono")))]
+#[derive(Debug, Clone, Eq, PartialEq, Default)]
+pub struct ChronoUtc {
+    format: Arc,
+}
+
+impl ChronoUtc {
+    /// Format the time using the [`RFC 3339`] format
+    /// (a subset of [`ISO 8601`]).
+    ///
+    /// [`RFC 3339`]: https://tools.ietf.org/html/rfc3339
+    /// [`ISO 8601`]: https://en.wikipedia.org/wiki/ISO_8601
+    pub fn rfc_3339() -> Self {
+        Self {
+            format: Arc::new(ChronoFmtType::Rfc3339),
+        }
+    }
+
+    /// Format the time using the given format string.
+    ///
+    /// See [`chrono::format::strftime`] for details on the supported syntax.
+    pub fn new(format_string: String) -> Self {
+        Self {
+            format: Arc::new(ChronoFmtType::Custom(format_string)),
+        }
+    }
+}
+
+impl FormatTime for ChronoUtc {
+    fn format_time(&self, w: &mut Writer<'_>) -> alloc::fmt::Result {
+        let t = chrono::Utc::now();
+        match self.format.as_ref() {
+            ChronoFmtType::Rfc3339 => w.write_str(&t.to_rfc3339()),
+            ChronoFmtType::Custom(fmt) => w.write_str(&format!("{}", t.format(fmt))),
+        }
+    }
+}
+
+/// The RFC 3339 format is used by default but a custom format string
+/// can be used. See [`chrono::format::strftime`]for details on
+/// the supported syntax.
+///
+/// [`chrono::format::strftime`]: https://docs.rs/chrono/0.4.9/chrono/format/strftime/index.html
+#[derive(Debug, Clone, Eq, PartialEq)]
+enum ChronoFmtType {
+    /// Format according to the RFC 3339 convention.
+    Rfc3339,
+    /// Format according to a custom format string.
+    Custom(String),
+}
+
+impl Default for ChronoFmtType {
+    fn default() -> Self {
+        ChronoFmtType::Rfc3339
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::fmt::format::Writer;
+    use crate::fmt::time::FormatTime;
+
+    use std::sync::Arc;
+
+    use super::ChronoFmtType;
+    use super::ChronoLocal;
+    use super::ChronoUtc;
+
+    #[test]
+    fn test_chrono_format_time_utc_default() {
+        let mut buf = String::new();
+        let mut dst: Writer<'_> = Writer::new(&mut buf);
+        assert!(FormatTime::format_time(&ChronoUtc::default(), &mut dst).is_ok());
+        // e.g. `buf` contains "2023-08-18T19:05:08.662499+00:00"
+        assert!(chrono::DateTime::parse_from_str(&buf, "%FT%H:%M:%S%.6f%z").is_ok());
+    }
+
+    #[test]
+    fn test_chrono_format_time_utc_custom() {
+        let fmt = ChronoUtc {
+            format: Arc::new(ChronoFmtType::Custom("%a %b %e %T %Y".to_owned())),
+        };
+        let mut buf = String::new();
+        let mut dst: Writer<'_> = Writer::new(&mut buf);
+        assert!(FormatTime::format_time(&fmt, &mut dst).is_ok());
+        // e.g. `buf` contains "Wed Aug 23 15:53:23 2023"
+        assert!(chrono::NaiveDateTime::parse_from_str(&buf, "%a %b %e %T %Y").is_ok());
+    }
+
+    #[test]
+    fn test_chrono_format_time_local_default() {
+        let mut buf = String::new();
+        let mut dst: Writer<'_> = Writer::new(&mut buf);
+        assert!(FormatTime::format_time(&ChronoLocal::default(), &mut dst).is_ok());
+        // e.g. `buf` contains "2023-08-18T14:59:08.662499-04:00".
+        assert!(chrono::DateTime::parse_from_str(&buf, "%FT%H:%M:%S%.6f%z").is_ok());
+    }
+
+    #[test]
+    fn test_chrono_format_time_local_custom() {
+        let fmt = ChronoLocal {
+            format: Arc::new(ChronoFmtType::Custom("%a %b %e %T %Y".to_owned())),
+        };
+        let mut buf = String::new();
+        let mut dst: Writer<'_> = Writer::new(&mut buf);
+        assert!(FormatTime::format_time(&fmt, &mut dst).is_ok());
+        // e.g. `buf` contains "Wed Aug 23 15:55:46 2023".
+        assert!(chrono::NaiveDateTime::parse_from_str(&buf, "%a %b %e %T %Y").is_ok());
+    }
+}
diff --git a/tracing-subscriber/src/fmt/time/mod.rs b/tracing-subscriber/src/fmt/time/mod.rs
index 5ba6698194..48f34d18d2 100644
--- a/tracing-subscriber/src/fmt/time/mod.rs
+++ b/tracing-subscriber/src/fmt/time/mod.rs
@@ -7,6 +7,7 @@ mod datetime;
 
 #[cfg(feature = "time")]
 mod time_crate;
+
 #[cfg(feature = "time")]
 #[cfg_attr(docsrs, doc(cfg(feature = "time")))]
 pub use time_crate::UtcTime;
@@ -19,6 +20,18 @@ pub use time_crate::LocalTime;
 #[cfg_attr(docsrs, doc(cfg(feature = "time")))]
 pub use time_crate::OffsetTime;
 
+/// [`chrono`]-based implementation for [`FormatTime`].
+#[cfg(feature = "chrono")]
+mod chrono_crate;
+
+#[cfg(feature = "chrono")]
+#[cfg_attr(docsrs, doc(cfg(feature = "chrono")))]
+pub use chrono_crate::ChronoLocal;
+
+#[cfg(feature = "chrono")]
+#[cfg_attr(docsrs, doc(cfg(feature = "chrono")))]
+pub use chrono_crate::ChronoUtc;
+
 /// A type that can measure and format the current time.
 ///
 /// This trait is used by `Format` to include a timestamp with each `Event` when it is logged.

From ffb1b115b2047faacebae9e8c2d4b7b27d4cc319 Mon Sep 17 00:00:00 2001
From: David Barsky 
Date: Wed, 27 Sep 2023 13:33:05 -0700
Subject: [PATCH 31/34] test: remove potentially problematic test (#2728)

---
 tracing/tests/macros_redefined_core.rs | 18 ------------------
 1 file changed, 18 deletions(-)
 delete mode 100644 tracing/tests/macros_redefined_core.rs

diff --git a/tracing/tests/macros_redefined_core.rs b/tracing/tests/macros_redefined_core.rs
deleted file mode 100644
index d830dcdb02..0000000000
--- a/tracing/tests/macros_redefined_core.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-extern crate self as core;
-
-use tracing::{enabled, event, span, Level};
-
-#[test]
-fn span() {
-    span!(Level::DEBUG, "foo");
-}
-
-#[test]
-fn event() {
-    event!(Level::DEBUG, "foo");
-}
-
-#[test]
-fn enabled() {
-    enabled!(Level::DEBUG);
-}

From b661e8484854d96ed2aa7d9d55c245f2cc5fac30 Mon Sep 17 00:00:00 2001
From: David Barsky 
Date: Thu, 28 Sep 2023 16:22:44 -0700
Subject: [PATCH 32/34] attributes: bump minimum version of proc-macro2 to
 1.0.60 (#2732)

As part of landing #2728, I noticed that the `-Zminimal-versions` check fails
due to proc-macro2 1.0.40 referencing a since-removed, nightly-only
feature (`proc_macro_span_shrink`). Since this change doesn't change the MSRV
of `proc-macro2` (or `tracing`, for that matter), this feels like a safe change
to make.
---
 tracing-attributes/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tracing-attributes/Cargo.toml b/tracing-attributes/Cargo.toml
index 67e546f43a..9c126ad81b 100644
--- a/tracing-attributes/Cargo.toml
+++ b/tracing-attributes/Cargo.toml
@@ -39,7 +39,7 @@ proc-macro = true
 async-await = []
 
 [dependencies]
-proc-macro2 = "1.0.40"
+proc-macro2 = "1.0.60"
 syn = { version = "2.0", default-features = false, features = ["full", "parsing", "printing", "visit-mut", "clone-impls", "extra-traits", "proc-macro"] }
 quote = "1.0.20"
 

From f875c16be50d412eabbca76580cdc4f76d6806de Mon Sep 17 00:00:00 2001
From: Jeremy Fitzhardinge 
Date: Thu, 28 Sep 2023 16:57:49 -0700
Subject: [PATCH 33/34] subscriber: Implement layer::Filter for Option
 (#2407)

It's currently awkward to have an optional per-layer filter.

Implement `Filter` for `Option where F: Filter`, following the example
of `Layer`. A `None` filter passes everything through.

Also, it looks like Filter for Arc/Box doesn't pass through all the methods, so
extend the `filter_impl_body` macro to include them.

This also adds a couple of tests and updates the docs.

---------

Co-authored-by: David Barsky 
Co-authored-by: Ryan Johnson 
Co-authored-by: Eliza Weisman 
---
 .../src/filter/layer_filters/mod.rs           | 107 ++++++++++++-
 tracing-subscriber/src/layer/mod.rs           |  18 +++
 .../tests/layer_filters/main.rs               |   5 +-
 .../tests/layer_filters/option.rs             | 143 ++++++++++++++++++
 tracing-subscriber/tests/layer_filters/vec.rs |   4 +-
 .../tests/option_filter_interest_caching.rs   |  53 +++++++
 .../vec_subscriber_filter_interests_cached.rs |   2 +-
 tracing/tests/no_subscriber.rs                |   2 +-
 8 files changed, 324 insertions(+), 10 deletions(-)
 create mode 100644 tracing-subscriber/tests/layer_filters/option.rs
 create mode 100644 tracing-subscriber/tests/option_filter_interest_caching.rs

diff --git a/tracing-subscriber/src/filter/layer_filters/mod.rs b/tracing-subscriber/src/filter/layer_filters/mod.rs
index e50ee6f007..a8b3ef7a1d 100644
--- a/tracing-subscriber/src/filter/layer_filters/mod.rs
+++ b/tracing-subscriber/src/filter/layer_filters/mod.rs
@@ -351,10 +351,10 @@ pub trait FilterExt: layer::Filter {
     //  globally applied to events where it doesn't today, since we can't know
     //  what `event_enabled` will say until we have the event to call it with.
     ///
-    /// [`Filter`]: crate::subscribe::Filter
-    /// [`enabled`]: crate::subscribe::Filter::enabled
-    /// [`event_enabled`]: crate::subscribe::Filter::event_enabled
-    /// [`callsite_enabled`]: crate::subscribe::Filter::callsite_enabled
+    /// [`Filter`]: crate::layer::Filter
+    /// [`enabled`]: crate::layer::Filter::enabled
+    /// [`event_enabled`]: crate::layer::Filter::event_enabled
+    /// [`callsite_enabled`]: crate::layer::Filter::callsite_enabled
     fn not(self) -> combinator::Not
     where
         Self: Sized,
@@ -478,6 +478,36 @@ macro_rules! filter_impl_body {
         fn max_level_hint(&self) -> Option {
             self.deref().max_level_hint()
         }
+
+        #[inline]
+        fn event_enabled(&self, event: &Event<'_>, cx: &Context<'_, S>) -> bool {
+            self.deref().event_enabled(event, cx)
+        }
+
+        #[inline]
+        fn on_new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
+            self.deref().on_new_span(attrs, id, ctx)
+        }
+
+        #[inline]
+        fn on_record(&self, id: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
+            self.deref().on_record(id, values, ctx)
+        }
+
+        #[inline]
+        fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
+            self.deref().on_enter(id, ctx)
+        }
+
+        #[inline]
+        fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
+            self.deref().on_exit(id, ctx)
+        }
+
+        #[inline]
+        fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
+            self.deref().on_close(id, ctx)
+        }
     };
 }
 
@@ -493,6 +523,75 @@ impl layer::Filter for Box + Send + Sync + 'static> {
     filter_impl_body!();
 }
 
+// Implement Filter for Option where None => allow
+#[cfg(feature = "registry")]
+#[cfg_attr(docsrs, doc(cfg(feature = "registry")))]
+impl layer::Filter for Option
+where
+    F: layer::Filter,
+{
+    #[inline]
+    fn enabled(&self, meta: &Metadata<'_>, ctx: &Context<'_, S>) -> bool {
+        self.as_ref()
+            .map(|inner| inner.enabled(meta, ctx))
+            .unwrap_or(true)
+    }
+
+    #[inline]
+    fn callsite_enabled(&self, meta: &'static Metadata<'static>) -> Interest {
+        self.as_ref()
+            .map(|inner| inner.callsite_enabled(meta))
+            .unwrap_or_else(Interest::always)
+    }
+
+    #[inline]
+    fn max_level_hint(&self) -> Option {
+        self.as_ref().and_then(|inner| inner.max_level_hint())
+    }
+
+    #[inline]
+    fn event_enabled(&self, event: &Event<'_>, ctx: &Context<'_, S>) -> bool {
+        self.as_ref()
+            .map(|inner| inner.event_enabled(event, ctx))
+            .unwrap_or(true)
+    }
+
+    #[inline]
+    fn on_new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
+        if let Some(inner) = self {
+            inner.on_new_span(attrs, id, ctx)
+        }
+    }
+
+    #[inline]
+    fn on_record(&self, id: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
+        if let Some(inner) = self {
+            inner.on_record(id, values, ctx)
+        }
+    }
+
+    #[inline]
+    fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
+        if let Some(inner) = self {
+            inner.on_enter(id, ctx)
+        }
+    }
+
+    #[inline]
+    fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
+        if let Some(inner) = self {
+            inner.on_exit(id, ctx)
+        }
+    }
+
+    #[inline]
+    fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
+        if let Some(inner) = self {
+            inner.on_close(id, ctx)
+        }
+    }
+}
+
 // === impl Filtered ===
 
 impl Filtered {
diff --git a/tracing-subscriber/src/layer/mod.rs b/tracing-subscriber/src/layer/mod.rs
index bdc154301a..9dcfcc927c 100644
--- a/tracing-subscriber/src/layer/mod.rs
+++ b/tracing-subscriber/src/layer/mod.rs
@@ -468,6 +468,24 @@
 //! function pointer. In addition, when more control is required, the [`Filter`]
 //! trait may also be implemented for user-defined types.
 //!
+//! //! [`Option`] also implements [`Filter`], which allows for an optional
+//! filter. [`None`](Option::None) filters out _nothing_ (that is, allows
+//! everything through). For example:
+//!
+//! ```rust
+//! # use tracing_subscriber::{filter::filter_fn, Layer};
+//! # use tracing_core::{Metadata, subscriber::Subscriber};
+//! # struct MyLayer(std::marker::PhantomData);
+//! # impl MyLayer { fn new() -> Self { Self(std::marker::PhantomData)} }
+//! # impl Layer for MyLayer {}
+//! # fn my_filter(_: &str) -> impl Fn(&Metadata) -> bool { |_| true  }
+//! fn setup_tracing(filter_config: Option<&str>) {
+//!     let layer = MyLayer::::new()
+//!         .with_filter(filter_config.map(|config| filter_fn(my_filter(config))));
+//! //...
+//! }
+//! ```
+//!
 //! 
 //!     Warning: Currently, the 
 //!     Registry type defined in this crate is the only root
diff --git a/tracing-subscriber/tests/layer_filters/main.rs b/tracing-subscriber/tests/layer_filters/main.rs
index 170074e8b3..80b929cbd6 100644
--- a/tracing-subscriber/tests/layer_filters/main.rs
+++ b/tracing-subscriber/tests/layer_filters/main.rs
@@ -2,6 +2,7 @@
 mod boxed;
 mod downcast_raw;
 mod filter_scopes;
+mod option;
 mod per_event;
 mod targets;
 mod trees;
@@ -12,7 +13,7 @@ use tracing_mock::{event, expect, layer, subscriber};
 use tracing_subscriber::{filter, prelude::*, Layer};
 
 #[test]
-fn basic_subscriber_filters() {
+fn basic_layer_filters() {
     let (trace_layer, trace_handle) = layer::named("trace")
         .event(expect::event().at_level(Level::TRACE))
         .event(expect::event().at_level(Level::DEBUG))
@@ -47,7 +48,7 @@ fn basic_subscriber_filters() {
 }
 
 #[test]
-fn basic_subscriber_filters_spans() {
+fn basic_layer_filter_spans() {
     let (trace_layer, trace_handle) = layer::named("trace")
         .new_span(expect::span().at_level(Level::TRACE))
         .new_span(expect::span().at_level(Level::DEBUG))
diff --git a/tracing-subscriber/tests/layer_filters/option.rs b/tracing-subscriber/tests/layer_filters/option.rs
new file mode 100644
index 0000000000..6eb4c40bb1
--- /dev/null
+++ b/tracing-subscriber/tests/layer_filters/option.rs
@@ -0,0 +1,143 @@
+use super::*;
+use tracing::Subscriber;
+use tracing_subscriber::{
+    filter::{self, LevelFilter},
+    prelude::*,
+    Layer,
+};
+
+fn filter_out_everything() -> filter::DynFilterFn {
+    // Use dynamic filter fn to disable interest caching and max-level hints,
+    // allowing us to put all of these tests in the same file.
+    filter::dynamic_filter_fn(|_, _| false)
+}
+
+#[test]
+fn option_some() {
+    let (layer, handle) = layer::mock().only().run_with_handle();
+    let layer = layer.with_filter(Some(filter_out_everything()));
+
+    let _guard = tracing_subscriber::registry().with(layer).set_default();
+
+    for i in 0..2 {
+        tracing::info!(i);
+    }
+
+    handle.assert_finished();
+}
+
+#[test]
+fn option_none() {
+    let (layer, handle) = layer::mock()
+        .event(expect::event())
+        .event(expect::event())
+        .only()
+        .run_with_handle();
+    let layer = layer.with_filter(None::>);
+
+    let _guard = tracing_subscriber::registry().with(layer).set_default();
+
+    for i in 0..2 {
+        tracing::info!(i);
+    }
+
+    handle.assert_finished();
+}
+
+#[test]
+fn option_mixed() {
+    let (layer, handle) = layer::mock()
+        .event(expect::event())
+        .only()
+        .run_with_handle();
+    let layer = layer
+        .with_filter(filter::dynamic_filter_fn(|meta, _ctx| {
+            meta.target() == "interesting"
+        }))
+        .with_filter(None::>);
+
+    let _guard = tracing_subscriber::registry().with(layer).set_default();
+
+    tracing::info!(target: "interesting", x="foo");
+    tracing::info!(target: "boring", x="bar");
+
+    handle.assert_finished();
+}
+
+/// The lack of a max level hint from a `None` filter should result in no max
+/// level hint when combined with other filters/layer.
+#[test]
+fn none_max_level_hint() {
+    let (layer_some, handle_none) = layer::mock()
+        .event(expect::event())
+        .event(expect::event())
+        .only()
+        .run_with_handle();
+    let subscribe_none = layer_some.with_filter(None::>);
+    assert!(subscribe_none.max_level_hint().is_none());
+
+    let (layer_filter_fn, handle_filter_fn) = layer::mock()
+        .event(expect::event())
+        .only()
+        .run_with_handle();
+    let max_level = Level::INFO;
+    let layer_filter_fn = layer_filter_fn.with_filter(
+        filter::dynamic_filter_fn(move |meta, _| return meta.level() <= &max_level)
+            .with_max_level_hint(max_level),
+    );
+    assert_eq!(layer_filter_fn.max_level_hint(), Some(LevelFilter::INFO));
+
+    let subscriber = tracing_subscriber::registry()
+        .with(subscribe_none)
+        .with(layer_filter_fn);
+    // The absence of a hint from the `None` filter upgrades the `INFO` hint
+    // from the filter fn layer.
+    assert!(subscriber.max_level_hint().is_none());
+
+    let _guard = subscriber.set_default();
+    tracing::info!(target: "interesting", x="foo");
+    tracing::debug!(target: "sometimes_interesting", x="bar");
+
+    handle_none.assert_finished();
+    handle_filter_fn.assert_finished();
+}
+
+/// The max level hint from inside a `Some(filter)` filter should be propagated
+/// and combined with other filters/layers.
+#[test]
+fn some_max_level_hint() {
+    let (layer_some, handle_some) = layer::mock()
+        .event(expect::event())
+        .event(expect::event())
+        .only()
+        .run_with_handle();
+    let layer_some = layer_some.with_filter(Some(
+        filter::dynamic_filter_fn(move |meta, _| return meta.level() <= &Level::DEBUG)
+            .with_max_level_hint(Level::DEBUG),
+    ));
+    assert_eq!(layer_some.max_level_hint(), Some(LevelFilter::DEBUG));
+
+    let (layer_filter_fn, handle_filter_fn) = layer::mock()
+        .event(expect::event())
+        .only()
+        .run_with_handle();
+    let layer_filter_fn = layer_filter_fn.with_filter(
+        filter::dynamic_filter_fn(move |meta, _| return meta.level() <= &Level::INFO)
+            .with_max_level_hint(Level::INFO),
+    );
+    assert_eq!(layer_filter_fn.max_level_hint(), Some(LevelFilter::INFO));
+
+    let subscriber = tracing_subscriber::registry()
+        .with(layer_some)
+        .with(layer_filter_fn);
+    // The `DEBUG` hint from the `Some` filter upgrades the `INFO` hint from the
+    // filter fn layer.
+    assert_eq!(subscriber.max_level_hint(), Some(LevelFilter::DEBUG));
+
+    let _guard = subscriber.set_default();
+    tracing::info!(target: "interesting", x="foo");
+    tracing::debug!(target: "sometimes_interesting", x="bar");
+
+    handle_some.assert_finished();
+    handle_filter_fn.assert_finished();
+}
diff --git a/tracing-subscriber/tests/layer_filters/vec.rs b/tracing-subscriber/tests/layer_filters/vec.rs
index 3555e19545..42aa308f6b 100644
--- a/tracing-subscriber/tests/layer_filters/vec.rs
+++ b/tracing-subscriber/tests/layer_filters/vec.rs
@@ -116,6 +116,6 @@ fn all_filtered_max_level_hint() {
 #[test]
 fn empty_vec() {
     // Just a None means everything is off
-    let collector = tracing_subscriber::registry().with(Vec::::new());
-    assert_eq!(collector.max_level_hint(), Some(LevelFilter::OFF));
+    let subscriber = tracing_subscriber::registry().with(Vec::::new());
+    assert_eq!(subscriber.max_level_hint(), Some(LevelFilter::OFF));
 }
diff --git a/tracing-subscriber/tests/option_filter_interest_caching.rs b/tracing-subscriber/tests/option_filter_interest_caching.rs
new file mode 100644
index 0000000000..609007cceb
--- /dev/null
+++ b/tracing-subscriber/tests/option_filter_interest_caching.rs
@@ -0,0 +1,53 @@
+// A separate test crate for `Option` for isolation from other tests
+// that may influence the interest cache.
+
+use std::sync::{
+    atomic::{AtomicUsize, Ordering},
+    Arc,
+};
+use tracing_mock::{expect, layer};
+use tracing_subscriber::{filter, prelude::*, Layer};
+
+/// A `None` filter should always be interested in events, and it should not
+/// needlessly degrade the caching of other filters.
+#[test]
+fn none_interest_cache() {
+    let (layer_none, handle_none) = layer::mock()
+        .event(expect::event())
+        .event(expect::event())
+        .only()
+        .run_with_handle();
+    let layer_none = layer_none.with_filter(None::>);
+
+    let times_filtered = Arc::new(AtomicUsize::new(0));
+    let (layer_filter_fn, handle_filter_fn) = layer::mock()
+        .event(expect::event())
+        .event(expect::event())
+        .only()
+        .run_with_handle();
+    let layer_filter_fn = layer_filter_fn.with_filter(filter::filter_fn({
+        let times_filtered = Arc::clone(×_filtered);
+        move |_| {
+            times_filtered.fetch_add(1, Ordering::Relaxed);
+            true
+        }
+    }));
+
+    let subscriber = tracing_subscriber::registry()
+        .with(layer_none)
+        .with(layer_filter_fn);
+
+    let _guard = subscriber.set_default();
+    for _ in 0..2 {
+        tracing::debug!(target: "always_interesting", x="bar");
+    }
+
+    // The `None` filter is unchanging and performs no filtering, so it should
+    // be cacheable and always be interested in events. The filter fn is a
+    // non-dynamic filter fn, which means the result can be cached per callsite.
+    // The filter fn should only need to be called once, and the `Option` filter
+    // should not interfere in the caching of that result.
+    assert_eq!(times_filtered.load(Ordering::Relaxed), 1);
+    handle_none.assert_finished();
+    handle_filter_fn.assert_finished();
+}
diff --git a/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs b/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs
index 8e1ecabce1..e80cfa09cf 100644
--- a/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs
+++ b/tracing-subscriber/tests/vec_subscriber_filter_interests_cached.rs
@@ -8,7 +8,7 @@ use tracing_mock::{layer::MockLayer, *};
 use tracing_subscriber::{filter, prelude::*};
 
 #[test]
-fn vec_subscriber_filter_interests_are_cached() {
+fn vec_layer_filter_interests_are_cached() {
     let mk_filtered = |level: Level, subscriber: MockLayer| {
         let seen = Arc::new(Mutex::new(HashMap::new()));
         let filter = filter::filter_fn({
diff --git a/tracing/tests/no_subscriber.rs b/tracing/tests/no_subscriber.rs
index 77e2c106c1..d15a2c8a18 100644
--- a/tracing/tests/no_subscriber.rs
+++ b/tracing/tests/no_subscriber.rs
@@ -4,7 +4,7 @@ use tracing_mock::subscriber;
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
 #[test]
-fn no_collector_disables_global() {
+fn no_subscriber_disables_global() {
     // Reproduces https://github.com/tokio-rs/tracing/issues/1999
     let (subscriber, handle) = subscriber::mock().only().run_with_handle();
     tracing::subscriber::set_global_default(subscriber)

From aa511045736d1256f2a77138cf1cf510c7e619a0 Mon Sep 17 00:00:00 2001
From: David Barsky 
Date: Fri, 29 Sep 2023 16:33:17 -0700
Subject: [PATCH 34/34] docs: remove usage of 0.2 terminology (#2728)

---
 examples/examples/fmt-compact.rs              |  2 +-
 examples/examples/fmt-source-locations.rs     |  2 +-
 tracing-core/src/dispatcher.rs                |  4 +-
 tracing-subscriber/src/filter/env/builder.rs  |  2 +-
 .../src/filter/layer_filters/mod.rs           |  8 ++--
 tracing-subscriber/src/fmt/time/time_crate.rs | 48 +++++++++----------
 tracing-subscriber/src/layer/layered.rs       |  2 +-
 tracing-subscriber/src/layer/mod.rs           |  4 +-
 8 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/examples/examples/fmt-compact.rs b/examples/examples/fmt-compact.rs
index a4899ce379..14cdd8a45f 100644
--- a/examples/examples/fmt-compact.rs
+++ b/examples/examples/fmt-compact.rs
@@ -7,7 +7,7 @@ fn main() {
         .compact()
         // enable everything
         .with_max_level(tracing::Level::TRACE)
-        // sets this to be the default, global collector for this application.
+        // sets this to be the default, global subscriber for this application.
         .init();
 
     let number_of_yaks = 3;
diff --git a/examples/examples/fmt-source-locations.rs b/examples/examples/fmt-source-locations.rs
index 799ebb17d5..b4b05b3027 100644
--- a/examples/examples/fmt-source-locations.rs
+++ b/examples/examples/fmt-source-locations.rs
@@ -14,7 +14,7 @@ fn main() {
         .with_line_number(true)
         // disable targets
         .with_target(false)
-        // sets this to be the default, global collector for this application.
+        // sets this to be the default, global subscriber for this application.
         .init();
 
     let number_of_yaks = 3;
diff --git a/tracing-core/src/dispatcher.rs b/tracing-core/src/dispatcher.rs
index 32632abdc5..de02afb790 100644
--- a/tracing-core/src/dispatcher.rs
+++ b/tracing-core/src/dispatcher.rs
@@ -518,8 +518,8 @@ impl Dispatch {
         }
     }
 
-    /// Registers a new callsite with this collector, returning whether or not
-    /// the collector is interested in being notified about the callsite.
+    /// Registers a new callsite with this subscriber, returning whether or not
+    /// the subscriber is interested in being notified about the callsite.
     ///
     /// This calls the [`register_callsite`] function on the [`Subscriber`]
     /// that this `Dispatch` forwards to.
diff --git a/tracing-subscriber/src/filter/env/builder.rs b/tracing-subscriber/src/filter/env/builder.rs
index c814707e6c..8572647412 100644
--- a/tracing-subscriber/src/filter/env/builder.rs
+++ b/tracing-subscriber/src/filter/env/builder.rs
@@ -212,7 +212,7 @@ impl Builder {
             #[cfg(feature = "nu_ansi_term")]
             use nu_ansi_term::{Color, Style};
             // NOTE: We can't use a configured `MakeWriter` because the EnvFilter
-            // has no knowledge of any underlying subscriber or collector, which
+            // has no knowledge of any underlying subscriber or subscriber, which
             // may or may not use a `MakeWriter`.
             let warn = |msg: &str| {
                 #[cfg(not(feature = "nu_ansi_term"))]
diff --git a/tracing-subscriber/src/filter/layer_filters/mod.rs b/tracing-subscriber/src/filter/layer_filters/mod.rs
index a8b3ef7a1d..69736fafd4 100644
--- a/tracing-subscriber/src/filter/layer_filters/mod.rs
+++ b/tracing-subscriber/src/filter/layer_filters/mod.rs
@@ -694,7 +694,7 @@ impl Filtered {
     /// # }
     /// ```
     ///
-    /// [subscriber]: Subscribe
+    /// [`Layer`]: crate::layer::Layer
     pub fn inner_mut(&mut self) -> &mut L {
         &mut self.layer
     }
@@ -706,8 +706,8 @@ where
     F: layer::Filter + 'static,
     L: Layer,
 {
-    fn on_register_dispatch(&self, collector: &Dispatch) {
-        self.layer.on_register_dispatch(collector);
+    fn on_register_dispatch(&self, subscriber: &Dispatch) {
+        self.layer.on_register_dispatch(subscriber);
     }
 
     fn on_layer(&mut self, subscriber: &mut S) {
@@ -1190,7 +1190,7 @@ impl FilterState {
         }
     }
 
-    /// Run a second filtering pass, e.g. for Subscribe::event_enabled.
+    /// Run a second filtering pass, e.g. for Layer::event_enabled.
     fn and(&self, filter: FilterId, f: impl FnOnce() -> bool) -> bool {
         let map = self.enabled.get();
         let enabled = map.is_enabled(filter) && f();
diff --git a/tracing-subscriber/src/fmt/time/time_crate.rs b/tracing-subscriber/src/fmt/time/time_crate.rs
index 60d57fd0bc..4883db418d 100644
--- a/tracing-subscriber/src/fmt/time/time_crate.rs
+++ b/tracing-subscriber/src/fmt/time/time_crate.rs
@@ -76,9 +76,9 @@ impl LocalTime {
     /// ```
     /// use tracing_subscriber::fmt::{self, time};
     ///
-    /// let collector = tracing_subscriber::fmt()
+    /// let subscriber = tracing_subscriber::fmt()
     ///     .with_timer(time::LocalTime::rfc_3339());
-    /// # drop(collector);
+    /// # drop(subscriber);
     /// ```
     ///
     /// [local time]: time::OffsetDateTime::now_local
@@ -130,9 +130,9 @@ impl LocalTime {
     /// use time::macros::format_description;
     ///
     /// let timer = LocalTime::new(format_description!("[hour]:[minute]:[second]"));
-    /// let collector = tracing_subscriber::fmt()
+    /// let subscriber = tracing_subscriber::fmt()
     ///     .with_timer(timer);
-    /// # drop(collector);
+    /// # drop(subscriber);
     /// ```
     ///
     /// Using [`time::format_description::parse`]:
@@ -143,9 +143,9 @@ impl LocalTime {
     /// let time_format = time::format_description::parse("[hour]:[minute]:[second]")
     ///     .expect("format string should be valid!");
     /// let timer = LocalTime::new(time_format);
-    /// let collector = tracing_subscriber::fmt()
+    /// let subscriber = tracing_subscriber::fmt()
     ///     .with_timer(timer);
-    /// # drop(collector);
+    /// # drop(subscriber);
     /// ```
     ///
     /// Using the [`format_description!`] macro requires enabling the `time`
@@ -158,9 +158,9 @@ impl LocalTime {
     /// use tracing_subscriber::fmt::{self, time::LocalTime};
     ///
     /// let timer = LocalTime::new(time::format_description::well_known::Rfc3339);
-    /// let collector = tracing_subscriber::fmt()
+    /// let subscriber = tracing_subscriber::fmt()
     ///     .with_timer(timer);
-    /// # drop(collector);
+    /// # drop(subscriber);
     /// ```
     ///
     /// [local time]: time::OffsetDateTime::now_local()
@@ -207,9 +207,9 @@ impl UtcTime {
     /// ```
     /// use tracing_subscriber::fmt::{self, time};
     ///
-    /// let collector = tracing_subscriber::fmt()
+    /// let subscriber = tracing_subscriber::fmt()
     ///     .with_timer(time::UtcTime::rfc_3339());
-    /// # drop(collector);
+    /// # drop(subscriber);
     /// ```
     ///
     /// [local time]: time::OffsetDateTime::now_utc
@@ -247,9 +247,9 @@ impl UtcTime {
     /// use time::macros::format_description;
     ///
     /// let timer = UtcTime::new(format_description!("[hour]:[minute]:[second]"));
-    /// let collector = tracing_subscriber::fmt()
+    /// let subscriber = tracing_subscriber::fmt()
     ///     .with_timer(timer);
-    /// # drop(collector);
+    /// # drop(subscriber);
     /// ```
     ///
     /// Using the [`format_description!`] macro requires enabling the `time`
@@ -263,9 +263,9 @@ impl UtcTime {
     /// let time_format = time::format_description::parse("[hour]:[minute]:[second]")
     ///     .expect("format string should be valid!");
     /// let timer = UtcTime::new(time_format);
-    /// let collector = tracing_subscriber::fmt()
+    /// let subscriber = tracing_subscriber::fmt()
     ///     .with_timer(timer);
-    /// # drop(collector);
+    /// # drop(subscriber);
     /// ```
     ///
     /// Using a [well-known format][well-known formats] (this is equivalent to
@@ -275,9 +275,9 @@ impl UtcTime {
     /// use tracing_subscriber::fmt::{self, time::UtcTime};
     ///
     /// let timer = UtcTime::new(time::format_description::well_known::Rfc3339);
-    /// let collector = tracing_subscriber::fmt()
+    /// let subscriber = tracing_subscriber::fmt()
     ///     .with_timer(timer);
-    /// # drop(collector);
+    /// # drop(subscriber);
     /// ```
     ///
     /// [UTC time]: time::OffsetDateTime::now_utc()
@@ -326,9 +326,9 @@ impl OffsetTime {
     /// ```
     /// use tracing_subscriber::fmt::{self, time};
     ///
-    /// let collector = tracing_subscriber::fmt()
+    /// let subscriber = tracing_subscriber::fmt()
     ///     .with_timer(time::OffsetTime::local_rfc_3339().expect("could not get local offset!"));
-    /// # drop(collector);
+    /// # drop(subscriber);
     /// ```
     ///
     /// Using `OffsetTime` with Tokio:
@@ -398,9 +398,9 @@ impl OffsetTime {
     ///
     /// let offset = UtcOffset::current_local_offset().expect("should get local offset!");
     /// let timer = OffsetTime::new(offset, format_description!("[hour]:[minute]:[second]"));
-    /// let collector = tracing_subscriber::fmt()
+    /// let subscriber = tracing_subscriber::fmt()
     ///     .with_timer(timer);
-    /// # drop(collector);
+    /// # drop(subscriber);
     /// ```
     ///
     /// Using [`time::format_description::parse`]:
@@ -413,9 +413,9 @@ impl OffsetTime {
     /// let time_format = time::format_description::parse("[hour]:[minute]:[second]")
     ///     .expect("format string should be valid!");
     /// let timer = OffsetTime::new(offset, time_format);
-    /// let collector = tracing_subscriber::fmt()
+    /// let subscriber = tracing_subscriber::fmt()
     ///     .with_timer(timer);
-    /// # drop(collector);
+    /// # drop(subscriber);
     /// ```
     ///
     /// Using the [`format_description!`] macro requires enabling the `time`
@@ -430,9 +430,9 @@ impl OffsetTime {
     ///
     /// let offset = UtcOffset::current_local_offset().expect("should get local offset!");
     /// let timer = OffsetTime::new(offset, time::format_description::well_known::Rfc3339);
-    /// let collector = tracing_subscriber::fmt()
+    /// let subscriber = tracing_subscriber::fmt()
     ///     .with_timer(timer);
-    /// # drop(collector);
+    /// # drop(subscriber);
     /// ```
     ///
     /// [`time` crate]: time
diff --git a/tracing-subscriber/src/layer/layered.rs b/tracing-subscriber/src/layer/layered.rs
index f09c58c97c..e276514986 100644
--- a/tracing-subscriber/src/layer/layered.rs
+++ b/tracing-subscriber/src/layer/layered.rs
@@ -470,7 +470,7 @@ where
             return Interest::sometimes();
         }
 
-        // otherwise, allow the inner subscriber or collector to weigh in.
+        // otherwise, allow the inner subscriber or subscriber to weigh in.
         inner
     }
 
diff --git a/tracing-subscriber/src/layer/mod.rs b/tracing-subscriber/src/layer/mod.rs
index 9dcfcc927c..296de5ef48 100644
--- a/tracing-subscriber/src/layer/mod.rs
+++ b/tracing-subscriber/src/layer/mod.rs
@@ -750,8 +750,8 @@ where
     /// [`WeakDispatch`]: tracing_core::dispatcher::WeakDispatch
     /// [upgraded]: tracing_core::dispatcher::WeakDispatch::upgrade
     /// [`Subscriber`]: tracing_core::Subscriber
-    fn on_register_dispatch(&self, collector: &Dispatch) {
-        let _ = collector;
+    fn on_register_dispatch(&self, subscriber: &Dispatch) {
+        let _ = subscriber;
     }
 
     /// Performs late initialization when attaching a `Layer` to a