From cec1877e180393eba0f6ddb0cf97bf3a791631c7 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 7 Jun 2024 07:48:42 +0200 Subject: Merging upstream version 1.75.0+dfsg1. Signed-off-by: Daniel Baumann --- vendor/tracing-attributes/.cargo-checksum.json | 2 +- vendor/tracing-attributes/CHANGELOG.md | 15 ++++ vendor/tracing-attributes/Cargo.toml | 4 +- vendor/tracing-attributes/src/expand.rs | 8 +- vendor/tracing-attributes/src/lib.rs | 2 +- vendor/tracing-attributes/tests/async_fn.rs | 91 ++++++++++---------- vendor/tracing-attributes/tests/destructuring.rs | 54 ++++++------ vendor/tracing-attributes/tests/err.rs | 101 ++++++++++++++--------- vendor/tracing-attributes/tests/fields.rs | 53 ++++++------ vendor/tracing-attributes/tests/follows_from.rs | 26 +++--- vendor/tracing-attributes/tests/instrument.rs | 54 ++++++------ vendor/tracing-attributes/tests/levels.rs | 96 ++++++++++----------- vendor/tracing-attributes/tests/names.rs | 24 +++--- vendor/tracing-attributes/tests/parents.rs | 14 ++-- vendor/tracing-attributes/tests/ret.rs | 92 ++++++++++----------- vendor/tracing-attributes/tests/targets.rs | 40 +++++---- 16 files changed, 361 insertions(+), 315 deletions(-) (limited to 'vendor/tracing-attributes') diff --git a/vendor/tracing-attributes/.cargo-checksum.json b/vendor/tracing-attributes/.cargo-checksum.json index f03bd5d46..cc2b53e52 100644 --- a/vendor/tracing-attributes/.cargo-checksum.json +++ b/vendor/tracing-attributes/.cargo-checksum.json @@ -1 +1 @@ -{"files":{"CHANGELOG.md":"51b693a78ec3115db6f20696605d5829a5928dc7270145810964f8edd4a5e574","Cargo.toml":"b8ad9f1020eeb1f1e495d7a693c825f7bdc3ee4bf29a72aeacbdef989870c61a","LICENSE":"898b1ae9821e98daf8964c8d6c7f61641f5f5aa78ad500020771c0939ee0dea1","README.md":"d878157a8f65779ef3d2e53d6772f99b5b79d7addccb6d04a2eb681ce1de99e1","src/attr.rs":"d0224a2a9be76743f039c86c1935622ca0b5b2e618b9323149855bf0e326fe48","src/expand.rs":"d2f3af4c987d79def03500d7a8cda1bd18c4da3e8395b500e37241968e38c7e0","src/lib.rs":"040047aa902ff3dc6d1b128a055de13d129d69fcd96b04f036223f4585d1fa1c","tests/async_fn.rs":"472a544e14b2141acd9d63e1cbe49f2610cfe8e924dff67b4d23c6a9121fc90f","tests/destructuring.rs":"26b9800678bad09e06512a113a54556e2fac3ecb15a18dcccefe105fb8911c26","tests/err.rs":"ef46724e62c4c307c2d0306e8689c1d4816df432709bfb7bbace7f8ceb67f86d","tests/fields.rs":"3882bd4e744d6b492f59beac7475e8bf4ff4ca8ad85c6951c305a22c78e75fae","tests/follows_from.rs":"f3cc336dac88533521b4cbe0b378fbcf1fb34e2d41a367b4726e98b49468309f","tests/instrument.rs":"dab616dac11043f82f91efbbb37c0dc5a375e51085449bf0b8d65c619f11166a","tests/levels.rs":"408a8eec7af33deba6a050ea9e59ed11e5e76a393f0a2549b11ddf683c0b785d","tests/names.rs":"5afd6c4d526588bcea3141c130a45a21872956495b6868a01b44ddff57749827","tests/parents.rs":"673d3f81eed6ba433f685ec53fd007c5dd957b97d32499d7ea1537e1f289cb2e","tests/ret.rs":"55473797667240c8f613b277360e68228e40047180b5f2828b13513873b9754e","tests/targets.rs":"95ce1ce1e2d29794062c5b3429d91c1bfaba5813251d5d8440c12cb2db6e11bf","tests/ui.rs":"60ed69aba2cbf4b1a2f42b78703f7f21d8a69f62e39bb0509f6a2224cad9b9de","tests/ui/async_instrument.rs":"00fcde05841e8f9f6cc6f9434f8cc4baed5cf6e3ca73e8faddccbdace14e9485","tests/ui/async_instrument.stderr":"1d650a0914f0f59beeb88946a8ad6991feffe885016462ba917ea8e09792f866","tests/ui/const_instrument.rs":"253160848b023cbf73c3d1dece4969ff892ae9a3149e771159230733fa1cab1b","tests/ui/const_instrument.stderr":"86527fbc2410ceba8f051771fdb4bf71eb853e086a4e4d17353089c65b918c18"},"package":"5f4f31f56159e98206da9efd823404b79b6ef3143b4a7ab76e67b1751b25a4ab"} \ No newline at end of file +{"files":{"CHANGELOG.md":"e410a2cbd565bff62c52c66580bd3c7aa9bd81e4b73b5f4cdd0f7c5ab13b21de","Cargo.toml":"2cb782a6b7cb5412591a8457af156d081514ae846a81bec889a9f60f68a39dca","LICENSE":"898b1ae9821e98daf8964c8d6c7f61641f5f5aa78ad500020771c0939ee0dea1","README.md":"d878157a8f65779ef3d2e53d6772f99b5b79d7addccb6d04a2eb681ce1de99e1","src/attr.rs":"d0224a2a9be76743f039c86c1935622ca0b5b2e618b9323149855bf0e326fe48","src/expand.rs":"548b8d5fb5e92fe57a067bb656b88ceb403234521eed8bce4e0ec91b5fdacf78","src/lib.rs":"de2409d2cefba7a21739ac1021ea8e0dec892a342b1ecb46a81f66b782ea8f5b","tests/async_fn.rs":"66dab5e2a58119f588daae74efa47b5d8db0751cb99660856d792f352a3a263e","tests/destructuring.rs":"d920dca0b7db5b48697c1eb5a40ce676956760eb8bc2dcbe4c5ce1bc3631877b","tests/err.rs":"6b717be09a2447bcb0583a9b6a42b53361935b4a61093572c55f506f9d5f5cff","tests/fields.rs":"8babe90df46cfe9018caf20ef85060c90d611c5531b4d603f10f83a38744e7c2","tests/follows_from.rs":"d0478db45cb838d76f0d52f930847e8540b09456e2cd56591e56910c5e9985c6","tests/instrument.rs":"0c47bd9117858ecc585faab597115b7b49e2c79ae20172c32a6184674c8fd274","tests/levels.rs":"20483e9c7555991044b748f209def016d28da0a64eb9f85fabb489b0fb75a440","tests/names.rs":"2a67b33681cc7689c4d677de7a97b846df1817406a56a98ba91bf67b9f7d630a","tests/parents.rs":"95451328d8d7dba9020dc3eeb4ee56fc7f4591d5d38e793b815e621e73063da1","tests/ret.rs":"4628f562f8b0fb36a0dc13f488d70df8a545bd9b49422dfbf05fd2cab3870fc3","tests/targets.rs":"2065af7ff491be720c56d1b218b095a64e4573bf2586e49ce638c5ed4d639811","tests/ui.rs":"60ed69aba2cbf4b1a2f42b78703f7f21d8a69f62e39bb0509f6a2224cad9b9de","tests/ui/async_instrument.rs":"00fcde05841e8f9f6cc6f9434f8cc4baed5cf6e3ca73e8faddccbdace14e9485","tests/ui/async_instrument.stderr":"1d650a0914f0f59beeb88946a8ad6991feffe885016462ba917ea8e09792f866","tests/ui/const_instrument.rs":"253160848b023cbf73c3d1dece4969ff892ae9a3149e771159230733fa1cab1b","tests/ui/const_instrument.stderr":"86527fbc2410ceba8f051771fdb4bf71eb853e086a4e4d17353089c65b918c18"},"package":"34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"} \ No newline at end of file diff --git a/vendor/tracing-attributes/CHANGELOG.md b/vendor/tracing-attributes/CHANGELOG.md index 6df517e85..3cb95f70f 100644 --- a/vendor/tracing-attributes/CHANGELOG.md +++ b/vendor/tracing-attributes/CHANGELOG.md @@ -1,3 +1,18 @@ +# 0.1.27 (October 13, 2023) + +### Changed + +- Bump minimum version of proc-macro2 to 1.0.60 ([#2732]) +- Generate less dead code for async block return type hint ([#2709]) + +### Fixed + +- Fix a compilation error in `#[instrument]` when the `"log"` feature is enabled ([#2599]) + +[#2732]: https://github.com/tokio-rs/tracing/pull/2732 +[#2709]: https://github.com/tokio-rs/tracing/pull/2709 +[#2599]: https://github.com/tokio-rs/tracing/pull/2599 + # 0.1.26 (June 21th, 2023) This release of `tracing-attributes` fixes warnings due to `allow` attributes in diff --git a/vendor/tracing-attributes/Cargo.toml b/vendor/tracing-attributes/Cargo.toml index 281ea1fdc..8d90671b8 100644 --- a/vendor/tracing-attributes/Cargo.toml +++ b/vendor/tracing-attributes/Cargo.toml @@ -13,7 +13,7 @@ edition = "2018" rust-version = "1.56.0" name = "tracing-attributes" -version = "0.1.26" +version = "0.1.27" authors = [ "Tokio Contributors ", "Eliza Weisman ", @@ -43,7 +43,7 @@ repository = "https://github.com/tokio-rs/tracing" proc-macro = true [dependencies.proc-macro2] -version = "1.0.40" +version = "1.0.60" [dependencies.quote] version = "1.0.20" diff --git a/vendor/tracing-attributes/src/expand.rs b/vendor/tracing-attributes/src/expand.rs index eb7be8f47..a7123e523 100644 --- a/vendor/tracing-attributes/src/expand.rs +++ b/vendor/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; } }; @@ -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(); diff --git a/vendor/tracing-attributes/src/lib.rs b/vendor/tracing-attributes/src/lib.rs index c7477946d..6a0fd5453 100644 --- a/vendor/tracing-attributes/src/lib.rs +++ b/vendor/tracing-attributes/src/lib.rs @@ -91,7 +91,7 @@ mod expand; /// Instruments a function to create and enter a `tracing` [span] every time /// the function is called. /// -/// Unless overriden, a span with the [`INFO`] [level] will be generated. +/// Unless overridden, a span with the [`INFO`] [level] will be generated. /// The generated span's name will be the name of the function. /// By default, all arguments to the function are included as fields on the /// span. Arguments that are `tracing` [primitive types] implementing the diff --git a/vendor/tracing-attributes/tests/async_fn.rs b/vendor/tracing-attributes/tests/async_fn.rs index d6d874ffd..1d9273400 100644 --- a/vendor/tracing-attributes/tests/async_fn.rs +++ b/vendor/tracing-attributes/tests/async_fn.rs @@ -17,7 +17,6 @@ async fn test_async_fn(polls: usize) -> Result<(), ()> { #[allow(dead_code)] // this is just here to test whether it compiles. #[instrument] async fn test_ret_impl_trait(n: i32) -> Result, ()> { - let n = n; Ok((0..10).filter(move |x| *x < n)) } @@ -84,16 +83,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(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, || { block_on_future(async { test_async_fn(2).await }).unwrap(); @@ -113,14 +112,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 = 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::mock().with_fields(field::mock("nested").with_value(&true))) + .event(expect::event().with_fields(expect::field("nested").with_value(&true))) .exit(span2.clone()) .enter(span2.clone()) .exit(span2.clone()) @@ -129,7 +128,7 @@ fn async_fn_nested() { .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -191,26 +190,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 = 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::mock("self")) - .with_field(field::mock("v")), + .with_field(expect::field("self")) + .with_field(expect::field("v")), ) .enter(span.clone()) .new_span(span3.clone()) .enter(span3.clone()) - .event(event::mock().with_fields(field::mock("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::mock("self"))) + .new_span(span2.clone().with_field(expect::field("self"))) .enter(span2.clone()) - .event(event::mock().with_fields(field::mock("val").with_value(&5u64))) + .event(expect::event().with_fields(expect::field("val").with_value(&5u64))) .exit(span2.clone()) .enter(span2.clone()) .exit(span2.clone()) @@ -219,7 +218,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 +254,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 = expect::span().named("call"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("_v") + expect::field("_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(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()) @@ -271,7 +270,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, || { @@ -323,26 +322,26 @@ fn async_fn_with_async_trait_and_fields_expressions_with_generic_parameter() { } //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 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::mock("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::mock("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::mock("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,14 +354,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(expect::field("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 +396,7 @@ fn out_of_scope_fields() { } } - let span = span::mock().named("call"); + let span = expect::span().named("call"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) @@ -405,7 +404,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 +429,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 = 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 @@ -442,7 +441,7 @@ fn manual_impl_future() { .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { @@ -463,8 +462,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 = 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 @@ -475,7 +474,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/vendor/tracing-attributes/tests/destructuring.rs b/vendor/tracing-attributes/tests/destructuring.rs index 09cf1ad53..cc4fecf3f 100644 --- a/vendor/tracing-attributes/tests/destructuring.rs +++ b/vendor/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 = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + expect::field("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) + .and(expect::field("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 = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + expect::field("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(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(), ), ) .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 = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::mock("arg1").with_value(&1usize).only()), + .with_field(expect::field("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 = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + expect::field("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) + .and(expect::field("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 = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + expect::field("arg1") .with_value(&format_args!("1")) - .and(field::mock("arg2").with_value(&format_args!("2"))) + .and(expect::field("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 = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + expect::field("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(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(), ), ) .enter(span.clone()) .exit(span.clone()) .drop_span(span) - .done() + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/vendor/tracing-attributes/tests/err.rs b/vendor/tracing-attributes/tests/err.rs index 485dd1196..bee7aa5f4 100644 --- a/vendor/tracing-attributes/tests/err.rs +++ b/vendor/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 = expect::span().named("err"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(expect::event().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 = expect::span().named("err_early_return"); + let (subscriber, handle) = subscriber::mock() + .new_span(span.clone()) + .enter(span.clone()) + .event(expect::event().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 = expect::span().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)) + expect::event() + .with_fields(expect::field("awaiting").with_value(&true)) .at_level(Level::TRACE), ) .exit(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(expect::event().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 = expect::span().named("err_mut"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(expect::event().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 = expect::span().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)) + expect::event() + .with_fields(expect::field("awaiting").with_value(&true)) .at_level(Level::TRACE), ) .exit(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::ERROR)) + .event(expect::event().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 = expect::span().named("returns_impl_trait"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::mock("x").with_value(&10usize).only()), + .with_field(expect::field("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 = expect::span().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") + 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 @@ -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 = expect::span().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") + 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())), ), ) .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 = expect::span().named("error_span").with_target("my_target"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() + expect::event() .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 = expect::span().named("err_info"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) - .event(event::mock().at_level(Level::INFO)) + .event(expect::event().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 = expect::span().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") + 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 @@ -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 = expect::span().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(expect::event().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/vendor/tracing-attributes/tests/fields.rs b/vendor/tracing-attributes/tests/fields.rs index c178fbb3d..a3b23d7ac 100644 --- a/vendor/tracing-attributes/tests/fields.rs +++ b/vendor/tracing-attributes/tests/fields.rs @@ -1,8 +1,6 @@ use tracing::subscriber::with_default; use tracing_attributes::instrument; -use tracing_mock::field::mock; -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::mock().with_field( - mock("foo") + let span = expect::span().with_field( + expect::field("foo") .with_value(&"bar") - .and(mock("dsa").with_value(&true)) - .and(mock("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::mock().with_field( - mock("s") + let span = expect::span().with_field( + expect::field("s") .with_value(&"hello world") - .and(mock("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::mock().with_field( - mock("s") + let span = expect::span().with_field( + expect::field("s") .with_value(&"hello world") - .and(mock("s.len").with_value(&"hello world".len())) - .and(mock("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::mock().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. - mock("s") + expect::field("s") .with_value(&tracing::field::display("hello world")) - .and(mock("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::mock().with_field(mock("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::mock().with_field(mock("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::mock().with_field( - mock("foo") + let span = expect::span().with_field( + expect::field("foo") .with_value(&"bar") - .and(mock("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::mock().with_field(mock("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::mock().with_field(mock("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,9 +149,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(expect::span()) + .exit(expect::span()) + .only() .run_with_handle(); with_default(subscriber, fun); diff --git a/vendor/tracing-attributes/tests/follows_from.rs b/vendor/tracing-attributes/tests/follows_from.rs index a589409de..6b5526b82 100644 --- a/vendor/tracing-attributes/tests/follows_from.rs +++ b/vendor/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 = 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()) @@ -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 = 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()) @@ -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 = expect::span().named("cause"); + let consequence = expect::span().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/vendor/tracing-attributes/tests/instrument.rs b/vendor/tracing-attributes/tests/instrument.rs index b215b8455..f751eebf6 100644 --- a/vendor/tracing-attributes/tests/instrument.rs +++ b/vendor/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 = expect::span() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::mock() + let span2 = expect::span() .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 = expect::span() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::mock() + 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::mock("arg1") + expect::field("arg1") .with_value(&2usize) - .and(field::mock("arg2").with_value(&false)) + .and(expect::field("arg2").with_value(&false)) .only(), ), ) @@ -76,16 +76,16 @@ fn fields() { .drop_span(span) .new_span( span2.clone().with_field( - field::mock("arg1") + expect::field("arg1") .with_value(&3usize) - .and(field::mock("arg2").with_value(&true)) + .and(expect::field("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 = expect::span() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span2 = span::mock() + let span2 = expect::span() .named("my_fn") .at_level(Level::DEBUG) .with_target("my_target"); - let span3 = span::mock() + 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::mock("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::mock("arg1").with_value(&3usize).only()), + .with_field(expect::field("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 = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("arg1") + expect::field("arg1") .with_value(&format_args!("Foo")) - .and(field::mock("arg2").with_value(&format_args!("false"))), + .and(expect::field("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 = expect::span().named("my_fn"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone().with_field( - field::mock("self") + expect::field("self") .with_value(&format_args!("Foo")) - .and(field::mock("arg1").with_value(&42usize)), + .and(expect::field("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 = expect::span().named("returns_impl_trait"); let (subscriber, handle) = subscriber::mock() .new_span( span.clone() - .with_field(field::mock("x").with_value(&10usize).only()), + .with_field(expect::field("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/vendor/tracing-attributes/tests/levels.rs b/vendor/tracing-attributes/tests/levels.rs index 94fc7e85a..ed80dc16a 100644 --- a/vendor/tracing-attributes/tests/levels.rs +++ b/vendor/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(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(); 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(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(); 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(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(); with_default(subscriber, || { diff --git a/vendor/tracing-attributes/tests/names.rs b/vendor/tracing-attributes/tests/names.rs index d97dece9a..03e3dbfa4 100644 --- a/vendor/tracing-attributes/tests/names.rs +++ b/vendor/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(expect::span().named("default_name")) + .enter(expect::span().named("default_name")) + .exit(expect::span().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(expect::span().named("my_name")) + .enter(expect::span().named("my_name")) + .exit(expect::span().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(expect::span().named("my_other_name")) + .enter(expect::span().named("my_other_name")) + .exit(expect::span().named("my_other_name")) + .only() .run_with_handle(); with_default(subscriber, || { diff --git a/vendor/tracing-attributes/tests/parents.rs b/vendor/tracing-attributes/tests/parents.rs index 7069b98ea..d4559415d 100644 --- a/vendor/tracing-attributes/tests/parents.rs +++ b/vendor/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 = expect::span().named("contextual_parent"); + let child = expect::span().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 = 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( @@ -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/vendor/tracing-attributes/tests/ret.rs b/vendor/tracing-attributes/tests/ret.rs index f56c80baa..90bd9e185 100644 --- a/vendor/tracing-attributes/tests/ret.rs +++ b/vendor/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 = expect::span().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))) + expect::event() + .with_fields(expect::field("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 = expect::span() .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))) + expect::event() + .with_fields(expect::field("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 = expect::span().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))) + expect::event() + .with_fields(expect::field("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 = expect::span().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))) + expect::event() + .with_fields(expect::field("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))) + expect::event() + .with_fields(expect::field("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 = expect::span().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))) + expect::event() + .with_fields(expect::field("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 = expect::span().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))) + expect::event() + .with_fields(expect::field("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 = expect::span().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))) + expect::event() + .with_fields(expect::field("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 = expect::span().named("ret_and_err"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() + expect::event() .with_fields( - field::mock("error") + expect::field("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 = expect::span().named("ret_and_ok"); let (subscriber, handle) = subscriber::mock() .new_span(span.clone()) .enter(span.clone()) .event( - event::mock() + expect::event() .with_fields( - field::mock("return") + expect::field("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 = expect::span().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))) + expect::event() + .with_fields(expect::field("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 = expect::span().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))) + expect::event() + .with_fields(expect::field("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/vendor/tracing-attributes/tests/targets.rs b/vendor/tracing-attributes/tests/targets.rs index 363f628f3..0e70287d3 100644 --- a/vendor/tracing-attributes/tests/targets.rs +++ b/vendor/tracing-attributes/tests/targets.rs @@ -24,36 +24,36 @@ mod my_mod { fn default_targets() { let (subscriber, handle) = subscriber::mock() .new_span( - span::mock() + expect::span() .named("default_target") .with_target(module_path!()), ) .enter( - span::mock() + expect::span() .named("default_target") .with_target(module_path!()), ) .exit( - span::mock() + expect::span() .named("default_target") .with_target(module_path!()), ) .new_span( - span::mock() + expect::span() .named("default_target") .with_target(my_mod::MODULE_PATH), ) .enter( - span::mock() + expect::span() .named("default_target") .with_target(my_mod::MODULE_PATH), ) .exit( - span::mock() + expect::span() .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() + expect::span() + .named("custom_target") + .with_target("my_target"), + ) + .enter( + expect::span() + .named("custom_target") + .with_target("my_target"), + ) + .exit( + expect::span() + .named("custom_target") + .with_target("my_target"), + ) + .new_span( + expect::span() .named("custom_target") .with_target("my_other_target"), ) .enter( - span::mock() + expect::span() .named("custom_target") .with_target("my_other_target"), ) .exit( - span::mock() + expect::span() .named("custom_target") .with_target("my_other_target"), ) - .done() + .only() .run_with_handle(); with_default(subscriber, || { -- cgit v1.2.3