Struct TracedError

pub struct TracedError<E> { /* private fields */ }

A wrapper type for Errors that bundles a SpanTrace with an inner Error type.

This type is a good match for the error-kind pattern where you have an error type with an inner enum of error variants and you would like to capture a span trace that can be extracted during printing without formatting the span trace as part of your display impl.

An example of implementing an error type for a library using TracedError might look like this

#[derive(Debug, thiserror::Error)]
enum Kind {
    // ...
}

#[derive(Debug)]
pub struct Error {
    source: TracedError<Kind>,
    backtrace: Backtrace,
}

impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        self.source.source()
    }

    fn backtrace(&self) -> Option<&Backtrace> {
        Some(&self.backtrace)
    }
}

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

impl<E> From<E> for Error
where
    Kind: From<E>,
{
    fn from(source: E) -> Self {
        Self {
            source: Kind::from(source).into(),
            backtrace: Backtrace::capture(),
        }
    }
}

Implementations

impl<E> TracedError<E>

where E: Error + Send + Sync + 'static,

pub fn new(error: E, span_trace: SpanTrace) -> Self

Construct a TracedError given both the SpanTrace and the inner Error

pub fn map<F, O>(self, op: O) -> TracedError<F>

where O: FnOnce(E) -> F, F: Error + Send + Sync + 'static,

Convert the inner error type of a TracedError while preserving the attached SpanTrace.

Examples

use tracing_error::TracedError;

let err: TracedError<InnerError> = InnerError.into();
let err: TracedError<OuterError> = err.map(|inner| OuterError(inner));

pub fn err_into<F>(self) -> TracedError<F>

where E: Into<F>, F: Error + Send + Sync + 'static,

Convert the inner error type of a TracedError using the inner error’s Into implementation, while preserving the attached SpanTrace.

Examples

use tracing_error::TracedError;

impl From<InnerError> for OuterError {
    fn from(inner: InnerError) -> Self {
        Self(inner)
    }
}

let err: TracedError<InnerError> = InnerError.into();
let err: TracedError<OuterError> = err.err_into();

Trait Implementations

impl<E> Debug for TracedError<E>

where E: Error,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E> Display for TracedError<E>

where E: Error,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E> Error for TracedError<E>

where E: Error + 'static,

fn source<'a>(&'a self) -> Option<&'a (dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access #99301)

Provides type-based access to context intended for error reports.

impl<E> From<E> for TracedError<E>

where E: Error + Send + Sync + 'static,

fn from(error: E) -> Self

Converts to this type from the input type.