Introduce ErasableError for implementors to return arbitrary errors

Author: SpriteOvO

spdlog/examples/04_format.rs

@@ -52,11 +52,12 @@ fn impl_manually() {
             let style_range_begin = dest.len();
 
             dest.write_str(&record.level().as_str().to_ascii_uppercase())
-                .map_err(spdlog::Error::FormatRecord)?;
+                .map_err(|err| spdlog::Error::FormatRecord(err.into()))?;
 
             let style_range_end = dest.len();
 
-            writeln!(dest, " {}", record.payload()).map_err(spdlog::Error::FormatRecord)?;
+            writeln!(dest, " {}", record.payload())
+                .map_err(|err| spdlog::Error::FormatRecord(err.into()))?;
 
             ctx.set_style_range(Some(style_range_begin..style_range_end));
             Ok(())

spdlog/src/error.rs

@@ -6,6 +6,7 @@
 //! handler will be used, which will print the error to `stderr`.
 
 use std::{
+    error::Error as StdError,
     fmt::{self, Display},
     io, result,
 };
@@ -18,6 +19,81 @@ use crate::utils::const_assert;
 #[cfg(feature = "multi-thread")]
 use crate::{sink::Task, RecordOwned};
 
+/// Stores an error that can either be typed or erased.
+///
+/// This wrapper is mainly used for returning arbitrary errors from downstream
+/// implementors.
+///
+/// # Examples
+///
+/// ```
+/// use std::{error::Error, fmt, io};
+///
+/// use spdlog::{error::ErasableError, formatter::Formatter, prelude::*, sink::Sink, Record};
+///
+/// #[derive(Debug)]
+/// struct MyError;
+///
+/// impl Error for MyError {}
+///
+/// impl fmt::Display for MyError {
+///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+///         write!(f, "MyError")
+///     }
+/// }
+///
+/// struct MySink;
+///
+/// impl Sink for MySink {
+///     fn log(&self, record: &Record) -> spdlog::Result<()> {
+///         let err: MyError = /* Something went wrong */
+///             # MyError;
+///         // `err` can not be converted to `io::Error`, so we use `Erased`
+///         Err(spdlog::Error::WriteRecord(ErasableError::erase(MyError)))
+///     }
+///
+///     fn flush(&self) -> spdlog::Result<()> {
+///         let err: io::Error = /* Something went wrong */
+///             # io::Error::new(io::ErrorKind::NotFound, "");
+///         // `err` is a `io::Error`, so we use `Typed`
+///         Err(spdlog::Error::FlushBuffer(err.into()))
+///     }
+///
+///     fn level_filter(&self) -> LevelFilter /* ... */
+///     # { unimplemented!() }
+///     fn set_level_filter(&self, level_filter: LevelFilter) /* ... */
+///     # { unimplemented!() }
+///     fn set_formatter(&self, formatter: Box<dyn Formatter>) /* ... */
+///     # { unimplemented!() }
+///     fn set_error_handler(&self, handler: Option<spdlog::ErrorHandler>) /* ... */
+///     # { unimplemented!() }
+/// }
+/// ```
+#[derive(Error, Debug)]
+pub enum ErasableError<E: StdError> {
+    /// A concrete error type is held, and the user can access it.
+    #[error("{0}")]
+    Typed(E),
+    /// The concrete type may not match, thus it is erased to a basic
+    /// `dyn std::error::Error`.
+    #[error("{0}")]
+    Erased(Box<dyn StdError>),
+}
+
+impl<E: StdError> ErasableError<E> {
+    /// Erase a typed error to a basic `Box<dyn std::error::Error>`.
+    #[must_use]
+    pub fn erase<R: StdError + 'static>(err: R) -> ErasableError<E> {
+        ErasableError::Erased(Box::new(err))
+    }
+}
+
+impl<E: StdError> From<E> for ErasableError<E> {
+    fn from(err: E) -> Self {
+        Self::Typed(err)
+    }
+}
+
 /// Contains most errors of this crate.
 #[derive(Error, Debug)]
 #[non_exhaustive]
@@ -26,20 +102,20 @@ pub enum Error {
     ///
     /// [`Formatter`]: crate::formatter::Formatter
     #[error("format record error: {0}")]
-    FormatRecord(fmt::Error),
+    FormatRecord(ErasableError<fmt::Error>),
 
     /// Returned by [`Sink`]s when an error occurs in writing a record to the
     /// target.
     ///
     /// [`Sink`]: crate::sink::Sink
     #[error("write record error: {0}")]
-    WriteRecord(io::Error),
+    WriteRecord(ErasableError<io::Error>),
 
     /// Returned by [`Sink`]s when an error occurs in flushing the buffer.
     ///
     /// [`Sink`]: crate::sink::Sink
     #[error("flush buffer error: {0}")]
-    FlushBuffer(io::Error),
+    FlushBuffer(ErasableError<io::Error>),
 
     /// Returned by [`Sink`]s when an error occurs in creating a directory.
     ///

spdlog/src/formatter/full_formatter.rs

@@ -111,7 +111,7 @@ impl Formatter for FullFormatter {
         ctx: &mut FormatterContext,
     ) -> crate::Result<()> {
         self.format_impl(record, dest, ctx)
-            .map_err(Error::FormatRecord)
+            .map_err(|err| Error::FormatRecord(err.into()))
     }
 }
 

spdlog/src/formatter/journald_formatter.rs

@@ -63,7 +63,7 @@ impl Formatter for JournaldFormatter {
         ctx: &mut FormatterContext,
     ) -> crate::Result<()> {
         self.format_impl(record, dest, ctx)
-            .map_err(Error::FormatRecord)
+            .map_err(|err| Error::FormatRecord(err.into()))
     }
 }
 

spdlog/src/formatter/json_formatter.rs

@@ -78,7 +78,7 @@ impl From<serde_json::Error> for JsonFormatterError {
 impl From<JsonFormatterError> for crate::Error {
     fn from(value: JsonFormatterError) -> Self {
         match value {
-            JsonFormatterError::Fmt(e) => Error::FormatRecord(e),
+            JsonFormatterError::Fmt(e) => Error::FormatRecord(e.into()),
             JsonFormatterError::Serialization(e) => Error::SerializeRecord(e.into()),
         }
     }

spdlog/src/formatter/pattern_formatter/mod.rs

@@ -161,7 +161,7 @@ use crate::{
 ///
 /// impl Pattern for MyPattern {
 ///     fn format(&self, record: &Record, dest: &mut StringBuf, _: &mut PatternContext) -> spdlog::Result<()> {
-///         write!(dest, "My own pattern").map_err(spdlog::Error::FormatRecord)
+///         write!(dest, "My own pattern").map_err(|err| spdlog::Error::FormatRecord(err.into()))
 ///     }
 /// }
 ///
@@ -225,7 +225,7 @@ use crate::{
 ///
 /// impl Pattern for MyPattern {
 ///     fn format(&self, record: &Record, dest: &mut StringBuf, _: &mut PatternContext) -> spdlog::Result<()> {
-///         write!(dest, "{}", self.id).map_err(spdlog::Error::FormatRecord)
+///         write!(dest, "{}", self.id).map_err(|err| spdlog::Error::FormatRecord(err.into()))
 ///     }
 /// }
 ///
@@ -472,7 +472,8 @@ impl Pattern for str {
         dest: &mut StringBuf,
         _ctx: &mut PatternContext,
     ) -> crate::Result<()> {
-        dest.write_str(self).map_err(Error::FormatRecord)
+        dest.write_str(self)
+            .map_err(|err| Error::FormatRecord(err.into()))
     }
 }