1 use tracing::subscriber::with_default;
2 use tracing::Level;
3 use tracing_attributes::instrument;
4 use tracing_mock::*;
5
6 // Reproduces a compile error when an instrumented function body contains inner
7 // attributes (https://github.com/tokio-rs/tracing/issues/2294).
8 #[deny(unused_variables)]
9 #[instrument]
repro_2294()10 fn repro_2294() {
11 #![allow(unused_variables)]
12 let i = 42;
13 }
14
15 #[test]
override_everything()16 fn override_everything() {
17 #[instrument(target = "my_target", level = "debug")]
18 fn my_fn() {}
19
20 #[instrument(level = "debug", target = "my_target")]
21 fn my_other_fn() {}
22
23 let span = span::mock()
24 .named("my_fn")
25 .at_level(Level::DEBUG)
26 .with_target("my_target");
27 let span2 = span::mock()
28 .named("my_other_fn")
29 .at_level(Level::DEBUG)
30 .with_target("my_target");
31 let (subscriber, handle) = subscriber::mock()
32 .new_span(span.clone())
33 .enter(span.clone())
34 .exit(span.clone())
35 .drop_span(span)
36 .new_span(span2.clone())
37 .enter(span2.clone())
38 .exit(span2.clone())
39 .drop_span(span2)
40 .done()
41 .run_with_handle();
42
43 with_default(subscriber, || {
44 my_fn();
45 my_other_fn();
46 });
47
48 handle.assert_finished();
49 }
50
51 #[test]
fields()52 fn fields() {
53 #[instrument(target = "my_target", level = "debug")]
54 fn my_fn(arg1: usize, arg2: bool) {}
55
56 let span = span::mock()
57 .named("my_fn")
58 .at_level(Level::DEBUG)
59 .with_target("my_target");
60
61 let span2 = span::mock()
62 .named("my_fn")
63 .at_level(Level::DEBUG)
64 .with_target("my_target");
65 let (subscriber, handle) = subscriber::mock()
66 .new_span(
67 span.clone().with_field(
68 field::mock("arg1")
69 .with_value(&2usize)
70 .and(field::mock("arg2").with_value(&false))
71 .only(),
72 ),
73 )
74 .enter(span.clone())
75 .exit(span.clone())
76 .drop_span(span)
77 .new_span(
78 span2.clone().with_field(
79 field::mock("arg1")
80 .with_value(&3usize)
81 .and(field::mock("arg2").with_value(&true))
82 .only(),
83 ),
84 )
85 .enter(span2.clone())
86 .exit(span2.clone())
87 .drop_span(span2)
88 .done()
89 .run_with_handle();
90
91 with_default(subscriber, || {
92 my_fn(2, false);
93 my_fn(3, true);
94 });
95
96 handle.assert_finished();
97 }
98
99 #[test]
skip()100 fn skip() {
101 struct UnDebug(pub u32);
102
103 #[instrument(target = "my_target", level = "debug", skip(_arg2, _arg3))]
104 fn my_fn(arg1: usize, _arg2: UnDebug, _arg3: UnDebug) {}
105
106 #[instrument(target = "my_target", level = "debug", skip_all)]
107 fn my_fn2(_arg1: usize, _arg2: UnDebug, _arg3: UnDebug) {}
108
109 let span = span::mock()
110 .named("my_fn")
111 .at_level(Level::DEBUG)
112 .with_target("my_target");
113
114 let span2 = span::mock()
115 .named("my_fn")
116 .at_level(Level::DEBUG)
117 .with_target("my_target");
118
119 let span3 = span::mock()
120 .named("my_fn2")
121 .at_level(Level::DEBUG)
122 .with_target("my_target");
123
124 let (subscriber, handle) = subscriber::mock()
125 .new_span(
126 span.clone()
127 .with_field(field::mock("arg1").with_value(&2usize).only()),
128 )
129 .enter(span.clone())
130 .exit(span.clone())
131 .drop_span(span)
132 .new_span(
133 span2
134 .clone()
135 .with_field(field::mock("arg1").with_value(&3usize).only()),
136 )
137 .enter(span2.clone())
138 .exit(span2.clone())
139 .drop_span(span2)
140 .new_span(span3.clone())
141 .enter(span3.clone())
142 .exit(span3.clone())
143 .drop_span(span3)
144 .done()
145 .run_with_handle();
146
147 with_default(subscriber, || {
148 my_fn(2, UnDebug(0), UnDebug(1));
149 my_fn(3, UnDebug(0), UnDebug(1));
150 my_fn2(2, UnDebug(0), UnDebug(1));
151 });
152
153 handle.assert_finished();
154 }
155
156 #[test]
generics()157 fn generics() {
158 #[derive(Debug)]
159 struct Foo;
160
161 #[instrument]
162 fn my_fn<S, T: std::fmt::Debug>(arg1: S, arg2: T)
163 where
164 S: std::fmt::Debug,
165 {
166 }
167
168 let span = span::mock().named("my_fn");
169
170 let (subscriber, handle) = subscriber::mock()
171 .new_span(
172 span.clone().with_field(
173 field::mock("arg1")
174 .with_value(&format_args!("Foo"))
175 .and(field::mock("arg2").with_value(&format_args!("false"))),
176 ),
177 )
178 .enter(span.clone())
179 .exit(span.clone())
180 .drop_span(span)
181 .done()
182 .run_with_handle();
183
184 with_default(subscriber, || {
185 my_fn(Foo, false);
186 });
187
188 handle.assert_finished();
189 }
190
191 #[test]
methods()192 fn methods() {
193 #[derive(Debug)]
194 struct Foo;
195
196 impl Foo {
197 #[instrument]
198 fn my_fn(&self, arg1: usize) {}
199 }
200
201 let span = span::mock().named("my_fn");
202
203 let (subscriber, handle) = subscriber::mock()
204 .new_span(
205 span.clone().with_field(
206 field::mock("self")
207 .with_value(&format_args!("Foo"))
208 .and(field::mock("arg1").with_value(&42usize)),
209 ),
210 )
211 .enter(span.clone())
212 .exit(span.clone())
213 .drop_span(span)
214 .done()
215 .run_with_handle();
216
217 with_default(subscriber, || {
218 let foo = Foo;
219 foo.my_fn(42);
220 });
221
222 handle.assert_finished();
223 }
224
225 #[test]
impl_trait_return_type()226 fn impl_trait_return_type() {
227 #[instrument]
228 fn returns_impl_trait(x: usize) -> impl Iterator<Item = usize> {
229 0..x
230 }
231
232 let span = span::mock().named("returns_impl_trait");
233
234 let (subscriber, handle) = subscriber::mock()
235 .new_span(
236 span.clone()
237 .with_field(field::mock("x").with_value(&10usize).only()),
238 )
239 .enter(span.clone())
240 .exit(span.clone())
241 .drop_span(span)
242 .done()
243 .run_with_handle();
244
245 with_default(subscriber, || {
246 for _ in returns_impl_trait(10) {
247 // nop
248 }
249 });
250
251 handle.assert_finished();
252 }
253