1 use std::convert::TryFrom;
2 use std::num::TryFromIntError;
3
4 use tracing::{subscriber::with_default, Level};
5 use tracing_attributes::instrument;
6 use tracing_mock::{expect, subscriber};
7 use tracing_subscriber::layer::SubscriberExt;
8 use tracing_subscriber::EnvFilter;
9 use tracing_test::block_on_future;
10
11 #[instrument(ret)]
ret() -> i3212 fn ret() -> i32 {
13 42
14 }
15
16 #[instrument(target = "my_target", ret)]
ret_with_target() -> i3217 fn ret_with_target() -> i32 {
18 42
19 }
20
21 #[test]
test()22 fn test() {
23 let span = expect::span().named("ret");
24 let (subscriber, handle) = subscriber::mock()
25 .new_span(span.clone())
26 .enter(span.clone())
27 .event(
28 expect::event()
29 .with_fields(expect::field("return").with_value(&tracing::field::debug(42)))
30 .at_level(Level::INFO),
31 )
32 .exit(span.clone())
33 .drop_span(span)
34 .only()
35 .run_with_handle();
36
37 with_default(subscriber, ret);
38 handle.assert_finished();
39 }
40
41 #[test]
test_custom_target()42 fn test_custom_target() {
43 let filter: EnvFilter = "my_target=info".parse().expect("filter should parse");
44 let span = expect::span()
45 .named("ret_with_target")
46 .with_target("my_target");
47
48 let (subscriber, handle) = subscriber::mock()
49 .new_span(span.clone())
50 .enter(span.clone())
51 .event(
52 expect::event()
53 .with_fields(expect::field("return").with_value(&tracing::field::debug(42)))
54 .at_level(Level::INFO)
55 .with_target("my_target"),
56 )
57 .exit(span.clone())
58 .drop_span(span)
59 .only()
60 .run_with_handle();
61
62 let subscriber = subscriber.with(filter);
63
64 with_default(subscriber, ret_with_target);
65 handle.assert_finished();
66 }
67
68 #[instrument(level = "warn", ret)]
ret_warn() -> i3269 fn ret_warn() -> i32 {
70 42
71 }
72
73 #[test]
test_warn()74 fn test_warn() {
75 let span = expect::span().named("ret_warn");
76 let (subscriber, handle) = subscriber::mock()
77 .new_span(span.clone())
78 .enter(span.clone())
79 .event(
80 expect::event()
81 .with_fields(expect::field("return").with_value(&tracing::field::debug(42)))
82 .at_level(Level::WARN),
83 )
84 .exit(span.clone())
85 .drop_span(span)
86 .only()
87 .run_with_handle();
88
89 with_default(subscriber, ret_warn);
90 handle.assert_finished();
91 }
92
93 #[instrument(ret)]
ret_mut(a: &mut i32) -> i3294 fn ret_mut(a: &mut i32) -> i32 {
95 *a *= 2;
96 tracing::info!(?a);
97 *a
98 }
99
100 #[test]
test_mut()101 fn test_mut() {
102 let span = expect::span().named("ret_mut");
103 let (subscriber, handle) = subscriber::mock()
104 .new_span(span.clone())
105 .enter(span.clone())
106 .event(
107 expect::event()
108 .with_fields(expect::field("a").with_value(&tracing::field::display(2)))
109 .at_level(Level::INFO),
110 )
111 .event(
112 expect::event()
113 .with_fields(expect::field("return").with_value(&tracing::field::debug(2)))
114 .at_level(Level::INFO),
115 )
116 .exit(span.clone())
117 .drop_span(span)
118 .only()
119 .run_with_handle();
120
121 with_default(subscriber, || ret_mut(&mut 1));
122 handle.assert_finished();
123 }
124
125 #[instrument(ret)]
ret_async() -> i32126 async fn ret_async() -> i32 {
127 42
128 }
129
130 #[test]
test_async()131 fn test_async() {
132 let span = expect::span().named("ret_async");
133 let (subscriber, handle) = subscriber::mock()
134 .new_span(span.clone())
135 .enter(span.clone())
136 .event(
137 expect::event()
138 .with_fields(expect::field("return").with_value(&tracing::field::debug(42)))
139 .at_level(Level::INFO),
140 )
141 .exit(span.clone())
142 .enter(span.clone())
143 .exit(span.clone())
144 .drop_span(span)
145 .only()
146 .run_with_handle();
147
148 with_default(subscriber, || block_on_future(async { ret_async().await }));
149 handle.assert_finished();
150 }
151
152 #[instrument(ret)]
ret_impl_type() -> impl Copy153 fn ret_impl_type() -> impl Copy {
154 42
155 }
156
157 #[test]
test_impl_type()158 fn test_impl_type() {
159 let span = expect::span().named("ret_impl_type");
160 let (subscriber, handle) = subscriber::mock()
161 .new_span(span.clone())
162 .enter(span.clone())
163 .event(
164 expect::event()
165 .with_fields(expect::field("return").with_value(&tracing::field::debug(42)))
166 .at_level(Level::INFO),
167 )
168 .exit(span.clone())
169 .drop_span(span)
170 .only()
171 .run_with_handle();
172
173 with_default(subscriber, ret_impl_type);
174 handle.assert_finished();
175 }
176
177 #[instrument(ret(Display))]
ret_display() -> i32178 fn ret_display() -> i32 {
179 42
180 }
181
182 #[test]
test_dbg()183 fn test_dbg() {
184 let span = expect::span().named("ret_display");
185 let (subscriber, handle) = subscriber::mock()
186 .new_span(span.clone())
187 .enter(span.clone())
188 .event(
189 expect::event()
190 .with_fields(expect::field("return").with_value(&tracing::field::display(42)))
191 .at_level(Level::INFO),
192 )
193 .exit(span.clone())
194 .drop_span(span)
195 .only()
196 .run_with_handle();
197
198 with_default(subscriber, ret_display);
199 handle.assert_finished();
200 }
201
202 #[instrument(err, ret)]
ret_and_err() -> Result<u8, TryFromIntError>203 fn ret_and_err() -> Result<u8, TryFromIntError> {
204 u8::try_from(1234)
205 }
206
207 #[test]
test_ret_and_err()208 fn test_ret_and_err() {
209 let span = expect::span().named("ret_and_err");
210 let (subscriber, handle) = subscriber::mock()
211 .new_span(span.clone())
212 .enter(span.clone())
213 .event(
214 expect::event()
215 .with_fields(
216 expect::field("error")
217 .with_value(&tracing::field::display(u8::try_from(1234).unwrap_err()))
218 .only(),
219 )
220 .at_level(Level::ERROR),
221 )
222 .exit(span.clone())
223 .drop_span(span)
224 .only()
225 .run_with_handle();
226
227 with_default(subscriber, || ret_and_err().ok());
228 handle.assert_finished();
229 }
230
231 #[instrument(err, ret)]
ret_and_ok() -> Result<u8, TryFromIntError>232 fn ret_and_ok() -> Result<u8, TryFromIntError> {
233 u8::try_from(123)
234 }
235
236 #[test]
test_ret_and_ok()237 fn test_ret_and_ok() {
238 let span = expect::span().named("ret_and_ok");
239 let (subscriber, handle) = subscriber::mock()
240 .new_span(span.clone())
241 .enter(span.clone())
242 .event(
243 expect::event()
244 .with_fields(
245 expect::field("return")
246 .with_value(&tracing::field::debug(u8::try_from(123).unwrap()))
247 .only(),
248 )
249 .at_level(Level::INFO),
250 )
251 .exit(span.clone())
252 .drop_span(span)
253 .only()
254 .run_with_handle();
255
256 with_default(subscriber, || ret_and_ok().ok());
257 handle.assert_finished();
258 }
259
260 #[instrument(level = "warn", ret(level = "info"))]
ret_warn_info() -> i32261 fn ret_warn_info() -> i32 {
262 42
263 }
264
265 #[test]
test_warn_info()266 fn test_warn_info() {
267 let span = expect::span().named("ret_warn_info").at_level(Level::WARN);
268 let (subscriber, handle) = subscriber::mock()
269 .new_span(span.clone())
270 .enter(span.clone())
271 .event(
272 expect::event()
273 .with_fields(expect::field("return").with_value(&tracing::field::debug(42)))
274 .at_level(Level::INFO),
275 )
276 .exit(span.clone())
277 .drop_span(span)
278 .only()
279 .run_with_handle();
280
281 with_default(subscriber, ret_warn_info);
282 handle.assert_finished();
283 }
284
285 #[instrument(ret(level = "warn", Debug))]
ret_dbg_warn() -> i32286 fn ret_dbg_warn() -> i32 {
287 42
288 }
289
290 #[test]
test_dbg_warn()291 fn test_dbg_warn() {
292 let span = expect::span().named("ret_dbg_warn").at_level(Level::INFO);
293 let (subscriber, handle) = subscriber::mock()
294 .new_span(span.clone())
295 .enter(span.clone())
296 .event(
297 expect::event()
298 .with_fields(expect::field("return").with_value(&tracing::field::debug(42)))
299 .at_level(Level::WARN),
300 )
301 .exit(span.clone())
302 .drop_span(span)
303 .only()
304 .run_with_handle();
305
306 with_default(subscriber, ret_dbg_warn);
307 handle.assert_finished();
308 }
309