fix: extract panic-utils crate and fix occasional incorrect downcasting

Extract `panic-utils` crate and consistently use it for downcasting
panic payloads to strings across the codebase.

The implementation is a bit more efficient than what was used previously
and avoids unnecessary allocations, and also fixes a few bugs related to
only one of the two possible cases handled when downcasting panic
payloads. The most egregious was the case in `sql-query-connector` where
we tried downcasting a panic from the database driver to `String` and
then unwrapped the result, leading to possible double panics if the
original panic was of the form `panic!("message")` and not
`panic!("message: {details}")` and thus the panic payload was a `&static
str` and not a `String`.

libs/driver-adapters/Cargo.toml

@@ -20,6 +20,7 @@ workspace = true
 async-trait.workspace = true
 futures.workspace = true
 once_cell = "1.15"
+panic-utils.path = "../../libs/panic-utils"
 prisma-metrics.path = "../../libs/metrics"
 serde.workspace = true
 serde_json.workspace = true

libs/driver-adapters/src/napi/error.rs

@@ -25,10 +25,7 @@ where
 }
 
 fn panic_to_napi_err<R>(panic_payload: Box<dyn Any + Send>) -> napi::Result<R> {
-    panic_payload
-        .downcast_ref::<&str>()
-        .map(|s| -> String { (*s).to_owned() })
-        .or_else(|| panic_payload.downcast_ref::<String>().map(|s| s.to_owned()))
+    panic_utils::downcast_box_to_string(panic_payload)
         .map(|message| Err(napi::Error::from_reason(format!("PANIC: {message}"))))
         .ok_or(napi::Error::from_reason("PANIC: unknown panic".to_string()))
         .unwrap()

libs/panic-utils/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "panic-utils"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+
+[lints]
+workspace = true

libs/panic-utils/src/lib.rs

@@ -0,0 +1,18 @@
+use std::{any::Any, borrow::Cow};
+
+/// Downcasts a boxed [`Any`] from a panic payload to a string.
+pub fn downcast_box_to_string(object: Box<dyn Any>) -> Option<Cow<'static, str>> {
+    object
+        .downcast::<&'static str>()
+        .map(|s| Cow::Borrowed(*s))
+        .or_else(|object| object.downcast::<String>().map(|s| Cow::Owned(*s)))
+        .ok()
+}
+
+/// Downcasts a reference to [`Any`] from panic info hook to a string.
+pub fn downcast_ref_to_string(object: &dyn Any) -> Option<&str> {
+    object
+        .downcast_ref::<&str>()
+        .copied()
+        .or_else(|| object.downcast_ref::<String>().map(|s| s.as_str()))
+}

libs/user-facing-errors/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+panic-utils.path = "../panic-utils"
 user-facing-error-macros = { path = "../user-facing-error-macros" }
 serde_json.workspace = true
 serde.workspace = true

libs/user-facing-errors/src/lib.rs

@@ -122,12 +122,7 @@ impl Error {
     /// Construct a new UnknownError from a [`PanicHookInfo`] in a panic hook. [`UnknownError`]s
     /// created with this constructor will have a proper, useful backtrace.
     pub fn new_in_panic_hook(panic_info: &std::panic::PanicHookInfo<'_>) -> Self {
-        let message = panic_info
-            .payload()
-            .downcast_ref::<&str>()
-            .map(|s| -> String { (*s).to_owned() })
-            .or_else(|| panic_info.payload().downcast_ref::<String>().map(|s| s.to_owned()))
-            .unwrap_or_else(|| "<unknown panic>".to_owned());
+        let message = panic_utils::downcast_ref_to_string(panic_info.payload()).unwrap_or("<unknown panic>");
 
         let backtrace = Some(format!("{:?}", backtrace::Backtrace::new()));
         let location = panic_info

query-engine/connectors/sql-query-connector/Cargo.toml

@@ -85,3 +85,6 @@ version = "1.0"
 [dependencies.user-facing-errors]
 features = ["sql"]
 path = "../../../libs/user-facing-errors"
+
+[dependencies.panic-utils]
+path = "../../../libs/panic-utils"

query-engine/connectors/sql-query-connector/src/error.rs

@@ -1,7 +1,7 @@
 use connector_interface::error::*;
 use quaint::error::ErrorKind as QuaintKind;
 use query_structure::{prelude::DomainError, Filter};
-use std::{any::Any, string::FromUtf8Error};
+use std::{any::Any, borrow::Cow, string::FromUtf8Error};
 use thiserror::Error;
 use user_facing_errors::query_engine::DatabaseConstraint;
 
@@ -100,7 +100,7 @@ impl From<Box<dyn Any + Send>> for RawError {
     fn from(e: Box<dyn Any + Send>) -> Self {
         Self::Database {
             code: None,
-            message: Some(*e.downcast::<String>().unwrap()),
+            message: panic_utils::downcast_box_to_string(e).map(Cow::into_owned),
         }
     }
 }

query-engine/query-engine/Cargo.toml

@@ -30,6 +30,7 @@ hyper = { version = "0.14", features = ["server", "http1", "http2", "runtime"] }
 tracing.workspace = true
 tracing-subscriber = { version = "0.3", features = ["json", "env-filter"] }
 prisma-metrics.path = "../../libs/metrics"
+panic-utils.path = "../../libs/panic-utils"
 
 user-facing-errors = { path = "../../libs/user-facing-errors" }
 telemetry = { path = "../../libs/telemetry" }

query-engine/query-engine/src/main.rs

@@ -38,25 +38,21 @@ async fn main() -> Result<(), AnyError> {
 fn set_panic_hook(log_format: LogFormat) {
     if let LogFormat::Json = log_format {
         std::panic::set_hook(Box::new(|info| {
-            let payload = info
-                .payload()
-                .downcast_ref::<String>()
-                .cloned()
-                .unwrap_or_else(|| info.payload().downcast_ref::<&str>().unwrap().to_string());
+            let payload = panic_utils::downcast_ref_to_string(info.payload()).unwrap_or_default();
 
             match info.location() {
                 Some(location) => {
                     tracing::event!(
                         tracing::Level::ERROR,
                         message = "PANIC",
-                        reason = payload.as_str(),
+                        reason = payload,
                         file = location.file(),
                         line = location.line(),
                         column = location.column(),
                     );
                 }
                 None => {
-                    tracing::event!(tracing::Level::ERROR, message = "PANIC", reason = payload.as_str());
+                    tracing::event!(tracing::Level::ERROR, message = "PANIC", reason = payload);
                 }
             }
 

schema-engine/cli/Cargo.toml

@@ -11,6 +11,7 @@ schema-core = { path = "../core" }
 user-facing-errors = { path = "../../libs/user-facing-errors", features = [
     "all-native",
 ] }
+panic-utils = { path = "../../libs/panic-utils" }
 
 backtrace = "0.3.59"
 base64 = "0.13"

schema-engine/cli/src/main.rs

@@ -46,12 +46,7 @@ async fn main() {
 
 fn set_panic_hook() {
     std::panic::set_hook(Box::new(move |panic_info| {
-        let message = panic_info
-            .payload()
-            .downcast_ref::<&str>()
-            .copied()
-            .or_else(|| panic_info.payload().downcast_ref::<String>().map(|s| s.as_str()))
-            .unwrap_or("<unknown panic>");
+        let message = panic_utils::downcast_ref_to_string(panic_info.payload()).unwrap_or("<unknown panic>");
 
         let location = panic_info
             .location()

schema-engine/cli/tests/cli_tests.rs

@@ -45,13 +45,10 @@ where
     match res {
         Ok(_) => (),
         Err(panic_payload) => {
-            let res = panic_payload
-                .downcast_ref::<&str>()
-                .map(|s| -> String { (*s).to_owned() })
-                .or_else(|| panic_payload.downcast_ref::<String>().map(|s| s.to_owned()))
-                .unwrap_or_default();
-
-            panic!("Error: '{}'", res);
+            panic!(
+                "Error: '{}'",
+                panic_utils::downcast_box_to_string(panic_payload).unwrap_or_default()
+            );
         }
     }
 }