diff --git a/moli-core/src/lib.rs b/moli-core/src/lib.rs index 78969343859..e4f98cb213a 100644 --- a/moli-core/src/lib.rs +++ b/moli-core/src/lib.rs @@ -18,8 +18,10 @@ pub mod testing; pub use moli_page_types as protocol_types; pub use moli_page_types::{LayoutConfiguration, LayoutPolicy, OptionalResourceFetchMask}; -pub use moli_renderer_v8::ProcessEnvironmentOwner; pub use moli_renderer_v8::renderer_output_transport_channel; +pub use moli_renderer_v8::{ + DiagnosticEvent, DiagnosticSource, DiagnosticsSubscription, ProcessEnvironmentOwner, +}; pub use moli_renderer_v8::{ PageId, RendererBrowserContextRuntimeId, RendererDocumentLifecycleIdentity, RendererDocumentTitleChanged, RendererOutputCursor, RendererOutputFence, diff --git a/moli-core/src/runtime/mod.rs b/moli-core/src/runtime/mod.rs index 1fa4268eae3..295ea95a204 100644 --- a/moli-core/src/runtime/mod.rs +++ b/moli-core/src/runtime/mod.rs @@ -261,6 +261,16 @@ fn initial_navigation_request(request: Request) -> Request { } impl Browser { + /// Subscribe to diagnostics from this Browser's Pages and Workers. + /// + /// The subscription receives future events. Producers continue when a + /// receiver lags. Drop the subscription to stop receiving diagnostics. + pub fn subscribe_diagnostics(&self) -> crate::DiagnosticsSubscription { + self.js_runtime + .browser_context_runtime() + .subscribe_diagnostics() + } + fn resource_request_client(&self) -> ResourceRequestClient { ResourceRequestClient::from_browser_resource_runtime_with_page_network_policy( self.resource_runtime.clone(), diff --git a/moli-core/tests/diagnostics.rs b/moli-core/tests/diagnostics.rs new file mode 100644 index 00000000000..badda9ed196 --- /dev/null +++ b/moli-core/tests/diagnostics.rs @@ -0,0 +1,254 @@ +use std::time::Duration; + +use anyhow::Result; +use moli_core::{ + DiagnosticEvent, DiagnosticSource, DiagnosticsSubscription, + runtime::{Browser, BrowserConfig}, +}; +use tokio::{ + io::{AsyncBufReadExt, AsyncWriteExt, BufReader}, + net::TcpListener, + task::JoinHandle, +}; + +#[tokio::test] +async fn browser_diagnostics_are_isolated_and_do_not_read_author_stack_properties() -> Result<()> { + let browser = Browser::new(BrowserConfig::default())?; + let other = Browser::new(BrowserConfig::default())?; + let mut page = browser.fetch("about:blank").await?; + page.evaluate_runtime_expression_async("reportError(new Error('before subscribing'))") + .await?; + let mut diagnostics = browser.subscribe_diagnostics(); + let mut other_diagnostics = other.subscribe_diagnostics(); + assert_empty(&mut diagnostics); + + let result = page + .evaluate_runtime_expression_async( + r#"(() => { + let getterCalls = 0; + let prepareCalls = 0; + const error = new Error("with custom stack"); + Object.defineProperty(error, "stack", { + get() { getterCalls++; return "author stack"; } + }); + Error.prepareStackTrace = () => { prepareCalls++; return "prepared by author"; }; + try { + reportError(error); + reportError(new Error("with lazy stack")); + const element = document.createElement("button"); + element.setAttribute("onclick", "return )"); + void element.onclick; + return JSON.stringify([getterCalls, prepareCalls]); + } finally { + delete Error.prepareStackTrace; + } + })()"#, + ) + .await?; + assert_eq!(result["value"], "[0,0]"); + + for marker in ["with custom stack", "with lazy stack", "SyntaxError"] { + let event = diagnostics.try_recv()?; + assert!( + matches!( + event.as_ref(), + DiagnosticEvent::RuntimeException { + source: DiagnosticSource::Page { page_id }, + message, + handled: false, + .. + } if *page_id == page.page_id() && message.contains(marker) + ), + "{event:?}" + ); + } + assert_empty(&mut diagnostics); + assert_empty(&mut other_diagnostics); + Ok(()) +} + +#[tokio::test] +async fn parser_script_failures_emit_one_diagnostic_and_one_dom_event_each() -> Result<()> { + let server = DiagnosticFixtureServer::spawn().await?; + let browser = Browser::new(BrowserConfig::default())?; + let mut diagnostics = browser.subscribe_diagnostics(); + let mut page = browser.fetch(&server.url("/parser")).await?; + let result = page + .evaluate_runtime_expression_async("scriptEvents.slice().sort().join(',')") + .await?; + assert_eq!(result["value"], "blocking,defer,written"); + + let mut urls = Vec::new(); + for _ in 0..3 { + let event = diagnostics.try_recv()?; + let DiagnosticEvent::ScriptLoadFailure { + source: DiagnosticSource::Page { page_id }, + url, + message, + } = event.as_ref() + else { + panic!("expected a Page script load failure, got {event:?}"); + }; + assert_eq!(*page_id, page.page_id()); + assert!(message.contains("404"), "{message}"); + urls.push(url.clone()); + } + urls.sort(); + assert_eq!( + urls, + ["/blocking.js", "/defer.js", "/written.js"].map(|path| server.url(path)) + ); + assert_empty(&mut diagnostics); + Ok(()) +} + +#[tokio::test] +async fn shared_worker_diagnostics_identify_the_instance_across_clients() -> Result<()> { + let server = DiagnosticFixtureServer::spawn().await?; + let browser = Browser::new(BrowserConfig::default())?; + let mut diagnostics = browser.subscribe_diagnostics(); + let mut instance = None; + + let mut first = browser.fetch(&server.url("/page")).await?; + let mut second = browser.fetch(&server.url("/page")).await?; + for page in [&mut first, &mut second] { + let result = tokio::time::timeout( + Duration::from_secs(15), + page.evaluate_runtime_expression_with_await_async( + r#"new Promise((resolve, reject) => { + globalThis.worker = new SharedWorker("/shared.js", "diagnostics"); + worker.onerror = () => reject(Error("could not start SharedWorker")); + worker.port.onmessage = event => resolve(event.data); + })"#, + true, + ), + ) + .await??; + assert_eq!(result["value"], "ready", "{result}"); + } + + for (page, marker) in [(&mut first, "first"), (&mut second, "second")] { + page.evaluate_runtime_expression_async(&format!("worker.port.postMessage({marker:?})")) + .await?; + let event = tokio::time::timeout(Duration::from_secs(15), diagnostics.recv()).await??; + let DiagnosticEvent::RuntimeException { + source: DiagnosticSource::SharedWorker { instance_id }, + message, + filename, + .. + } = event.as_ref() + else { + panic!("expected a SharedWorker exception, got {event:?}"); + }; + assert!(message.contains(marker), "{message}"); + assert_eq!(filename, &server.url("/shared.js")); + assert_eq!(*instance.get_or_insert(*instance_id), *instance_id); + } + let result = tokio::time::timeout( + Duration::from_secs(15), + first.evaluate_runtime_expression_with_await_async( + r#"new Promise(resolve => { + globalThis.missingWorker = new SharedWorker("/missing.js"); + missingWorker.onerror = () => resolve("error"); + })"#, + true, + ), + ) + .await??; + assert_eq!(result["value"], "error", "{result}"); + let failure = diagnostics.try_recv()?; + assert!( + matches!( + failure.as_ref(), + DiagnosticEvent::ScriptLoadFailure { + source: DiagnosticSource::SharedWorker { instance_id }, + url, + message, + } if Some(*instance_id) != instance && url == &server.url("/missing.js") && message.contains("404") + ), + "{failure:?}" + ); + assert_empty(&mut diagnostics); + Ok(()) +} + +fn assert_empty(diagnostics: &mut DiagnosticsSubscription) { + assert_eq!( + diagnostics.try_recv(), + Err(tokio::sync::broadcast::error::TryRecvError::Empty), + ); +} + +struct DiagnosticFixtureServer { + origin: String, + task: JoinHandle<()>, +} + +impl DiagnosticFixtureServer { + async fn spawn() -> Result { + let listener = TcpListener::bind("127.0.0.1:0").await?; + let origin = format!("http://{}", listener.local_addr()?); + let task = tokio::spawn(async move { + while let Ok((stream, _)) = listener.accept().await { + let mut stream = BufReader::new(stream); + let mut line = String::new(); + stream.read_line(&mut line).await.unwrap(); + let (status, content_type, body) = fixture_response(line.split_whitespace().nth(1)); + loop { + line.clear(); + if stream.read_line(&mut line).await.unwrap() == 0 || line == "\r\n" { + break; + } + } + let response = format!( + "HTTP/1.1 {status}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", + body.len(), + ); + stream + .get_mut() + .write_all(response.as_bytes()) + .await + .unwrap(); + stream.get_mut().shutdown().await.unwrap(); + } + }); + Ok(Self { origin, task }) + } + + fn url(&self, path: &str) -> String { + format!("{}{path}", self.origin) + } +} + +impl Drop for DiagnosticFixtureServer { + fn drop(&mut self) { + self.task.abort(); + } +} + +fn fixture_response(path: Option<&str>) -> (&'static str, &'static str, &'static str) { + match path { + Some("/parser") => ( + "200 OK", + "text/html", + r#" + + + + "#, + ), + Some("/page") => ("200 OK", "text/html", ""), + Some("/shared.js") => ( + "200 OK", + "text/javascript", + "onconnect = event => { + const port = event.ports[0]; + port.onmessage = event => { throw new Error(event.data); }; + port.postMessage('ready'); + };", + ), + _ => ("404 Not Found", "text/plain", "fixture script not found"), + } +} diff --git a/moli-core/tests/fixtures/runtime/parser_owned_module_tla_exotic_rejection_reports_window_error_payload_before_later_module.html b/moli-core/tests/fixtures/runtime/parser_owned_module_tla_exotic_rejection_reports_window_error_payload_before_later_module.html index 65d5543adbc..11db7ca9480 100644 --- a/moli-core/tests/fixtures/runtime/parser_owned_module_tla_exotic_rejection_reports_window_error_payload_before_later_module.html +++ b/moli-core/tests/fixtures/runtime/parser_owned_module_tla_exotic_rejection_reports_window_error_payload_before_later_module.html @@ -5,11 +5,10 @@ window.parserOwnedModuleTlaPayloadOrder = []; window.addEventListener("error", (event) => { window.parserOwnedModuleTlaPayloadOrder.push("window-error"); - window.parserOwnedModuleTlaPayloadErrorMessageMatches = Boolean( - event.error && - typeof event.error.message === "string" && - event.error.message.length > 0, - ); + window.parserOwnedModuleTlaPayloadErrorIdentityMatches = + event.error === window.parserOwnedModuleTlaPayloadReason; + window.parserOwnedModuleTlaPayloadErrorMessageMatches = + typeof event.message === "string" && event.message.length > 0; window.parserOwnedModuleTlaPayloadFilenameMatches = typeof event.filename === "string" && event.filename.includes( @@ -21,8 +20,8 @@ type="module" onerror="window.parserOwnedModuleTlaPayloadOrder.push('script-error');" > - const reason = Object.create(null); - await Promise.reject(reason); + window.parserOwnedModuleTlaPayloadReason = Object.create(null); + await Promise.reject(window.parserOwnedModuleTlaPayloadReason);