pub enum Error {
UsualCase {
backtrace: Backtrace,
},
UsedInTightLoop {
backtrace: Option<Backtrace>,
},
SnafuErrorAsSource {
source: ConfigFileError,
},
SourceErrorDoesNotHaveBacktrace {
source: Error,
backtrace: Backtrace,
},
}Expand description
Backtraces aren’t yet supported by the stable Rust compiler. SNAFU provides a stable-compatible way of getting backtraces as well as support for the backtrace support in the nightly compiler. By default, backtraces are disabled. It is expected that the final executable adds SNAFU as a dependency and chooses the appropriate feature flag to enable backtraces.
When using SNAFU to define error types, it’s recommended to start
with a Backtrace field on every leaf error variant (those
without a source). Backtraces are only captured on
failure. Since backtraces are disabled by default, adding them in
a library does not force any users to pay the price of backtraces
if they are not used; they can be zero cost.
Certain errors are used for flow control. Those don’t need a
backtrace as they don’t represent actual failures. However,
sometimes an error is mostly used for flow control but might
also indicate an error. In those cases, you can use
Option<Backtrace> to avoid capturing a backtrace unless an
environment variable is set by the end user to provide additional
debugging.
For variants that do have a source, you need to evaluate if the source error provides a backtrace of some kind. If it is another SNAFU error, for example, you can delegate retrieval of the backtrace to the source error. If the source error doesn’t provide its own backtrace, you should capture your own backtrace. This backtrace would not be as useful as one captured by the source error, but it’s as useful as you can get.
When you wish to display the backtrace of an error, you can use
the ErrorCompat::backtrace method. It’s recommended to always
use this in the fully-qualified form so it will be easy to find
and replace when Rust stabilizes backtraces.
use snafu::ErrorCompat;
fn inner_process() -> Result<(), Error> {
// Complicated logic
}
fn main() {
if let Err(e) = inner_process() {
eprintln!("An error occurred: {}", e);
if let Some(bt) = ErrorCompat::backtrace(&e) {
eprintln!("{:?}", bt);
}
}
}Variants
UsualCase
Fields
backtrace: BacktraceThe most common leaf error should always include a backtrace field.
UsedInTightLoop
When an error is expected to be created frequently but the
backtrace is rarely needed, you can wrap it in an
Option. See the instructions on how to access the
backtrace in this case.
SnafuErrorAsSource
Fields
source: ConfigFileErrorThis error wraps another error that already has a backtrace. Instead of capturing our own, we forward the request for the backtrace to the inner error. This gives a more accurate backtrace.
SourceErrorDoesNotHaveBacktrace
This error wraps another error that does not expose a backtrace. We capture our own backtrace to provide something useful.
Trait Implementations
sourceimpl Error for Errorwhere
Self: Debug + Display,
impl Error for Errorwhere
Self: Debug + Display,
sourcefn description(&self) -> &str
fn description(&self) -> &str
use the Display impl or to_string()
sourcefn cause(&self) -> Option<&dyn Error>
fn cause(&self) -> Option<&dyn Error>
replaced by Error::source, which can support downcasting
sourceimpl ErrorCompat for Error
impl ErrorCompat for Error
sourcefn iter_chain(&self) -> ChainCompat<'_>ⓘNotable traits for ChainCompat<'a>impl<'a> Iterator for ChainCompat<'a> type Item = &'a dyn Error;where
Self: AsErrorSource,
fn iter_chain(&self) -> ChainCompat<'_>ⓘNotable traits for ChainCompat<'a>impl<'a> Iterator for ChainCompat<'a> type Item = &'a dyn Error;where
Self: AsErrorSource,
Error::source. Read more