v8: add call_call_reducer with stack traces

Author: Centril

crates/core/src/host/v8/error.rs

@@ -1,6 +1,7 @@
 //! Utilities for error handling when dealing with V8.
 
-use v8::{Exception, HandleScope, Local, TryCatch, Value};
+use core::fmt;
+use v8::{Exception, HandleScope, Local, StackFrame, StackTrace, TryCatch, Value};
 
 /// The result of trying to convert a [`Value`] in scope `'scope` to some type `T`.
 pub(super) type ValueResult<'scope, T> = Result<T, ExceptionValue<'scope>>;
@@ -117,19 +118,134 @@ impl From<ErrorOrException<JsError>> for anyhow::Error {
 
 /// A JS exception turned into an error.
 #[derive(thiserror::Error, Debug)]
-#[error("js error: {msg:?}")]
 pub(super) struct JsError {
     msg: String,
+    trace: JsStackTrace,
+}
+
+impl fmt::Display for JsError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "js error {}", self.msg)?;
+        writeln!(f, "{}", self.trace)?;
+        Ok(())
+    }
+}
+
+/// A V8 stack trace that is independent of a `'scope`.
+#[derive(Debug, Default)]
+pub(super) struct JsStackTrace {
+    frames: Box<[JsStackTraceFrame]>,
+}
+
+impl JsStackTrace {
+    /// Converts a V8 [`StackTrace`] into one independent of `'scope`.
+    fn from_trace<'scope>(scope: &mut HandleScope<'scope>, trace: Local<'scope, StackTrace>) -> Self {
+        let frames = (0..trace.get_frame_count())
+            .map(|index| {
+                let frame = trace.get_frame(scope, index).unwrap();
+                JsStackTraceFrame::from_frame(scope, frame)
+            })
+            .collect::<Box<[_]>>();
+        Self { frames }
+    }
+}
+
+impl fmt::Display for JsStackTrace {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for frame in self.frames.iter() {
+            writeln!(f, "\t{frame}")?;
+        }
+
+        Ok(())
+    }
+}
+
+/// A V8 stack trace frame that is independent of a `'scope`.
+#[derive(Debug)]
+pub(super) struct JsStackTraceFrame {
+    line: usize,
+    column: usize,
+    script_id: usize,
+    script_name: Option<String>,
+    fn_name: Option<String>,
+    is_eval: bool,
+    is_ctor: bool,
+    is_wasm: bool,
+    is_user_js: bool,
+}
+
+impl JsStackTraceFrame {
+    /// Converts a V8 [`StackFrame`] into one independent of `'scope`.
+    fn from_frame<'scope>(scope: &mut HandleScope<'scope>, frame: Local<'scope, StackFrame>) -> Self {
+        let script_name = frame
+            .get_script_name_or_source_url(scope)
+            .map(|s| s.to_rust_string_lossy(scope));
+
+        let fn_name = frame.get_function_name(scope).map(|s| s.to_rust_string_lossy(scope));
+
+        Self {
+            line: frame.get_line_number(),
+            column: frame.get_column(),
+            script_id: frame.get_script_id(),
+            script_name,
+            fn_name,
+            is_eval: frame.is_eval(),
+            is_ctor: frame.is_constructor(),
+            is_wasm: frame.is_wasm(),
+            is_user_js: frame.is_user_javascript(),
+        }
+    }
+}
+
+impl fmt::Display for JsStackTraceFrame {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let fn_name = self.fn_name.as_deref().unwrap_or("<anonymous>");
+        let script_name = self.script_name.as_deref().unwrap_or("<unknown location>");
+
+        // This isn't exactly the same format as chrome uses,
+        // but it's close enough for now.
+        // TODO(centril): make it more like chrome in the future.
+        f.write_fmt(format_args!(
+            "at {} ({}:{}:{})",
+            fn_name, script_name, &self.line, &self.column
+        ))?;
+
+        if self.is_ctor {
+            f.write_str(" (constructor)")?;
+        }
+
+        if self.is_eval {
+            f.write_str(" (eval)")?;
+        }
+
+        if self.is_wasm {
+            f.write_str(" (wasm)")?;
+        }
+
+        if !self.is_user_js {
+            f.write_str(" (native)")?;
+        }
+
+        Ok(())
+    }
 }
 
 impl JsError {
     /// Turns a caught JS exception in `scope` into a [`JSError`].
     fn from_caught(scope: &mut TryCatch<'_, HandleScope<'_>>) -> Self {
-        let msg = match scope.message() {
-            Some(msg) => msg.get(scope).to_rust_string_lossy(scope),
-            None => "unknown error".to_owned(),
-        };
-        Self { msg }
+        match scope.message() {
+            Some(message) => Self {
+                trace: message
+                    .get_stack_trace(scope)
+                    .map(|trace| JsStackTrace::from_trace(scope, trace))
+                    .unwrap_or_default(),
+                msg: message.get(scope).to_rust_string_lossy(scope),
+            },
+            None => Self {
+                trace: JsStackTrace::default(),
+                msg: "unknown error".to_owned(),
+            },
+        }
     }
 }
 

crates/core/src/host/v8/key_cache.rs

@@ -24,6 +24,8 @@ pub(super) struct KeyCache {
     value: Option<Global<v8::String>>,
     /// The `__describe_module__` property on the global proxy object.
     describe_module: Option<Global<v8::String>>,
+    /// The `__call_reducer__` property on the global proxy object.
+    call_reducer: Option<Global<v8::String>>,
 }
 
 impl KeyCache {
@@ -42,6 +44,11 @@ impl KeyCache {
         Self::get_or_create_key(scope, &mut self.describe_module, "__describe_module__")
     }
 
+    /// Returns the `__call_reducer__` property name.
+    pub(super) fn call_reducer<'scope>(&mut self, scope: &mut HandleScope<'scope>) -> Local<'scope, v8::String> {
+        Self::get_or_create_key(scope, &mut self.call_reducer, "__call_reducer__")
+    }
+
     /// Returns an interned string corresponding to `string`
     /// and memoizes the creation on the v8 side.
     fn get_or_create_key<'scope>(

crates/core/src/host/v8/mod.rs

@@ -3,8 +3,10 @@
 use super::module_common::{build_common_module_from_raw, ModuleCommon};
 use super::module_host::{CallReducerParams, DynModule, Module, ModuleInfo, ModuleInstance, ModuleRuntime};
 use super::UpdateDatabaseResult;
-use crate::host::v8::error::{exception_already_thrown, Throwable};
+use crate::host::v8::error::{exception_already_thrown, ExceptionThrown, Throwable};
+use crate::host::v8::ser::serialize_to_js;
 use crate::host::wasm_common::module_host_actor::InstanceCommon;
+use crate::host::ArgsTuple;
 use crate::{host::Scheduler, module_host_context::ModuleCreationContext, replica_context::ReplicaContext};
 use anyhow::anyhow;
 use de::deserialize_js;
@@ -13,9 +15,9 @@ use from_value::cast;
 use key_cache::get_or_create_key_cache;
 use spacetimedb_datastore::locking_tx_datastore::MutTxId;
 use spacetimedb_datastore::traits::Program;
-use spacetimedb_lib::RawModuleDef;
+use spacetimedb_lib::{ConnectionId, Identity, RawModuleDef};
 use std::sync::{Arc, LazyLock};
-use v8::{Function, HandleScope};
+use v8::{Function, HandleScope, Local, Value};
 
 mod de;
 mod error;
@@ -141,21 +143,66 @@ impl ModuleInstance for JsInstance {
     }
 }
 
+/// Returns the global property `key`.
+fn get_global_property<'scope>(
+    scope: &mut HandleScope<'scope>,
+    key: Local<'scope, v8::String>,
+) -> Result<Local<'scope, Value>, ExceptionThrown> {
+    scope
+        .get_current_context()
+        .global(scope)
+        .get(scope, key.into())
+        .ok_or_else(exception_already_thrown)
+}
+
+// Calls the `__call_reducer__` function on the global proxy object.
+fn call_call_reducer(
+    scope: &mut HandleScope<'_>,
+    reducer_id: u32,
+    sender: &Identity,
+    conn_id: &ConnectionId,
+    timestamp: u64,
+    reducer_args: &ArgsTuple,
+) -> anyhow::Result<Result<(), Box<str>>> {
+    // Get a cached version of the `__call_reducer__` property.
+    let key_cache = get_or_create_key_cache(scope);
+    let call_reducer_key = key_cache.borrow_mut().call_reducer(scope);
+
+    catch_exception(scope, |scope| {
+        // Serialize the arguments.
+        let reducer_id = serialize_to_js(scope, &reducer_id)?;
+        let sender = serialize_to_js(scope, &sender.to_u256())?;
+        let conn_id: v8::Local<'_, v8::Value> = serialize_to_js(scope, &conn_id.to_u128())?;
+        let timestamp = serialize_to_js(scope, &timestamp)?;
+        let reducer_args = serialize_to_js(scope, &reducer_args.tuple.elements)?;
+        let args = &[reducer_id, sender, conn_id, timestamp, reducer_args];
+
+        // Get the function on the global proxy object and convert to a function.
+        let object = get_global_property(scope, call_reducer_key)?;
+        let fun =
+            cast!(scope, object, Function, "function export for `__call_reducer__`").map_err(|e| e.throw(scope))?;
+
+        // Call the function.
+        let receiver = v8::undefined(scope).into();
+        let ret = fun.call(scope, receiver, args).ok_or_else(exception_already_thrown)?;
+
+        // Deserialize the user result.
+        let user_res = deserialize_js(scope, ret)?;
+
+        Ok(user_res)
+    })
+    .map_err(Into::into)
+}
+
 // Calls the `__describe_module__` function on the global proxy object to extract a [`RawModuleDef`].
 fn call_describe_module(scope: &mut HandleScope<'_>) -> anyhow::Result<RawModuleDef> {
     // Get a cached version of the `__describe_module__` property.
     let key_cache = get_or_create_key_cache(scope);
-    let describe_module_key = key_cache.borrow_mut().describe_module(scope).into();
+    let describe_module_key = key_cache.borrow_mut().describe_module(scope);
 
     catch_exception(scope, |scope| {
-        // Get the function on the global proxy object.
-        let object = scope
-            .get_current_context()
-            .global(scope)
-            .get(scope, describe_module_key)
-            .ok_or_else(exception_already_thrown)?;
-
-        // Convert to a function.
+        // Get the function on the global proxy object and convert to a function.
+        let object = get_global_property(scope, describe_module_key)?;
         let fun =
             cast!(scope, object, Function, "function export for `__describe_module__`").map_err(|e| e.throw(scope))?;
 
@@ -187,6 +234,63 @@ mod test {
         })
     }
 
+    #[test]
+    fn call_call_reducer_works() {
+        let call = |code| {
+            with_script(code, |scope, _| {
+                call_call_reducer(
+                    scope,
+                    42,
+                    &Identity::ONE,
+                    &ConnectionId::ZERO,
+                    24,
+                    &ArgsTuple::nullary(),
+                )
+            })
+        };
+
+        // Test the trap case.
+        let ret = call(
+            r#"
+            function __call_reducer__(reducer_id, sender, conn_id, timestamp, args) {
+                throw new Error("foobar");
+            }
+        "#,
+        );
+        let actual = format!("{}", ret.expect_err("should trap")).replace("\t", "    ");
+        let expected = r#"
+js error Uncaught Error: foobar
+    at __call_reducer__ (<unknown location>:3:23)
+        "#;
+        assert_eq!(actual.trim(), expected.trim());
+
+        // Test the error case.
+        let ret = call(
+            r#"
+            function __call_reducer__(reducer_id, sender, conn_id, timestamp, args) {
+                return {
+                    "tag": "err",
+                    "value": "foobar",
+                };
+            }
+        "#,
+        );
+        assert_eq!(&*ret.expect("should not trap").expect_err("should error"), "foobar");
+
+        // Test the error case.
+        let ret = call(
+            r#"
+            function __call_reducer__(reducer_id, sender, conn_id, timestamp, args) {
+                return {
+                    "tag": "ok",
+                    "value": {},
+                };
+            }
+        "#,
+        );
+        ret.expect("should not trap").expect("should not error");
+    }
+
     #[test]
     fn call_describe_module_works() {
         let code = r#"

crates/core/src/host/v8/to_value.rs

@@ -116,6 +116,7 @@ pub(in super::super) mod test {
     pub(in super::super) fn with_scope<R>(logic: impl FnOnce(&mut HandleScope<'_>) -> R) -> R {
         V8Runtime::init_for_test();
         let isolate = &mut Isolate::new(<_>::default());
+        isolate.set_capture_stack_trace_for_uncaught_exceptions(true, 1024);
         let scope = &mut HandleScope::new(isolate);
         let context = Context::new(scope, Default::default());
         let scope = &mut ContextScope::new(scope, context);