wip

Author: Centril

Cargo.lock

@@ -291,7 +291,7 @@ unicode-normalization = "0.1.23"
 url = "2.3.1"
 urlencoding = "2.1.2"
 uuid = { version = "1.2.1", features = ["v4"] }
-v8 = "137.2"
+v8 = "140.0"
 walkdir = "2.2.5"
 wasmbin = "0.6"
 webbrowser = "1.0.2"

Cargo.toml

@@ -1,5 +1,5 @@
 use super::scheduler::{get_schedule_from_row, ScheduleError, Scheduler};
-use crate::database_logger::{BacktraceProvider, LogLevel, Record};
+use crate::database_logger::{BacktraceFrame, BacktraceProvider, LogLevel, ModuleBacktrace, Record};
 use crate::db::relational_db::{MutTx, RelationalDB};
 use crate::error::{DBError, DatastoreError, IndexError, NodesError};
 use crate::host::wasm_common::TimingSpan;
@@ -197,18 +197,31 @@ impl InstanceEnv {
     }
 
     /// End a console timer by logging the span at INFO level.
-    pub(crate) fn console_timer_end(&self, span: &TimingSpan, bt: &dyn BacktraceProvider) {
+    pub(crate) fn console_timer_end(&self, span: &TimingSpan) {
         let elapsed = span.start.elapsed();
         let message = format!("Timing span {:?}: {:?}", &span.name, elapsed);
 
+        /// A backtrace provider that provides nothing.
+        struct Noop;
+        impl BacktraceProvider for Noop {
+            fn capture(&self) -> Box<dyn ModuleBacktrace> {
+                Box::new(Noop)
+            }
+        }
+        impl ModuleBacktrace for Noop {
+            fn frames(&self) -> Vec<BacktraceFrame<'_>> {
+                Vec::new()
+            }
+        }
+
         let record = Record {
             ts: chrono::Utc::now(),
             target: None,
             filename: None,
             line_number: None,
             message: &message,
         };
-        self.console_log(LogLevel::Info, &record, bt);
+        self.console_log(LogLevel::Info, &record, &Noop);
     }
 
     /// Project `cols` in `row_ref` encoded in BSATN to `buffer`

crates/core/src/host/instance_env.rs

@@ -1,6 +1,10 @@
 //! Utilities for error handling when dealing with V8.
 
+use crate::database_logger::{BacktraceFrame, BacktraceProvider, ModuleBacktrace};
+
+use super::serialize_to_js;
 use core::fmt;
+use spacetimedb_sats::Serialize;
 use v8::{Exception, HandleScope, Local, StackFrame, StackTrace, TryCatch, Value};
 
 /// The result of trying to convert a [`Value`] in scope `'scope` to some type `T`.
@@ -58,6 +62,60 @@ impl<'scope, M: IntoJsString> IntoException<'scope> for RangeError<M> {
     }
 }
 
+/// A catchable termination error thrown in callbacks to indicate a host error.
+#[derive(Serialize)]
+pub(super) struct TerminationError {
+    __terminated__: String,
+}
+
+impl TerminationError {
+    /// Convert `anyhow::Error` to a termination error.
+    pub(super) fn from_error<'scope>(
+        scope: &mut HandleScope<'scope>,
+        error: &anyhow::Error,
+    ) -> ExcResult<ExceptionValue<'scope>> {
+        let __terminated__ = format!("{error}");
+        let error = Self { __terminated__ };
+        serialize_to_js(scope, &error).map(ExceptionValue)
+    }
+}
+
+/// A catchable error code thrown in callbacks
+/// to indicate bad arguments to a syscall.
+#[derive(Serialize)]
+pub(super) struct CodeError {
+    __code_error__: u16,
+}
+
+impl CodeError {
+    /// Create a code error from a code.
+    pub(super) fn from_code<'scope>(
+        scope: &mut HandleScope<'scope>,
+        __code_error__: u16,
+    ) -> ExcResult<ExceptionValue<'scope>> {
+        let error = Self { __code_error__ };
+        serialize_to_js(scope, &error).map(ExceptionValue)
+    }
+}
+
+/// A catchable error code thrown in callbacks
+/// to indicate that a buffer was too small and the minimum size required.
+#[derive(Serialize)]
+pub(super) struct BufferTooSmall {
+    __buffer_too_small__: u32,
+}
+
+impl BufferTooSmall {
+    /// Create a code error from a code.
+    pub(super) fn from_requirement<'scope>(
+        scope: &mut HandleScope<'scope>,
+        __buffer_too_small__: u32,
+    ) -> ExcResult<ExceptionValue<'scope>> {
+        let error = Self { __buffer_too_small__ };
+        serialize_to_js(scope, &error).map(ExceptionValue)
+    }
+}
+
 #[derive(Debug)]
 pub(crate) struct ExceptionThrown {
     _priv: (),
@@ -134,14 +192,14 @@ impl fmt::Display for JsError {
 }
 
 /// A V8 stack trace that is independent of a `'scope`.
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone)]
 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 {
+    pub(super) 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();
@@ -150,6 +208,12 @@ impl JsStackTrace {
             .collect::<Box<[_]>>();
         Self { frames }
     }
+
+    /// Construct a backtrace from `scope`.
+    pub(super) fn from_current_stack_trace(scope: &mut HandleScope<'_>) -> ExcResult<Self> {
+        let trace = StackTrace::current_stack_trace(scope, 1024).ok_or_else(exception_already_thrown)?;
+        Ok(Self::from_trace(scope, trace))
+    }
 }
 
 impl fmt::Display for JsStackTrace {
@@ -162,8 +226,26 @@ impl fmt::Display for JsStackTrace {
     }
 }
 
+impl BacktraceProvider for JsStackTrace {
+    fn capture(&self) -> Box<dyn ModuleBacktrace> {
+        Box::new(self.clone())
+    }
+}
+
+impl ModuleBacktrace for JsStackTrace {
+    fn frames(&self) -> Vec<BacktraceFrame<'_>> {
+        self.frames
+            .iter()
+            .map(|frame| BacktraceFrame {
+                module_name: frame.script_name.as_deref(),
+                func_name: frame.fn_name.as_deref(),
+            })
+            .collect()
+    }
+}
+
 /// A V8 stack trace frame that is independent of a `'scope`.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub(super) struct JsStackTraceFrame {
     line: usize,
     column: usize,
@@ -197,12 +279,22 @@ impl JsStackTraceFrame {
             is_user_js: frame.is_user_javascript(),
         }
     }
+
+    /// Returns the name of the function that was called.
+    fn fn_name(&self) -> &str {
+        self.fn_name.as_deref().unwrap_or("<anonymous>")
+    }
+
+    /// Returns the name of the script where the function resides.
+    fn script_name(&self) -> &str {
+        self.script_name.as_deref().unwrap_or("<unknown location>")
+    }
 }
 
 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>");
+        let fn_name = self.fn_name();
+        let script_name = self.script_name();
 
         // This isn't exactly the same format as chrome uses,
         // but it's close enough for now.
@@ -267,7 +359,8 @@ pub(super) fn catch_exception<'scope, T>(
     body: impl FnOnce(&mut HandleScope<'scope>) -> Result<T, ErrorOrException<ExceptionThrown>>,
 ) -> Result<T, ErrorOrException<JsError>> {
     let scope = &mut TryCatch::new(scope);
-    body(scope).map_err(|e| match e {
+    let ret = body(scope);
+    ret.map_err(|e| match e {
         ErrorOrException::Err(e) => ErrorOrException::Err(e),
         ErrorOrException::Exception(_) => ErrorOrException::Exception(JsError::from_caught(scope)),
     })