Struct Trace

pub struct Trace {
    pub message: String,
    pub source: Option<Box<Self>>,
}

A helper type that can be used to “freeze” a trace and then pass it on to a further error.

This is useful in case you’re dealing with errors where you don’t want to propagate the type (e.g., due to lifetimes) but do want to propagate the trace.

Example

use std::error::Error;
use std::fmt::{Display, Formatter, Result as FResult};

use error_trace::{ErrorTrace as _, Trace};

#[derive(Debug)]
struct SomeError {
    msg: String,
}
impl Display for SomeError {
    fn fmt(&self, f: &mut Formatter<'_>) -> FResult { write!(f, "{}", self.msg) }
}
impl Error for SomeError {}

#[derive(Debug)]
struct HigherError {
    msg:   String,
    child: SomeError,
}
impl Display for HigherError {
    fn fmt(&self, f: &mut Formatter<'_>) -> FResult { write!(f, "{}", self.msg) }
}
impl Error for HigherError {
    fn source(&self) -> Option<&(dyn 'static + Error)> { Some(&self.child) }
}



let err = HigherError {
    msg:   "Oh no, something went wrong!".into(),
    child: SomeError { msg: "A specific reason".into() },
};
assert_eq!(
    Trace::new(err).trace().to_string(),
    r#"Oh no, something went wrong!

Caused by:
 o A specific reason

"#
);

Fields

message: String

The error on this level.

source: Option<Box<Self>>

The error on the next level, if any.

Implementations

impl Trace

pub fn new(err: impl Error) -> Self

Builds a new Trace from the given Error.

Arguments

• err: The error to walk and to freeze the errors of by serializing the messages.

Returns

A new Trace that itself implements Error again.

Example

See Trace itself for an example of how to use it, or see ErrorTrace::freeze().

pub fn from_msg(msg: impl Into<String>) -> Self

Builds a new Trace from a single String.

Arguments

• msg: The (already serialized) message to wrap this trace around.

Returns

A new Trace that wraps the msg implementing Error.

Example

use std::error::Error as _;

use error_trace::{ErrorTrace as _, Trace};

let trace = Trace::from_msg("Hello there!");
assert_eq!(trace.trace().to_string(), "Hello there!");

pub fn from_source(msg: impl Into<String>, err: impl Error) -> Self

Builds a new Trace from a message and a source Error.

Arguments

• msg: Some toplevel to show as root cause.
• err: The first error of the trace that causes msg.

Returns

A new Trace that wraps the msg as error, with err as trace, and that implements Error.

pub fn as_error(&self) -> &(dyn Error + 'static)

Returns this Trace as an Error trait object.

Returns

A &'static dyn Error which is even static!

Trait Implementations

impl Clone for Trace

fn clone(&self) -> Trace

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Trace

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

Formats the value using the given formatter.

impl Display for Trace

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

Formats the value using the given formatter.

impl Error for Trace

fn source(&self) -> Option<&(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)

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