From ceeb4698bb684a320189d8fa7a91f250141be0d9 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sat, 7 Nov 2026 03:50:31 +0800 Subject: [PATCH] fix(performance): default absent connection timing to fetch start Use the allowed response fetch start for DNS and connection timing when there is no client connection, including Service Worker respondWith. Keep TLS unset and retain TAO masking and actual network observations. Cover synthetic, forwarded, network fallback and cross-origin responses in both the top Window and an iframe. --- moli-core/tests/scripts.rs | 2 + .../scripts/connection_resource_timing.rs | 214 ++++++++++++++++++ .../performance_runtime/fetch_timing.rs | 4 + 3 files changed, 220 insertions(+) create mode 100644 moli-core/tests/scripts/connection_resource_timing.rs diff --git a/moli-core/tests/scripts.rs b/moli-core/tests/scripts.rs index 2aea9c37607..d83c2c4260b 100644 --- a/moli-core/tests/scripts.rs +++ b/moli-core/tests/scripts.rs @@ -1,5 +1,7 @@ #[path = "scripts/child_script_text.rs"] mod child_script_text; +#[path = "scripts/connection_resource_timing.rs"] +mod connection_resource_timing; #[path = "scripts/event_source_resource_timing.rs"] mod event_source_resource_timing; #[path = "scripts/font_loading.rs"] diff --git a/moli-core/tests/scripts/connection_resource_timing.rs b/moli-core/tests/scripts/connection_resource_timing.rs new file mode 100644 index 00000000000..874f14a7a27 --- /dev/null +++ b/moli-core/tests/scripts/connection_resource_timing.rs @@ -0,0 +1,214 @@ +use super::*; +use parking_lot::Mutex; +use std::sync::Arc; +use tokio::{ + io::{AsyncReadExt, AsyncWriteExt}, + net::TcpListener, + task::{JoinHandle, JoinSet}, +}; + +struct ConnectionTimingServer { + origin: String, + requests: Arc>>, + task: JoinHandle<()>, +} + +impl Drop for ConnectionTimingServer { + fn drop(&mut self) { + self.task.abort(); + } +} + +impl ConnectionTimingServer { + async fn spawn() -> Result { + let listener = TcpListener::bind("127.0.0.1:0").await?; + let origin = format!("http://{}", listener.local_addr()?); + let requests = Arc::new(Mutex::new(Vec::new())); + let observed = requests.clone(); + let task = tokio::spawn(async move { + let mut connections = JoinSet::new(); + loop { + tokio::select! { + accepted = listener.accept() => { + let Ok((mut socket, _)) = accepted else { break }; + let observed = observed.clone(); + connections.spawn(async move { + let mut request = Vec::new(); + while !request.ends_with(b"\r\n\r\n") && request.len() < 16384 { + let Ok(byte) = socket.read_u8().await else { return }; + request.push(byte); + } + let request = String::from_utf8_lossy(&request); + let path = request.split_whitespace().nth(1).unwrap_or("/"); + observed.lock().push(path.to_owned()); + let (mime, body) = if path.starts_with("/page") { + ("text/html", "connection timing") + } else if path == "/sw.js" { + ("text/javascript", r#" + self.addEventListener('install', event => event.waitUntil(skipWaiting())); + self.addEventListener('activate', event => event.waitUntil(clients.claim())); + self.addEventListener('fetch', event => { + const path = new URL(event.request.url).pathname; + if (path === '/synthetic') + event.respondWith(new Response('synthetic')); + else if (path === '/forward') + event.respondWith(fetch('/network')); + }); + "#) + } else { + ("text/plain", "network") + }; + let response = format!( + "HTTP/1.1 200 OK\r\nContent-Type: {mime}\r\nContent-Length: {}\r\nCache-Control: no-store\r\nAccess-Control-Allow-Origin: *\r\nConnection: close\r\n\r\n{body}", body.len() + ); + let _ = socket.write_all(response.as_bytes()).await; + }); + } + _ = connections.join_next(), if !connections.is_empty() => {} + } + } + }); + Ok(Self { + origin, + requests, + task, + }) + } +} + +async fn check_service_worker_connection_timing(iframe: bool) -> Result<()> { + let server = ConnectionTimingServer::spawn().await?; + let remote = ConnectionTimingServer::spawn().await?; + let browser = Browser::new(AppConfig::default())?; + let mut page = browser.fetch(&format!("{}/page", server.origin)).await?; + let expression = format!( + r#"(async () => {{ + const registration = await navigator.serviceWorker.register('/sw.js'); + await navigator.serviceWorker.ready; + if (!navigator.serviceWorker.controller) + await new Promise(resolve => navigator.serviceWorker.addEventListener('controllerchange', resolve, {{once:true}})); + let realm = window; + if ({iframe}) {{ + const frame = document.createElement('iframe'); + frame.src = '/page?child'; + await new Promise(resolve => {{ frame.onload = resolve; document.body.appendChild(frame); }}); + realm = frame.contentWindow; + }} + await new Promise(resolve => setTimeout(resolve, 20)); + const results = []; + for (const path of ['/synthetic', '/forward', '/network', {remote:?} + '/network']) {{ + const url = new URL(path, location.href).href; + const body = await (await realm.fetch(url)).text(); + const entries = realm.performance.getEntriesByName(url, 'resource').map(e => ({{ + fetchStart:e.fetchStart, domainLookupStart:e.domainLookupStart, + domainLookupEnd:e.domainLookupEnd, connectStart:e.connectStart, connectEnd:e.connectEnd, + secureConnectionStart:e.secureConnectionStart, responseStart:e.responseStart, + responseEnd:e.responseEnd, nextHopProtocol:e.nextHopProtocol, transferSize:e.transferSize + }})); + results.push({{path, body, entries, topCount:performance.getEntriesByName(url, 'resource').length}}); + }} + await registration.unregister(); + return JSON.stringify(results); + }})()"#, + remote = remote.origin, + ); + let result = tokio::time::timeout( + Duration::from_secs(15), + page.evaluate_runtime_expression_with_await_async(&expression, true), + ) + .await??; + assert!(result.get("exceptionDetails").is_none(), "{result}"); + let results: serde_json::Value = serde_json::from_str( + result["value"] + .as_str() + .unwrap_or_else(|| panic!("missing timing results: {result}")), + )?; + let results = results.as_array().unwrap(); + assert_eq!(results.len(), 4); + for (index, result) in results.iter().enumerate() { + assert_eq!( + result["body"], + if index == 0 { "synthetic" } else { "network" } + ); + assert_eq!(result["topCount"], if iframe { 0 } else { 1 }); + let entries = result["entries"].as_array().unwrap(); + assert_eq!( + entries.len(), + 1, + "one timing in the requesting Window: {result}" + ); + let entry = &entries[0]; + let fetch_start = entry["fetchStart"].as_f64().unwrap(); + assert!(fetch_start > 0.0, "{result}"); + assert!( + entry["responseEnd"].as_f64().unwrap() >= fetch_start, + "{result}" + ); + if index < 2 { + for field in [ + "domainLookupStart", + "domainLookupEnd", + "connectStart", + "connectEnd", + ] { + assert_eq!(entry[field], entry["fetchStart"], "{field}: {result}"); + } + assert_eq!( + entry["secureConnectionStart"], 0, + "no client TLS connection: {result}" + ); + assert_eq!( + entry["nextHopProtocol"], "", + "no client HTTP connection: {result}" + ); + } else if index == 2 { + assert!( + entry["connectStart"].as_f64().unwrap() >= fetch_start, + "{result}" + ); + assert!( + entry["connectEnd"].as_f64().unwrap() >= entry["connectStart"].as_f64().unwrap(), + "{result}" + ); + assert_eq!(entry["nextHopProtocol"], "http/1.1", "{result}"); + assert!(entry["transferSize"].as_f64().unwrap() > 300.0, "{result}"); + } else { + for field in [ + "domainLookupStart", + "domainLookupEnd", + "connectStart", + "connectEnd", + "secureConnectionStart", + "responseStart", + "transferSize", + ] { + assert_eq!( + entry[field], 0, + "cross-origin response without TAO: {field}: {result}" + ); + } + assert_eq!(entry["nextHopProtocol"], "", "{result}"); + } + } + let requests = server.requests.lock(); + assert!( + !requests + .iter() + .any(|path| path == "/synthetic" || path == "/forward") + ); + assert_eq!( + requests.iter().filter(|path| *path == "/network").count(), + 2 + ); + Ok(()) +} + +#[tokio::test(flavor = "multi_thread")] +async fn service_worker_response_without_connection_uses_window_fetch_start() -> Result<()> { + check_service_worker_connection_timing(false).await +} + +#[tokio::test(flavor = "multi_thread")] +async fn service_worker_response_without_connection_uses_child_fetch_start() -> Result<()> { + check_service_worker_connection_timing(true).await +} diff --git a/moli-renderer-v8/src/context_bootstrap/performance_runtime/fetch_timing.rs b/moli-renderer-v8/src/context_bootstrap/performance_runtime/fetch_timing.rs index 1eab8784f6f..259434b38f0 100644 --- a/moli-renderer-v8/src/context_bootstrap/performance_runtime/fetch_timing.rs +++ b/moli-renderer-v8/src/context_bootstrap/performance_runtime/fetch_timing.rs @@ -403,6 +403,10 @@ impl FetchResourceTiming { .and_then(|timing| timing.connection_timing()) .and_then(|timing| timing.connection) else { + // A response without a client connection (for example respondWith) + // uses fetchStart for DNS and connect timing. It performed no TLS + // handshake, regardless of the requested URL's scheme. + entry.connection_timing = Some(ResourceConnectionTiming::at(start, false)); return; }; // Reuse is decided by the selected connection's actual creation time,