@@ -14,6 +14,7 @@ use crate::trace::{
14
14
} ;
15
15
use crate :: { export:: trace:: SpanExporter , trace:: SpanProcessor } ;
16
16
use crate :: { InstrumentationLibrary , Resource } ;
17
+ use futures_util:: StreamExt ;
17
18
use once_cell:: sync:: { Lazy , OnceCell } ;
18
19
use opentelemetry:: trace:: TraceError ;
19
20
use opentelemetry:: { global, trace:: TraceResult } ;
@@ -49,11 +50,14 @@ pub(crate) struct TracerProviderInner {
49
50
50
51
impl Drop for TracerProviderInner {
51
52
fn drop ( & mut self ) {
52
- for processor in & mut self . processors {
53
- if let Err ( err) = processor. shutdown ( ) {
54
- global:: handle_error ( err) ;
53
+ let processors = std:: mem:: take ( & mut self . processors ) ;
54
+ crate :: util:: spawn_future ( async move {
55
+ for processor in processors {
56
+ if let Err ( err) = processor. shutdown ( ) . await {
57
+ global:: handle_error ( err) ;
58
+ }
55
59
}
56
- }
60
+ } )
57
61
}
58
62
}
59
63
@@ -121,13 +125,14 @@ impl TracerProvider {
121
125
/// provider
122
126
/// }
123
127
///
124
- /// fn main() {
128
+ /// #[tokio::main]
129
+ /// async fn main() {
125
130
/// let provider = init_tracing();
126
131
///
127
132
/// // create spans..
128
133
///
129
134
/// // force all spans to flush
130
- /// for result in provider.force_flush() {
135
+ /// for result in provider.force_flush().await {
131
136
/// if let Err(err) = result {
132
137
/// // .. handle flush error
133
138
/// }
@@ -141,17 +146,17 @@ impl TracerProvider {
141
146
/// global::shutdown_tracer_provider();
142
147
/// }
143
148
/// ```
144
- pub fn force_flush ( & self ) -> Vec < TraceResult < ( ) > > {
145
- self . span_processors ( )
146
- . iter ( )
147
- . map ( |processor| processor. force_flush ( ) )
149
+ pub async fn force_flush ( & self ) -> Vec < TraceResult < ( ) > > {
150
+ futures_util:: stream:: iter ( self . span_processors ( ) )
151
+ . then ( |processor| processor. force_flush ( ) )
148
152
. collect ( )
153
+ . await
149
154
}
150
155
151
156
/// Shuts down the current `TracerProvider`.
152
157
///
153
158
/// Note that shut down doesn't means the TracerProvider has dropped
154
- pub fn shutdown ( & self ) -> TraceResult < ( ) > {
159
+ pub async fn shutdown ( & self ) -> TraceResult < ( ) > {
155
160
if self
156
161
. is_shutdown
157
162
. compare_exchange ( false , true , Ordering :: SeqCst , Ordering :: SeqCst )
@@ -161,7 +166,7 @@ impl TracerProvider {
161
166
// it's up to the processor to properly block new spans after shutdown
162
167
let mut errs = vec ! [ ] ;
163
168
for processor in & self . inner . processors {
164
- if let Err ( err) = processor. shutdown ( ) {
169
+ if let Err ( err) = processor. shutdown ( ) . await {
165
170
errs. push ( err) ;
166
171
}
167
172
}
@@ -348,6 +353,7 @@ mod tests {
348
353
}
349
354
}
350
355
356
+ #[ async_trait:: async_trait]
351
357
impl SpanProcessor for TestSpanProcessor {
352
358
fn on_start ( & self , _span : & mut Span , _cx : & Context ) {
353
359
self . assert_info
@@ -356,19 +362,19 @@ mod tests {
356
362
. fetch_add ( 1 , Ordering :: SeqCst ) ;
357
363
}
358
364
359
- fn on_end ( & self , _span : SpanData ) {
365
+ async fn on_end ( & self , _span : SpanData ) {
360
366
// ignore
361
367
}
362
368
363
- fn force_flush ( & self ) -> TraceResult < ( ) > {
369
+ async fn force_flush ( & self ) -> TraceResult < ( ) > {
364
370
if self . success {
365
371
Ok ( ( ) )
366
372
} else {
367
373
Err ( TraceError :: from ( "cannot export" ) )
368
374
}
369
375
}
370
376
371
- fn shutdown ( & self ) -> TraceResult < ( ) > {
377
+ async fn shutdown ( & self ) -> TraceResult < ( ) > {
372
378
if self . assert_info . 0 . is_shutdown . load ( Ordering :: SeqCst ) {
373
379
Ok ( ( ) )
374
380
} else {
@@ -378,13 +384,13 @@ mod tests {
378
384
Ordering :: SeqCst ,
379
385
Ordering :: SeqCst ,
380
386
) ;
381
- self . force_flush ( )
387
+ self . force_flush ( ) . await
382
388
}
383
389
}
384
390
}
385
391
386
- #[ test]
387
- fn test_force_flush ( ) {
392
+ #[ tokio :: test]
393
+ async fn test_force_flush ( ) {
388
394
let tracer_provider = super :: TracerProvider :: new ( TracerProviderInner {
389
395
processors : vec ! [
390
396
Box :: from( TestSpanProcessor :: new( true ) ) ,
@@ -393,7 +399,7 @@ mod tests {
393
399
config : Default :: default ( ) ,
394
400
} ) ;
395
401
396
- let results = tracer_provider. force_flush ( ) ;
402
+ let results = tracer_provider. force_flush ( ) . await ;
397
403
assert_eq ! ( results. len( ) , 2 ) ;
398
404
}
399
405
@@ -527,8 +533,8 @@ mod tests {
527
533
assert_eq ! ( no_service_name. config( ) . resource. len( ) , 0 )
528
534
}
529
535
530
- #[ test]
531
- fn test_shutdown_noops ( ) {
536
+ #[ tokio :: test]
537
+ async fn test_shutdown_noops ( ) {
532
538
let processor = TestSpanProcessor :: new ( false ) ;
533
539
let assert_handle = processor. assert_info ( ) ;
534
540
let tracer_provider = super :: TracerProvider :: new ( TracerProviderInner {
@@ -545,12 +551,12 @@ mod tests {
545
551
546
552
assert ! ( assert_handle. started_span_count( 2 ) ) ;
547
553
548
- let shutdown = |tracer_provider : super :: TracerProvider | {
549
- let _ = tracer_provider. shutdown ( ) ; // shutdown once
554
+ let shutdown = |tracer_provider : super :: TracerProvider | async move {
555
+ let _ = tracer_provider. shutdown ( ) . await ; // shutdown once
550
556
} ;
551
557
552
558
// assert tracer provider can be shutdown using on a cloned version
553
- shutdown ( tracer_provider. clone ( ) ) ;
559
+ shutdown ( tracer_provider. clone ( ) ) . await ;
554
560
555
561
// after shutdown we should get noop tracer
556
562
let noop_tracer = tracer_provider. tracer ( "noop" ) ;
0 commit comments