add shutdown in global logger provider

Author: TommyCpp

opentelemetry-sdk/src/logs/log_emitter.rs

@@ -80,6 +80,20 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider {
         }
         Logger::new(library, self.clone())
     }
+
+    /// Shuts down this `LoggerProvider`
+    fn shutdown(&self) -> Vec<LogResult<()>> {
+        // mark itself as already shutdown
+        self.is_shutdown
+            .store(true, std::sync::atomic::Ordering::Relaxed);
+        // propagate the shutdown signal to processors
+        // it's up to the processor to properly block new logs after shutdown
+        self.inner
+            .processors
+            .iter()
+            .map(|processor| processor.shutdown())
+            .collect()
+    }
 }
 
 impl LoggerProvider {
@@ -105,27 +119,6 @@ impl LoggerProvider {
             .map(|processor| processor.force_flush())
             .collect()
     }
-
-    /// Shuts down this `LoggerProvider`, panicking on failure.
-    pub fn shutdown(&mut self) -> Vec<LogResult<()>> {
-        // mark itself as already shutdown
-        self.is_shutdown
-            .store(true, std::sync::atomic::Ordering::Relaxed);
-        // propagate the shutdown signal to processors
-        // it's up to the processor to properly block new logs after shutdown
-        self.inner
-            .processors
-            .iter()
-            .map(|processor| processor.shutdown())
-            .collect()
-    }
-
-    /// Attempts to shutdown this `LoggerProvider`, succeeding only when
-    /// all cloned `LoggerProvider` values have been dropped.
-    // todo: remove this
-    pub fn try_shutdown(&mut self) -> Option<Vec<LogResult<()>>> {
-        Some(self.shutdown())
-    }
 }
 
 #[derive(Debug)]
@@ -464,7 +457,7 @@ mod tests {
     #[test]
     fn shutdown_test() {
         let counter = Arc::new(AtomicU64::new(0));
-        let mut logger_provider = LoggerProvider::builder()
+        let logger_provider = LoggerProvider::builder()
             .with_log_processor(ShutdownTestLogProcessor::new(counter.clone()))
             .build();
 

opentelemetry/src/global/logs.rs

@@ -6,6 +6,7 @@ use std::{
 
 use once_cell::sync::Lazy;
 
+use crate::logs::LogResult;
 use crate::{
     logs::{Logger, LoggerProvider, NoopLoggerProvider},
     InstrumentationLibrary,
@@ -25,6 +26,9 @@ pub trait ObjectSafeLoggerProvider {
         &self,
         library: Arc<InstrumentationLibrary>,
     ) -> Box<dyn Logger + Send + Sync + 'static>;
+
+    /// shutdown the logger provider, logs emitted after this will not be processed.
+    fn shutdown(&self) -> Vec<LogResult<()>>;
 }
 
 impl<L, P> ObjectSafeLoggerProvider for P
@@ -38,6 +42,10 @@ where
     ) -> Box<dyn Logger + Send + Sync + 'static> {
         Box::new(self.library_logger(library))
     }
+
+    fn shutdown(&self) -> Vec<LogResult<()>> {
+        self.shutdown()
+    }
 }
 
 pub struct BoxedLogger(Box<dyn Logger + Send + Sync + 'static>);
@@ -132,5 +140,6 @@ where
 
 /// Shut down the current global [`LoggerProvider`].
 pub fn shutdown_logger_provider() {
-    let _ = set_logger_provider(NoopLoggerProvider::new());
+    let logger_provider = set_logger_provider(NoopLoggerProvider::new());
+    let _ = ObjectSafeLoggerProvider::shutdown(&logger_provider);
 }

opentelemetry/src/logs/logger.rs

@@ -1,6 +1,6 @@
 use std::{borrow::Cow, sync::Arc};
 
-use crate::{logs::LogRecord, InstrumentationLibrary, InstrumentationLibraryBuilder, KeyValue};
+use crate::{logs::{LogRecord, LogResult}, InstrumentationLibrary, InstrumentationLibraryBuilder, KeyValue};
 
 #[cfg(feature = "logs_level_enabled")]
 use super::Severity;
@@ -145,4 +145,12 @@ impl<'a, T: LoggerProvider + ?Sized> LoggerBuilder<'a, T> {
         self.provider
             .library_logger(Arc::new(self.library_builder.build()))
     }
+
+    /// Shutdown the logger provider. Noop logger will be returned after shutdown.
+    ///
+    /// Note that `shutdown` doesn't mean `Drop`(though `Drop` can call `shutdown`).
+    /// It simply means the provider will emit anything in the buffer(if applicable) and stop processing
+    fn shutdown(&self) -> Vec<LogResult<()>> {
+        Vec::new() // noop
+    }
 }