Struct tracing_error::TracedError

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

This is supported on feature="traced-error" only.

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)]
pub struct Error {
    source: TracedError<Kind>,
    backtrace: 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(),
        }
    }
}

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)>

The lower-level source of this error, if any.

fn backtrace(&self) -> Option<&Backtrace>

🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred.

fn description(&self) -> &str

Deprecated since 1.41.0:

use the Display impl or to_string()

if let Err(e) = "xc".parse::<u32>() { // Print e itself, no need for description(). eprintln!("Error: {}", e); }

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

Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

impl<E> From<E> for TracedError<E> where
    E: Error + Send + Sync + 'static, 

fn from(error: E) -> Self

Performs the conversion.