Wrapping anyhow::Error in another error loses backtrace #174

Activity

1. mhnap commented on Aug 28, 2024

   

   mhnap

   on Aug 28, 2024

   More actions

   I found one solution for this problem - add the #[backtrace] attribute to inner anyhow::Error, but it requires a nightly.

   By the way, map() is lazy and your test never will pass as there indeed would be two different backtraces generated during next() call. I fixed it by switching to Vec.

   #[test]
   fn backtrace_preserved_after_thiserror_derive() {
       #[derive(Debug, thiserror::Error)]
       enum SomeError {
           #[error(transparent)]
           Anyhow {
               #[backtrace] // <-- Passing with this attribute
               source: anyhow::Error,
           },
       }
   
       let mut errs: Vec<_> = (0..2).map(|_| anyhow::anyhow!("aaa")).collect();
   
       let wrapped = anyhow::Error::from(SomeError::Anyhow {
           source: errs.pop().unwrap(),
       });
       let notwrapped = errs.pop().unwrap();
   
       assert_eq!(
           wrapped.backtrace().to_string(),
           notwrapped.backtrace().to_string()
       );
   }

   Would be great if this could be solved on stable too.
2. MarijnS95 commented on Dec 11, 2025

   

   MarijnS95

   on Dec 11, 2025

   More actions

   This seems to be similar to #157; because std::error::Error doesn't currently provide a backtrace() API on stable, that can be forwarded from anyhow to thiserror and back to anyhow. There's a mention about the new nightly provide() API in the docs now that should be able to forward it though:

   https://docs.rs/thiserror/latest/thiserror/

   If a field is both a source (named source, or has #[source] or #[from] attribute) and is marked #[backtrace], then the Error trait’s provide() method is forwarded to the source’s provide so that both layers of the error share the same backtrace. The #[backtrace] attribute requires a nightly compiler with Rust version 1.73 or newer.

   So you might need to add both #[from] #[backtrace] to your tuple member (or name it source) as long as you're using a nightly compiler.

   ---

   There are a few more things at play here that could have printed the backtrace though (without calling anyhow::Error::backtrace()). Calling to_string(), i.e. Display on anyhow::Error will only Display-print the top-level error. Anyhow requires either alt-mode Display printing ({err:#}) or non-alt mode Debug printing ({err:?}) to print .source() errors, and I wouldn't be surprised if it uses the same logic to decide whether to print the backtrace() or not.

   That way, calling .unwrap() or returning anyhow::Error out of fn main() which both call Debug on the top-level anyhow::Error, will walk the chain of .source() errors and call Display on those (which will prevent them from also printing their own .source() stack again if they were also anyhow::Error).