refactor!: Append::flush is now fallible (#117)

Signed-off-by: tison <[email protected]>

Author: tisonkun

CHANGELOG.md

@@ -7,6 +7,7 @@ All notable changes to this project will be documented in this file.
 ### Breaking changes
 
 * `Diagnosic` is now a trait. `Visitor`'s method signature is simplified.
+* `Append::flush` is now fallible.
 
 ### New features
 

src/append/fastrace.rs

@@ -66,8 +66,9 @@ impl Append for FastraceEvent {
         Ok(())
     }
 
-    fn flush(&self) {
+    fn flush(&self) -> anyhow::Result<()> {
         fastrace::flush();
+        Ok(())
     }
 }
 

src/append/mod.rs

@@ -57,7 +57,11 @@ pub trait Append: fmt::Debug + Send + Sync + 'static {
     ) -> anyhow::Result<()>;
 
     /// Flushes any buffered records.
-    fn flush(&self) {}
+    ///
+    /// Default to a no-op.
+    fn flush(&self) -> anyhow::Result<()> {
+        Ok(())
+    }
 }
 
 impl<T: Append> From<T> for Box<dyn Append> {

src/append/opentelemetry.rs

@@ -200,10 +200,9 @@ impl OpentelemetryLogBuilder {
             .with_resource(resource)
             .build();
 
-        let library = InstrumentationScope::builder(name.clone()).build();
+        let library = InstrumentationScope::builder(name).build();
         let logger = provider.logger_with_scope(library);
         Ok(OpentelemetryLog {
-            name,
             layout,
             logger,
             provider,
@@ -228,7 +227,6 @@ impl OpentelemetryLogBuilder {
 /// ```
 #[derive(Debug)]
 pub struct OpentelemetryLog {
-    name: String,
     layout: Option<Box<dyn Layout>>,
     logger: opentelemetry_sdk::logs::SdkLogger,
     provider: SdkLoggerProvider,
@@ -268,10 +266,9 @@ impl Append for OpentelemetryLog {
         Ok(())
     }
 
-    fn flush(&self) {
-        if let Err(err) = self.provider.force_flush() {
-            eprintln!("failed to flush logger {}: {}", self.name, err);
-        }
+    fn flush(&self) -> anyhow::Result<()> {
+        self.provider.force_flush()?;
+        Ok(())
     }
 }
 

src/append/rolling_file/append.rs

@@ -58,11 +58,10 @@ impl Append for BlockingRollingFile {
         Ok(())
     }
 
-    fn flush(&self) {
+    fn flush(&self) -> anyhow::Result<()> {
         let mut writer = self.writer.lock().unwrap_or_else(|e| e.into_inner());
-        if let Err(err) = Write::flush(&mut *writer) {
-            eprintln!("failed to flush writer: {err}");
-        }
+        Write::flush(&mut *writer)?;
+        Ok(())
     }
 }
 

src/append/stdio.rs

@@ -68,8 +68,9 @@ impl Append for Stdout {
         Ok(())
     }
 
-    fn flush(&self) {
-        let _ = std::io::stdout().flush();
+    fn flush(&self) -> anyhow::Result<()> {
+        std::io::stdout().flush()?;
+        Ok(())
     }
 }
 
@@ -120,7 +121,8 @@ impl Append for Stderr {
         Ok(())
     }
 
-    fn flush(&self) {
-        let _ = std::io::stderr().flush();
+    fn flush(&self) -> anyhow::Result<()> {
+        std::io::stderr().flush()?;
+        Ok(())
     }
 }

src/append/syslog.rs

@@ -162,11 +162,10 @@ impl Append for BlockingSyslog {
         Ok(())
     }
 
-    fn flush(&self) {
+    fn flush(&self) -> anyhow::Result<()> {
         let mut writer = self.writer.lock().unwrap_or_else(|e| e.into_inner());
-        if let Err(err) = writer.flush() {
-            eprintln!("failed to flush writer: {err}");
-        }
+        writer.flush()?;
+        Ok(())
     }
 }
 

src/logger/log_impl.rs

@@ -47,14 +47,16 @@ impl log::Log for Logger {
     fn log(&self, record: &Record) {
         for dispatch in &self.dispatches {
             if let Err(err) = dispatch.log(record) {
-                handle_error(record, err);
+                handle_log_error(record, err);
             }
         }
     }
 
     fn flush(&self) {
         for dispatch in &self.dispatches {
-            dispatch.flush();
+            if let Err(err) = dispatch.flush() {
+                handle_flush_error(err);
+            }
         }
     }
 }
@@ -119,14 +121,15 @@ impl Dispatch {
         Ok(())
     }
 
-    fn flush(&self) {
+    fn flush(&self) -> anyhow::Result<()> {
         for append in &self.appends {
-            append.flush();
+            append.flush()?;
         }
+        Ok(())
     }
 }
 
-fn handle_error(record: &Record, error: anyhow::Error) {
+fn handle_log_error(record: &Record, error: anyhow::Error) {
     let Err(fallback_error) = write!(
         std::io::stderr(),
         r###"
@@ -156,3 +159,26 @@ Error performing stderr logging after error occurred during regular logging.
         fallback_error = fallback_error,
     );
 }
+
+fn handle_flush_error(error: anyhow::Error) {
+    let Err(fallback_error) = write!(
+        std::io::stderr(),
+        r###"
+Error perform flush.
+    Error: {error:?}
+"###,
+        error = error,
+    ) else {
+        return;
+    };
+
+    panic!(
+        r###"
+Error performing stderr logging after error occurred during regular flush.
+    Error: {error:?}
+    Fallback error: {fallback_error}
+"###,
+        error = error,
+        fallback_error = fallback_error,
+    );
+}