fix(backtrace): Support newer backtrace format (#141)

Backtrace parsing for recent versions of `backtrace-rs` fails to obtain inline frames. The regular expression is now tidied up a little bit and supports both the old and new backtrace format in one go, along with inline frames. 

Additionally, crate name parsing was broken for the new Rust mangling schema, which no longer uses underscores in front of trait implementors and uses `::` instead of `..` for crate separators.

Author: jan-auer

src/backtrace_support.rs

@@ -21,21 +21,31 @@ pub static ref WELL_KNOWN_SYS_MODULES: Vec<&'static str> = {
         "sentry_types::",
         // these are not modules but things like __rust_maybe_catch_panic
         "__rust_",
+        "___rust_",
     ];
     #[cfg(feature = "with_failure")] {
         rv.push("failure::");
     }
+    #[cfg(feature = "with_log")] {
+        rv.push("log::");
+    }
+    #[cfg(feature = "with_error_chain")] {
+        rv.push("error_chain::");
+    }
     rv
 };
 
 pub static ref WELL_KNOWN_BORDER_FRAMES: Vec<&'static str> = {
     #[allow(unused_mut)]
     let mut rv = vec![
         "std::panicking::begin_panic",
+        "core::panicking::panic",
     ];
     #[cfg(feature = "with_failure")] {
         rv.push("failure::error_message::err_msg");
         rv.push("failure::backtrace::Backtrace::new");
+        rv.push("failure::backtrace::internal::InternalBacktrace::new");
+        rv.push("failure::Fail::context");
     }
     #[cfg(feature = "with_log")] {
         rv.push("<sentry::integrations::log::Logger as log::Log>::log");

src/client.rs

@@ -213,7 +213,13 @@ impl Default for ClientOptions {
 }
 
 lazy_static::lazy_static! {
-    static ref CRATE_RE: Regex = Regex::new(r"^(?:_<)?([a-zA-Z0-9_]+?)(?:\.\.|::)").unwrap();
+    static ref CRATE_RE: Regex = Regex::new(r#"(?x)
+        ^
+        (?:_?<)?           # trait impl syntax
+        (?:\w+\ as \ )?    # anonymous implementor
+        ([a-zA-Z0-9_]+?)   # crate name
+        (?:\.\.|::)        # crate delimiter (.. or ::)
+    "#).unwrap();
 }
 
 /// Tries to parse the rust crate from a function name.
@@ -680,10 +686,23 @@ mod tests {
     }
 
     #[test]
-    fn test_parse_crate_name_unknown() {
+    fn test_parse_crate_name_anonymous_impl() {
         assert_eq!(
             parse_crate_name("_<F as alloc..boxed..FnBox<A>>::call_box"),
-            None
+            Some("alloc".into())
+        );
+    }
+
+    #[test]
+    fn test_parse_crate_name_none() {
+        assert_eq!(parse_crate_name("main"), None);
+    }
+
+    #[test]
+    fn test_parse_crate_name_newstyle() {
+        assert_eq!(
+            parse_crate_name("<failure::error::Error as core::convert::From<F>>::from"),
+            Some("failure".into())
         );
     }
 }

src/integrations/failure.rs

@@ -40,20 +40,24 @@ lazy_static::lazy_static! {
     static ref FRAME_RE: Regex = Regex::new(
         r#"(?xm)
         ^
-            [\ ]*(?:\d+:)[\ ]*                  # leading frame number
+            \s*(?:\d+:)?\s*                      # frame number (missing for inline)
+
+            (?:
+                (?P<addr_old>0x[a-f0-9]+)        # old style address prefix
+                \s-\s
+            )?
+
+            (?P<symbol>[^\r\n\(]+)               # symbol name
+
             (?:
-                (?P<addr_oldsyntax>0x[a-f0-9]+)               # addr
-                [\ ]-[\ ]
-                (?P<symbol_oldsyntax>[^\r\n]+)
-              |
-                (?P<symbol>[^\r\n]+)
-                \((?P<addr>0x[a-f0-9]+)\)               # addr
-            )
+                \s\((?P<addr_new>0x[a-f0-9]+)\)  # new style address in parens
+            )?
+
             (?:
                 \r?\n
-                [\ \t]+at[\ ]
-                (?P<path>[^\r\n]+?)
-                (?::(?P<lineno>\d+))?
+                \s+at\s                          # padded "at" in new line
+                (?P<path>[^\r\n]+?)              # path to source file
+                (?::(?P<lineno>\d+))?            # optional source line
             )?
         $
     "#
@@ -62,31 +66,33 @@ lazy_static::lazy_static! {
 }
 
 fn parse_stacktrace(bt: &str) -> Option<Stacktrace> {
+    let mut last_address = None;
+
     let frames = FRAME_RE
         .captures_iter(&bt)
         .map(|captures| {
             let abs_path = captures.name("path").map(|m| m.as_str().to_string());
             let filename = abs_path.as_ref().map(|p| filename(p));
-            let real_symbol = captures
-                .name("symbol")
-                .map_or_else(|| &captures["symbol_oldsyntax"], |m| m.as_str())
-                .to_string();
+            let real_symbol = captures["symbol"].to_string();
             let symbol = strip_symbol(&real_symbol);
             let function = demangle_symbol(symbol);
+
+            // Obtain the instruction address. A missing address usually indicates an inlined stack
+            // frame, in which case the previous address needs to be used.
+            last_address = captures
+                .name("addr_new")
+                .or_else(|| captures.name("addr_old"))
+                .and_then(|m| m.as_str().parse().ok())
+                .or(last_address);
+
             Frame {
                 symbol: if symbol != function {
                     Some(symbol.into())
                 } else {
                     None
                 },
                 function: Some(function),
-                instruction_addr: Some(
-                    captures
-                        .name("addr")
-                        .map_or_else(|| &captures["addr_oldsyntax"], |m| m.as_str())
-                        .parse()
-                        .unwrap(),
-                ),
+                instruction_addr: last_address,
                 abs_path,
                 filename,
                 lineno: captures
@@ -231,3 +237,41 @@ where
         }
     }
 }
+
+#[test]
+fn test_parse_stacktrace() {
+    use crate::protocol::Addr;
+
+    let backtrace = r#"
+   2: <failure::error::error_impl::ErrorImpl as core::convert::From<F>>::from::h3bae66c036570137 (0x55a12174de62)
+             at /root/.cargo/registry/src/github.com-1ecc6299db9ec823/failure-0.1.5/src/error/error_impl.rs:19
+      <failure::error::Error as core::convert::From<F>>::from::hc7d0d62dae166cea
+             at /root/.cargo/registry/src/github.com-1ecc6299db9ec823/failure-0.1.5/src/error/mod.rs:36
+      failure::error_message::err_msg::he322d3ed9409189a
+             at /root/.cargo/registry/src/github.com-1ecc6299db9ec823/failure-0.1.5/src/error_message.rs:12
+      rust::inline2::h562e5687710b6a71
+             at src/main.rs:5
+      rust::not_inline::h16f5b6019e5f0815
+             at src/main.rs:10
+   7: main (0x55e3895a4dc7)
+"#;
+
+    let stacktrace = parse_stacktrace(backtrace).expect("stacktrace");
+    assert_eq!(stacktrace.frames.len(), 6);
+
+    assert_eq!(stacktrace.frames[0].function, Some("main".into()));
+    assert_eq!(
+        stacktrace.frames[0].instruction_addr,
+        Some(Addr(0x55e3_895a_4dc7))
+    );
+
+    // Inlined frame, inherits address from parent
+    assert_eq!(
+        stacktrace.frames[1].function,
+        Some("rust::not_inline".into())
+    );
+    assert_eq!(
+        stacktrace.frames[1].instruction_addr,
+        Some(Addr(0x55a1_2174_de62))
+    );
+}