ntex_error/

message.rs

use std::{error::Error as StdError, fmt, fmt::Write, sync::Arc};

use ntex_bytes::ByteString;

use crate::{AsError, ErrorDiagnostic, ResultType};

struct Wrt<'a> {
    written: usize,
    fmt: &'a mut dyn fmt::Write,
}

impl<'a> Wrt<'a> {
    fn new(fmt: &'a mut dyn fmt::Write) -> Self {
        Wrt { fmt, written: 0 }
    }

    fn wrote(&mut self) -> usize {
        let res = self.written;
        self.written = 0;
        res
    }
}

impl fmt::Write for Wrt<'_> {
    fn write_str(&mut self, s: &str) -> Result<(), fmt::Error> {
        self.written += s.len();
        self.fmt.write_str(s)
    }

    fn write_char(&mut self, c: char) -> Result<(), fmt::Error> {
        self.written += 1;
        self.fmt.write_char(c)
    }
}

/// Formats an error and its source chain into a string.
pub fn fmt_err_string(e: &dyn StdError) -> String {
    let mut buf = String::new();
    _ = fmt_err(&mut buf, e);
    buf
}

/// Writes an error and its source chain.
pub fn fmt_err(f: &mut dyn fmt::Write, e: &dyn StdError) -> fmt::Result {
    let mut wrt = Wrt::new(f);
    let mut current = Some(e);
    while let Some(std_err) = current {
        write!(&mut wrt, "{std_err}")?;
        if wrt.wrote() > 0 {
            writeln!(wrt.fmt)?;
        }
        current = std_err.source();
    }
    Ok(())
}

/// Formats a full diagnostic view of an error for logging and tracing.
pub fn fmt_diag_string<'a, T>(e: &'a T) -> String
where
    T: ErrorDiagnostic + AsError,
    ResultType: From<&'a T::Target>,
{
    let mut buf = String::new();
    _ = fmt_diag(&mut buf, e);
    buf
}

/// Formats a full diagnostic view of an error for logging and tracing.
///
/// Includes the result type, signature, tag, service, and the display
/// representation of the error and its source chain. For `ServiceError`
/// results, a resolved backtrace is appended when available.
pub fn fmt_diag<'a, T>(f: &mut dyn fmt::Write, container: &'a T) -> fmt::Result
where
    T: ErrorDiagnostic + AsError,
    ResultType: From<&'a T::Target>,
{
    fmt_diag_typ(f, Some(ResultType::from(container.as_diag())), container)
}

/// Formats a full diagnostic view of an error for logging and tracing.
///
/// Includes the result type, signature, tag, service, and the display
/// representation of the error and its source chain. For `ServiceError`
/// results, a resolved backtrace is appended when available.
pub fn fmt_diag_typ<T>(f: &mut dyn fmt::Write, typ: Option<ResultType>, e: &T) -> fmt::Result
where
    T: ErrorDiagnostic,
{
    writeln!(f, "err: {e}")?;
    if let Some(ref tp) = typ {
        writeln!(f, "type: {}", tp.as_str())?;
    }
    writeln!(f, "signature: {}", e.signature())?;

    if let Some(tag) = e.tag() {
        if let Ok(s) = ByteString::try_from(tag) {
            writeln!(f, "tag: {s}")?;
        } else {
            writeln!(f, "tag: {tag:?}")?;
        }
    }
    if let Some(svc) = e.service() {
        writeln!(f, "service: {svc}")?;
    }
    writeln!(f)?;

    let mut wrt = Wrt::new(f);
    write!(&mut wrt, "{e}")?;
    if wrt.wrote() > 0 {
        writeln!(wrt.fmt)?;
    }

    let mut nesting = 0;
    let mut current = e.source();
    while let Some(err) = current {
        nesting += 2;
        write!(&mut wrt, "{}", " ".repeat(nesting))?;
        write!(&mut wrt, "{err}")?;
        if wrt.wrote() > nesting {
            writeln!(wrt.fmt)?;
        }
        current = err.source();
    }

    if typ == Some(ResultType::ServiceError)
        && let Some(bt) = e.backtrace()
        && let Some(repr) = bt.repr()
    {
        writeln!(wrt.fmt, "{repr}")?;
    }

    Ok(())
}

/// A lightweight owned error message.
#[derive(Clone, PartialEq, Eq, thiserror::Error)]
pub struct ErrorMessage(ByteString);

/// An owned error message with an optional source error.
#[derive(Clone)]
pub struct ErrorMessageChained {
    msg: ByteString,
    source: Option<Arc<dyn StdError + Send + Sync>>,
}

impl ErrorMessageChained {
    /// Creates a message error with a source.
    pub fn new<M, E>(ctx: M, source: E) -> Self
    where
        M: Into<ErrorMessage>,
        E: StdError + Send + Sync + 'static,
    {
        ErrorMessageChained {
            msg: ctx.into().into_string(),
            source: Some(Arc::new(source)),
        }
    }

    /// Creates an empty message error without a source.
    pub const fn empty() -> Self {
        Self::from_static("")
    }

    /// Creates a message error without a source from a [`ByteString`].
    pub const fn from_bstr(msg: ByteString) -> Self {
        Self { msg, source: None }
    }

    /// Creates a message error without a source from a static string.
    pub const fn from_static(msg: &'static str) -> Self {
        Self::from_bstr(ByteString::from_static(msg))
    }

    /// Returns `true` if the message is empty.
    pub fn is_empty(&self) -> bool {
        self.msg.is_empty()
    }

    /// Returns the message as a string slice.
    pub fn as_str(&self) -> &str {
        &self.msg
    }

    /// Returns the message as a [`ByteString`].
    pub fn as_bstr(&self) -> &ByteString {
        &self.msg
    }

    /// Converts this error into its message, the source is dropped.
    pub fn into_string(self) -> ByteString {
        self.msg
    }

    /// Sets the source error, replacing the current one.
    #[must_use]
    pub fn with_source<E: StdError + Send + Sync + 'static>(self, source: E) -> Self {
        Self {
            msg: self.msg,
            source: Some(Arc::new(source)),
        }
    }
}

impl ErrorMessage {
    /// Creates an empty error message.
    pub const fn empty() -> Self {
        Self(ByteString::from_static(""))
    }

    /// Creates an error message from a [`ByteString`].
    pub const fn from_bstr(msg: ByteString) -> Self {
        ErrorMessage(msg)
    }

    /// Creates an error message from a static string.
    pub const fn from_static(msg: &'static str) -> Self {
        ErrorMessage(ByteString::from_static(msg))
    }

    /// Returns `true` if the message is empty.
    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    /// Returns the message as a string slice.
    pub fn as_str(&self) -> &str {
        &self.0
    }

    /// Returns the underlying [`ByteString`].
    pub fn as_bstr(&self) -> &ByteString {
        &self.0
    }

    /// Converts this message into its underlying [`ByteString`].
    pub fn into_string(self) -> ByteString {
        self.0
    }

    /// Attaches a source error to this message.
    pub fn with_source<E: StdError + Send + Sync + 'static>(
        self,
        source: E,
    ) -> ErrorMessageChained {
        ErrorMessageChained::new(self, source)
    }
}

impl From<String> for ErrorMessage {
    fn from(value: String) -> Self {
        Self(ByteString::from(value))
    }
}

impl From<ByteString> for ErrorMessage {
    fn from(value: ByteString) -> Self {
        Self(value)
    }
}

impl From<&'static str> for ErrorMessage {
    fn from(value: &'static str) -> Self {
        Self(ByteString::from_static(value))
    }
}

impl fmt::Debug for ErrorMessage {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self.0, f)
    }
}

impl fmt::Display for ErrorMessage {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self.0, f)
    }
}

impl From<ErrorMessage> for ByteString {
    fn from(msg: ErrorMessage) -> Self {
        msg.0
    }
}

impl<'a> From<&'a ErrorMessage> for ByteString {
    fn from(msg: &'a ErrorMessage) -> Self {
        msg.0.clone()
    }
}

impl<M: Into<ErrorMessage>> From<M> for ErrorMessageChained {
    fn from(value: M) -> Self {
        ErrorMessageChained {
            msg: value.into().0,
            source: None,
        }
    }
}

impl StdError for ErrorMessageChained {
    fn source(&self) -> Option<&(dyn StdError + 'static)> {
        self.source
            .as_ref()
            .map(|e| e.as_ref() as &(dyn StdError + 'static))
    }
}

impl fmt::Debug for ErrorMessageChained {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self, f)
    }
}

impl fmt::Display for ErrorMessageChained {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.msg.is_empty() {
            Ok(())
        } else {
            fmt::Display::fmt(&self.msg, f)
        }
    }
}

#[cfg(test)]
#[allow(dead_code)]
mod tests {
    use ntex_bytes::Bytes;
    use std::{error::Error, io};

    use super::*;

    #[test]
    fn error_message() {
        let msg = ErrorMessage::empty();
        assert!(msg.is_empty());
        assert_eq!(msg.as_str(), "");
        assert_eq!(msg.as_bstr(), ByteString::new());
        assert_eq!(ByteString::new(), msg.as_bstr());
        assert_eq!(ByteString::new(), msg.into_string());

        let msg = ErrorMessage::from("test");
        assert!(!msg.is_empty());
        assert_eq!(format!("{msg}"), "test");
        assert_eq!(format!("{msg:?}"), "test");
        assert_eq!(msg.as_str(), "test");
        assert_eq!(msg.as_bstr(), ByteString::from("test"));

        let msg = ErrorMessage::from("test".to_string());
        assert!(!msg.is_empty());
        assert_eq!(msg.as_str(), "test");
        assert_eq!(msg.as_bstr(), ByteString::from("test"));

        let msg = ErrorMessage::from_bstr(ByteString::from("test"));
        assert!(!msg.is_empty());
        assert_eq!(msg.as_str(), "test");
        assert_eq!(msg.as_bstr(), ByteString::from("test"));

        let msg = ErrorMessage::from(ByteString::from("test"));
        assert!(!msg.is_empty());
        assert_eq!(msg.as_str(), "test");
        assert_eq!(msg.as_bstr(), ByteString::from("test"));

        let msg = ErrorMessage::from_static("test");
        assert!(!msg.is_empty());
        assert_eq!(msg.as_str(), "test");
        assert_eq!(msg.as_bstr(), ByteString::from("test"));

        assert_eq!(ByteString::from(&msg), "test");
        assert_eq!(ByteString::from(msg), "test");
    }

    #[test]
    fn error_message_chained() {
        let chained = ErrorMessageChained::from(ByteString::from("test"));
        assert_eq!(chained.as_bstr(), "test");
        assert!(chained.source().is_none());

        let chained = ErrorMessageChained::from_bstr(ByteString::from("test"));
        assert_eq!(chained.as_bstr(), "test");
        assert!(chained.source().is_none());
        assert_eq!(format!("{chained}"), "test");
        assert_eq!(format!("{chained:?}"), "test");

        let msg = ErrorMessage::from(ByteString::from("test"));
        let chained = msg.with_source(io::Error::other("io-test"));
        assert_eq!(chained.as_bstr(), "test");
        assert!(chained.source().is_some());

        let err = ErrorMessageChained::new("test", io::Error::other("io-test"));
        let msg = fmt_err_string(&err);
        assert_eq!(msg, "test\nio-test\n");

        let chained = ErrorMessageChained::from(ByteString::new());
        assert_eq!(format!("{chained}"), "");
        assert!(chained.is_empty());

        let chained = ErrorMessageChained::empty();
        assert!(chained.is_empty());
        assert_eq!(chained.as_str(), "");
        assert!(chained.source().is_none());

        let chained = ErrorMessageChained::from_static("test");
        assert!(!chained.is_empty());
        assert_eq!(chained.as_str(), "test");
        assert!(chained.source().is_none());

        let chained = chained.with_source(io::Error::other("first"));
        let chained = chained.with_source(io::Error::other("second"));
        assert_eq!(chained.source().unwrap().to_string(), "second");
        assert_eq!(chained.into_string(), "test");
    }

    #[derive(thiserror::Error, derive_more::Debug)]
    enum TestError {
        #[error("Disconnect")]
        #[debug("")]
        Disconnect(#[source] io::Error),
        #[error("InternalServiceError")]
        #[debug("InternalServiceError {_0}")]
        Service(&'static str),
    }

    impl Clone for TestError {
        fn clone(&self) -> Self {
            panic!()
        }
    }

    impl ErrorDiagnostic for TestError {
        fn signature(&self) -> &'static str {
            match self {
                TestError::Service(_) => ResultType::ServiceError.as_str(),
                TestError::Disconnect(_) => ResultType::ClientError.as_str(),
            }
        }
    }

    impl From<&TestError> for ResultType {
        fn from(err: &TestError) -> ResultType {
            match err {
                TestError::Service(_) => ResultType::ServiceError,
                TestError::Disconnect(_) => ResultType::ClientError,
            }
        }
    }

    #[test]
    fn fmt_diag() {
        let err = TestError::Service("409 Error");

        let msg = fmt_err_string(&err);
        assert_eq!(msg, "InternalServiceError\n");

        let err = crate::Error::from(TestError::Disconnect(io::Error::other("Test io error")));
        if let Some(bt) = err.backtrace() {
            bt.resolver().resolve();
        }
        let msg = fmt_diag_string(&err);
        assert!(msg.contains("Test io error"), "{msg}");

        assert!(
            format!("{:?}", err.source()).contains("Test io erro"),
            "{:?}",
            err.source().unwrap()
        );

        let err = err.with_tag(Bytes::from("test-tag"));
        let msg = fmt_diag_string(&err);
        assert!(msg.contains("test-tag"), "{msg}");
    }
}