Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(workers): prevent recursive local error reporting

ldm0f8edead3f6fa
diff --git a/moli-renderer-v8/src/worker/global_scope/mod.rs b/moli-renderer-v8/src/worker/global_scope/mod.rs
index a41c03b33..b1a1b62de 100644
--- a/moli-renderer-v8/src/worker/global_scope/mod.rs
+++ b/moli-renderer-v8/src/worker/global_scope/mod.rs
@@ -1510,6 +1510,8 @@ pub(crate) struct WorkerGlobalState {
pub(crate) termination_requested: Arc<AtomicBool>,
/// Whether `close()` has been called.
pub(super) closed: bool,
+ /// HTML's per-global guard against recursively reporting an error event.
+ pub(super) in_error_reporting_mode: bool,
/// Timer id counter.
pub(super) next_timer_id: u32,
/// Inside-settings resource authority for every request owned by this
diff --git a/moli-renderer-v8/src/worker/thread/dispatch.rs b/moli-renderer-v8/src/worker/thread/dispatch.rs
index 6770aab1e..bae55df84 100644
--- a/moli-renderer-v8/src/worker/thread/dispatch.rs
+++ b/moli-renderer-v8/src/worker/thread/dispatch.rs
@@ -1021,6 +1021,14 @@ fn invoke_worker_listener<'s>(
}
}
+struct WorkerErrorReportingScope(Rc<RefCell<super::WorkerGlobalState>>);
+
+impl Drop for WorkerErrorReportingScope {
+ fn drop(&mut self) {
+ self.0.borrow_mut().in_error_reporting_mode = false;
+ }
+}
+
pub(super) fn dispatch_worker_error_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
@@ -1029,6 +1037,17 @@ pub(super) fn dispatch_worker_error_event<'s>(
parent_tx: &mpsc::UnboundedSender<WorkerToParentMessage>,
script_url: &str,
) -> bool {
+ let _reporting_scope = if let Some(state) = get_worker_state(scope) {
+ if state.borrow().in_error_reporting_mode {
+ // A nested exception remains unhandled and propagates to the
+ // parent, without recursively firing another local error event.
+ return false;
+ }
+ state.borrow_mut().in_error_reporting_mode = true;
+ Some(WorkerErrorReportingScope(state))
+ } else {
+ None
+ };
let event = new_worker_error_event(scope, report, script_url, exception);
set_event_dispatch_fields(scope, global, event);
diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs
index e0a49b698..c5b96d696 100644
--- a/moli-renderer-v8/src/worker/thread/mod.rs
+++ b/moli-renderer-v8/src/worker/thread/mod.rs
@@ -1655,6 +1655,7 @@ async fn worker_main(
worker_wake_tx,
termination_requested: Arc::clone(&termination_requested),
closed: false,
+ in_error_reporting_mode: false,
next_timer_id: 0,
loader,
global_kind,
diff --git a/moli-renderer-v8/src/worker/thread/tests/error_reporting_guard.rs b/moli-renderer-v8/src/worker/thread/tests/error_reporting_guard.rs
new file mode 100644
index 000000000..dc683594b
--- /dev/null
+++ b/moli-renderer-v8/src/worker/thread/tests/error_reporting_guard.rs
@@ -0,0 +1,97 @@
+use super::*;
+
+const REPORTING_PROBE: &str = r#"
+const config = __CONFIG__;
+const local = [];
+const outer = new TypeError('outer'), inner = new RangeError('inner'), again = new SyntaxError('again');
+let current = outer, round = 0, nestedCalls = 0;
+const tag = error => error === outer ? 'outer' : error === inner ? 'inner' : error === again ? 'again' : 'unexpected';
+const nestedTarget = new EventTarget();
+nestedTarget.addEventListener('probe', () => { throw inner; });
+function nest(error) {
+ if (error !== outer || nestedCalls) return;
+ if (config.nested === 'dispatch') { nestedCalls++; nestedTarget.dispatchEvent(new Event('probe')); }
+ if (config.nested === 'throw') { nestedCalls++; throw inner; }
+}
+if (config.handler === 'handler') {
+ self.onerror = function(message, filename, line, column, error) {
+ local.push({tag:tag(error), receiverOK:this === self, argumentsOK:arguments.length === 5});
+ nest(error);
+ return config.cancel;
+ };
+} else {
+ self.addEventListener('error', function(event) {
+ local.push({tag:tag(event.error), receiverOK:this === self, argumentsOK:event instanceof ErrorEvent && event.target === self});
+ if (config.cancel) event.preventDefault();
+ nest(event.error);
+ });
+}
+function finish() { postMessage({done:true, local, nestedCalls}); close(); }
+function run() {
+ round++;
+ current = round === 1 ? outer : again;
+ setTimeout(round === 1 ? run : finish, 0);
+ throw current;
+}
+setTimeout(run, 0);
+
+"#;
+
+#[tokio::test]
+async fn worker_error_reporting_suppresses_recursive_events_and_resets_between_errors() {
+ ensure_v8();
+ for (handler, cancel, nested, expected_errors) in [
+ ("listener", true, "dispatch", &["inner"][..]),
+ ("handler", true, "dispatch", &["inner"][..]),
+ ("listener", false, "throw", &["again", "inner", "outer"][..]),
+ ("handler", true, "throw", &["inner", "outer"][..]),
+ ] {
+ let config = serde_json::json!({
+ "handler": handler, "cancel": cancel, "nested": nested,
+ });
+ let source = REPORTING_PROBE.replace("__CONFIG__", &config.to_string());
+ let mut handle = spawn_test_worker_with_options(WorkerSpawnOptions::new(
+ source,
+ "https://worker-errors.test/reporting.js".into(),
+ ));
+ let mut errors = Vec::new();
+ let actual = timeout(TIMEOUT, async {
+ loop {
+ match handle.recv().await.expect("worker channel closed") {
+ WorkerToParentMessage::Post(payload) => {
+ break serde_json::from_str::<serde_json::Value>(&stringify_payload(
+ &payload,
+ ))
+ .unwrap();
+ }
+ WorkerToParentMessage::Error { message, phase, .. } => {
+ assert_eq!(phase, WorkerErrorPhase::Runtime, "{config}");
+ let tag = message.split_whitespace().last().expect("error message");
+ assert!(
+ ["outer", "inner", "again"].contains(&tag),
+ "{config}: {message}"
+ );
+ errors.push(tag.to_owned());
+ }
+ other => panic!("{config}: unexpected worker message {other:?}"),
+ }
+ }
+ })
+ .await
+ .unwrap_or_else(|_| panic!("{config}: worker reporting timed out"));
+ assert_eq!(
+ actual,
+ serde_json::json!({
+ "done": true,
+ "local": [
+ {"tag": "outer", "receiverOK": true, "argumentsOK": true},
+ {"tag": "again", "receiverOK": true, "argumentsOK": true},
+ ],
+ "nestedCalls": u8::from(nested != "none"),
+ }),
+ "{config}"
+ );
+ errors.sort();
+ assert_eq!(errors, expected_errors, "{config}");
+ }
+}
diff --git a/moli-renderer-v8/src/worker/thread/tests/mod.rs b/moli-renderer-v8/src/worker/thread/tests/mod.rs
index 8f545f69b..4305cc88d 100644
--- a/moli-renderer-v8/src/worker/thread/tests/mod.rs
+++ b/moli-renderer-v8/src/worker/thread/tests/mod.rs
@@ -1,4 +1,5 @@
mod abort_signal_events;
+mod error_reporting_guard;
use std::pin::pin;
use std::sync::Arc;
use std::time::Duration;