@@ -269,14 +269,63 @@ mod tests {
269
269
270
270
use super :: * ;
271
271
use opentelemetry:: global:: { logger, set_logger_provider, shutdown_logger_provider} ;
272
- use opentelemetry:: logs:: Logger ;
273
- use opentelemetry:: { Key , KeyValue , Value } ;
274
272
use opentelemetry:: logs:: { Logger , LoggerProvider as _} ;
273
+ use opentelemetry:: { Key , KeyValue , Value } ;
275
274
use std:: fmt:: { Debug , Formatter } ;
276
275
use std:: sync:: atomic:: AtomicU64 ;
277
276
use std:: sync:: { Arc , Mutex } ;
278
277
use std:: thread;
279
278
279
+ struct ShutdownTestLogProcessor {
280
+ is_shutdown : Arc < Mutex < bool > > ,
281
+ counter : Arc < AtomicU64 > ,
282
+ }
283
+
284
+ impl Debug for ShutdownTestLogProcessor {
285
+ fn fmt ( & self , _f : & mut Formatter < ' _ > ) -> std:: fmt:: Result {
286
+ todo ! ( )
287
+ }
288
+ }
289
+
290
+ impl ShutdownTestLogProcessor {
291
+ pub ( crate ) fn new ( counter : Arc < AtomicU64 > ) -> Self {
292
+ ShutdownTestLogProcessor {
293
+ is_shutdown : Arc :: new ( Mutex :: new ( false ) ) ,
294
+ counter,
295
+ }
296
+ }
297
+ }
298
+
299
+ impl LogProcessor for ShutdownTestLogProcessor {
300
+ fn emit ( & self , _data : LogData ) {
301
+ self . is_shutdown
302
+ . lock ( )
303
+ . map ( |is_shutdown| {
304
+ if !* is_shutdown {
305
+ self . counter
306
+ . fetch_add ( 1 , std:: sync:: atomic:: Ordering :: SeqCst ) ;
307
+ }
308
+ } )
309
+ . expect ( "lock poisoned" ) ;
310
+ }
311
+
312
+ fn force_flush ( & self ) -> LogResult < ( ) > {
313
+ Ok ( ( ) )
314
+ }
315
+
316
+ fn shutdown ( & self ) -> LogResult < ( ) > {
317
+ self . is_shutdown
318
+ . lock ( )
319
+ . map ( |mut is_shutdown| * is_shutdown = true )
320
+ . expect ( "lock poisoned" ) ;
321
+ Ok ( ( ) )
322
+ }
323
+
324
+ #[ cfg( feature = "logs_level_enabled" ) ]
325
+ fn event_enabled ( & self , _level : Severity , _target : & str , _name : & str ) -> bool {
326
+ true
327
+ }
328
+ }
280
329
#[ test]
281
330
fn test_logger_provider_default_resource ( ) {
282
331
let assert_resource = |provider : & super :: LoggerProvider ,
@@ -403,57 +452,6 @@ mod tests {
403
452
assert_eq ! ( no_service_name. config( ) . resource. len( ) , 0 ) ;
404
453
}
405
454
406
- struct ShutdownTestLogProcessor {
407
- is_shutdown : Arc < Mutex < bool > > ,
408
- counter : Arc < AtomicU64 > ,
409
- }
410
-
411
- impl Debug for ShutdownTestLogProcessor {
412
- fn fmt ( & self , _f : & mut Formatter < ' _ > ) -> std:: fmt:: Result {
413
- todo ! ( )
414
- }
415
- }
416
-
417
- impl ShutdownTestLogProcessor {
418
- pub ( crate ) fn new ( counter : Arc < AtomicU64 > ) -> Self {
419
- ShutdownTestLogProcessor {
420
- is_shutdown : Arc :: new ( Mutex :: new ( false ) ) ,
421
- counter,
422
- }
423
- }
424
- }
425
-
426
- impl LogProcessor for ShutdownTestLogProcessor {
427
- fn emit ( & self , _data : LogData ) {
428
- self . is_shutdown
429
- . lock ( )
430
- . map ( |is_shutdown| {
431
- if !* is_shutdown {
432
- self . counter
433
- . fetch_add ( 1 , std:: sync:: atomic:: Ordering :: SeqCst ) ;
434
- }
435
- } )
436
- . expect ( "lock poisoned" ) ;
437
- }
438
-
439
- fn force_flush ( & self ) -> LogResult < ( ) > {
440
- Ok ( ( ) )
441
- }
442
-
443
- fn shutdown ( & self ) -> LogResult < ( ) > {
444
- self . is_shutdown
445
- . lock ( )
446
- . map ( |mut is_shutdown| * is_shutdown = true )
447
- . expect ( "lock poisoned" ) ;
448
- Ok ( ( ) )
449
- }
450
-
451
- #[ cfg( feature = "logs_level_enabled" ) ]
452
- fn event_enabled ( & self , _level : Severity , _target : & str , _name : & str ) -> bool {
453
- true
454
- }
455
- }
456
-
457
455
#[ test]
458
456
fn shutdown_test ( ) {
459
457
let counter = Arc :: new ( AtomicU64 :: new ( 0 ) ) ;
@@ -524,36 +522,19 @@ mod tests {
524
522
thread:: sleep ( std:: time:: Duration :: from_millis ( 10 ) ) ;
525
523
}
526
524
527
- // Intentionally *not* calling shutdown/flush on the provider, but
528
- // instead relying on shutdown_logger_provider which causes the global
529
- // provider to be dropped, leading to the sdk logger provider's drop to
530
- // be called, which is expected to call shutdown on processors.
525
+ // shutdown logger provider explicitly call shutdown on the logger
531
526
shutdown_logger_provider ( ) ;
532
527
533
528
// Assert
534
529
535
- // shutdown_logger_provider is necessary but not sufficient, as loggers
536
- // hold on to the the provider (via inner provider clones).
537
- assert ! ( !* shutdown_called. lock( ) . unwrap( ) ) ;
530
+ // shutdown_logger_provider should be shutdown regardless if the logger is dropped.
531
+ assert ! ( * shutdown_called. lock( ) . unwrap( ) ) ;
538
532
539
533
// flush is never called by the sdk.
540
534
assert ! ( !* flush_called. lock( ) . unwrap( ) ) ;
541
535
542
- // Drop one of the logger. Not enough!
543
- drop ( logger1) ;
544
- assert ! ( !* shutdown_called. lock( ) . unwrap( ) ) ;
545
-
546
- // drop logger2, which is the only remaining logger in this thread.
547
- // Still not enough!
548
- drop ( logger2) ;
549
- assert ! ( !* shutdown_called. lock( ) . unwrap( ) ) ;
550
-
551
- // now signal the spawned thread to end, which causes it to drop its
552
- // logger. Since that is the last logger, the provider (inner provider)
553
- // is finally dropped, triggering shutdown
554
536
* signal_to_end. lock ( ) . unwrap ( ) = true ;
555
537
handle. join ( ) . unwrap ( ) ;
556
- assert ! ( * shutdown_called. lock( ) . unwrap( ) ) ;
557
538
558
539
// flush is never called by the sdk.
559
540
assert ! ( !* flush_called. lock( ) . unwrap( ) ) ;
0 commit comments