feat: further detect common io errors in megaphone's updater

autoconnect/autoconnect-common/Cargo.toml

@@ -11,6 +11,7 @@ actix-web.workspace = true
 cadence.workspace = true
 futures.workspace = true
 futures-locks.workspace = true
+hyper.workspace = true
 reqwest.workspace = true
 tokio.workspace = true
 sentry.workspace = true

autoconnect/autoconnect-common/src/megaphone.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, sync::Arc, time::Duration};
+use std::{collections::HashMap, error::Error, io, sync::Arc, time::Duration};
 
 use actix_web::rt;
 use cadence::{CountedExt, StatsdClient};
@@ -53,6 +53,8 @@ fn report_updater_error(metrics: &Arc<StatsdClient>, err: reqwest::Error) {
         "timeout"
     } else if err.is_connect() {
         "connect"
+    } else if is_io(&err) {
+        "io"
     } else {
         "unknown"
     };
@@ -91,3 +93,29 @@ async fn updater(
     }
     Ok(())
 }
+
+/// Determine if a source of [reqwest::Error] was a [hyper::Error] Io Error
+fn is_io(err: &reqwest::Error) -> bool {
+    let mut source = err.source();
+    while let Some(err) = source {
+        if let Some(hyper_err) = err.downcast_ref::<hyper::Error>() {
+            if is_hyper_io(hyper_err) {
+                return true;
+            }
+        }
+        source = err.source();
+    }
+    false
+}
+
+/// Determine if a source of [hyper::Error] was an [io::Error]
+fn is_hyper_io(err: &hyper::Error) -> bool {
+    let mut source = err.source();
+    while let Some(err) = source {
+        if err.downcast_ref::<io::Error>().is_some() {
+            return true;
+        }
+        source = err.source();
+    }
+    false
+}

autoconnect/autoconnect-ws/src/error.rs

@@ -73,7 +73,12 @@ impl WSError {
 
 impl ReportableError for WSError {
     fn backtrace(&self) -> Option<&Backtrace> {
-        self.backtrace.as_ref()
+        // XXX: dumb hack: return SMError's backtrace for now as our
+        // sentry::event_from_error doesn't capture it
+        match &self.kind {
+            WSErrorKind::SM(e) => e.backtrace(),
+            _ => self.backtrace.as_ref(),
+        }
     }
 
     fn is_sentry_event(&self) -> bool {