Resolves rust-lang#1151 - send errors, error-logs and panics to sentry

Author: syphar

Cargo.lock

@@ -19,6 +19,10 @@ exclude = [
 consistency_check = ["crates-index"]
 
 [dependencies]
+sentry = "0.23.0"
+sentry-log = "0.23.0"
+sentry-panic = "0.23.0"
+sentry-anyhow = { version = "0.23.0", features = ["backtrace"] }
 log = "0.4"
 regex = "1"
 structopt = "0.3"

Cargo.toml

@@ -11,12 +11,29 @@ use docs_rs::{
     BuildQueue, Config, Context, Index, Metrics, PackageKind, RustwideBuilder, Server, Storage,
 };
 use once_cell::sync::OnceCell;
+use sentry_anyhow::capture_anyhow;
+use sentry_log::SentryLogger;
 use structopt::StructOpt;
 use strum::VariantNames;
 
 pub fn main() {
     let _ = dotenv::dotenv();
-    logger_init();
+
+    let _sentry_guard = if let Ok(sentry_dsn) = env::var("SENTRY_DSN") {
+        rustwide::logging::init_with(SentryLogger::with_dest(logger_init()));
+        Some(sentry::init((
+            sentry_dsn,
+            sentry::ClientOptions {
+                release: Some(docs_rs::BUILD_VERSION.into()),
+                attach_stacktrace: true,
+                ..Default::default()
+            }
+            .add_integration(sentry_panic::PanicIntegration::default()),
+        )))
+    } else {
+        rustwide::logging::init_with(logger_init());
+        None
+    };
 
     if let Err(err) = CommandLine::from_args().handle_args() {
         let mut msg = format!("Error: {}", err);
@@ -29,15 +46,23 @@ pub fn main() {
         if !backtrace.is_empty() {
             eprintln!("\nStack backtrace:\n{}", backtrace);
         }
+
+        capture_anyhow(&err);
+
+        eprintln!("{}", msg);
+
+        // we need to drop the sentry guard here so all unsent
+        // errors are sent to sentry
+        drop(_sentry_guard);
         std::process::exit(1);
     }
 }
 
-fn logger_init() {
+fn logger_init() -> env_logger::Logger {
     use std::io::Write;
 
     let env = env_logger::Env::default().filter_or("DOCSRS_LOG", "docs_rs=info");
-    let logger = env_logger::from_env(env)
+    env_logger::from_env(env)
         .format(|buf, record| {
             writeln!(
                 buf,
@@ -48,9 +73,7 @@ fn logger_init() {
                 record.args()
             )
         })
-        .build();
-
-    rustwide::logging::init_with(logger);
+        .build()
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, strum::EnumString, strum::EnumVariantNames)]

src/bin/cratesfyi.rs

@@ -129,11 +129,8 @@ impl BuildQueue {
                 }
 
                 error!(
-                    "Failed to build package {}-{} from queue: {}\nBacktrace: {}",
-                    to_process.name,
-                    to_process.version,
-                    e,
-                    e.backtrace()
+                    "Failed to build package {}-{} from queue: {}",
+                    to_process.name, to_process.version, e,
                 );
             }
         }

src/build_queue.rs

@@ -15,11 +15,11 @@ macro_rules! ctry {
             Err(error) => {
                 let request: &::iron::Request = $req;
 
+                // TODO this should be `capture_anyhow` if error is `anyhow::Error`
                 ::log::error!(
-                    "called ctry!() on an `Err` value: {:?}\nnote: while attempting to fetch the route {:?}\n{:?}",
+                    "called ctry!() on an `Err` value: {:?}\nnote: while attempting to fetch the route {:?}",
                     error,
                     request.url,
-                    ::backtrace::Backtrace::new(),
                 );
 
                 // This is very ugly, but it makes it impossible to get a type inference error
@@ -48,9 +48,8 @@ macro_rules! cexpect {
                 let request: &::iron::Request = $req;
 
                 ::log::error!(
-                    "called cexpect!() on a `None` value while attempting to fetch the route {:?}\n{:?}",
+                    "called cexpect!() on a `None` value while attempting to fetch the route {:?}",
                     request.url,
-                    ::backtrace::Backtrace::new(),
                 );
 
                 // This is very ugly, but it makes it impossible to get a type inference error