fix(performance): preserve encoded response sizes across cache reuse

This commit is contained in:
ldm0
2026-11-20 22:47:54 +08:00
parent ed46b6293e
commit 98c2ea8d0f
16 changed files with 618 additions and 46 deletions
Generated
+1
View File
@@ -2987,6 +2987,7 @@ dependencies = [
"percent-encoding 2.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
"rcgen",
"serde",
"serde_json",
"strum",
"thiserror",
"tokio",
+1
View File
@@ -41,6 +41,7 @@ url = "2.5.7"
wildcard = "0.3.0"
[dev-dependencies]
serde_json = "1"
h2 = "0.4"
moli-cookie-jar = { path = "../moli-cookie-jar", features = ["test-support"] }
rcgen = { version = "0.13", default-features = false, features = ["aws_lc_rs", "pem"] }
+1
View File
@@ -89,6 +89,7 @@ pub(crate) struct CachedStreamingResponseLookup {
pub(crate) body: std::io::BufReader<std::fs::File>,
pub(crate) needs_validation: bool,
pub(crate) cache_state: crate::ResponseCacheState,
pub(crate) body_sizes: crate::FetchResponseBodySizes,
}
pub(crate) fn cached_streaming_response_needs_validation(
+28 -7
View File
@@ -26,9 +26,21 @@ pub(crate) fn load_cached_streaming_response_lookup(
else {
return Ok(None);
};
let Some(cached) = store.load_reader(&key)? else {
let Some(mut cached) = store.load_reader(&key)? else {
return Ok(None);
};
if cached.metadata.encoded_body_size.is_none() {
// A decoded cache file cannot recover an older compressed wire size.
// Identity entries can be upgraded from their actual body file length.
if cached.metadata.headers.iter().any(|(name, value)| {
name.eq_ignore_ascii_case("content-encoding")
&& !value.is_empty()
&& !value.eq_ignore_ascii_case(b"identity")
}) {
return Ok(None);
}
cached.metadata.encoded_body_size = Some(cached.body_len()?);
}
let cache_request_url = normalized_cache_url_string(request_url);
if cached.metadata.request_url != cache_request_url
|| !vary_headers_match(config, request, request_url, &cached.metadata.vary_headers)
@@ -42,7 +54,6 @@ pub(crate) fn load_cached_streaming_response_lookup(
);
return Ok(None);
}
let mut cached = cached;
// Normalized cache keys should not leak the first request's fragment into
// later streaming hits.
cached.metadata.final_url = request_url.to_string();
@@ -63,7 +74,7 @@ pub(crate) fn load_cached_streaming_response_lookup(
key,
cached,
needs_validation,
)))
)?))
}
pub(crate) fn cached_streaming_response_body_exceeds_response_limit(
@@ -135,13 +146,14 @@ pub(crate) fn finish_streaming_cached_response(
status_text: Option<&str>,
headers: &[(String, Vec<u8>)],
redirected: bool,
body_sizes: Option<crate::FetchResponseBodySizes>,
writer: HttpCacheBodyWriter,
) -> Result<()> {
let Some((_, _)) = cache_store_and_key_for_request(config, request, request_url, cookie_header)
else {
return Ok(());
};
let Some(metadata) = cache_metadata_for_response_parts(
let Some(mut metadata) = cache_metadata_for_response_parts(
config,
request,
request_url,
@@ -154,6 +166,7 @@ pub(crate) fn finish_streaming_cached_response(
return Ok(());
};
metadata.encoded_body_size = body_sizes.map(|sizes| sizes.encoded);
writer.finish(metadata)?;
tracing::debug!(url = %request_url, "stored streaming response in disk cache");
Ok(())
@@ -163,10 +176,18 @@ fn cached_streaming_record_from_entry(
key: String,
entry: HttpCachedEntryReader,
needs_validation: bool,
) -> CachedStreamingResponseLookup {
) -> Result<CachedStreamingResponseLookup> {
let body_sizes = crate::FetchResponseBodySizes {
encoded: entry
.metadata
.encoded_body_size
.expect("cache lookup resolved encoded size"),
decoded: entry.body_len()?,
};
let metadata = entry.metadata.clone();
CachedStreamingResponseLookup {
Ok(CachedStreamingResponseLookup {
key,
body_sizes,
metadata,
final_url: entry.metadata.final_url,
status: entry.metadata.status,
@@ -174,7 +195,7 @@ fn cached_streaming_record_from_entry(
body: entry.body,
needs_validation,
cache_state: crate::ResponseCacheState::Local,
}
})
}
fn entry_reader_body_exceeds_response_limit(
+97 -10
View File
@@ -26,7 +26,18 @@ struct ResponseProgressState {
timing: Mutex<FetchResponseTiming>,
}
/// Native counts of encoded receipt and decoded representation, excluding framing.
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct FetchResponseBodySizes {
pub encoded: u64,
pub decoded: u64,
}
impl ResponseProgress {
pub(crate) fn timing(&self) -> FetchResponseTiming {
*self.inner.timing.lock()
}
pub(crate) fn mark_request_started(&self) {
self.inner
.timing
@@ -62,11 +73,30 @@ impl ResponseProgress {
}
pub(crate) fn mark_response_started(&self) {
self.inner
.timing
.lock()
.response_started_at
.get_or_insert_with(Instant::now);
let mut timing = self.inner.timing.lock();
timing.response_started_at.get_or_insert_with(Instant::now);
timing.body_sizes.get_or_insert_with(Default::default);
}
pub(crate) fn reset_response_body_sizes(&self) {
let mut timing = self.inner.timing.lock();
timing.body_sizes = Some(FetchResponseBodySizes::default());
timing.body_bytes_received = false;
}
pub(crate) fn record_encoded_response_body_size(&self, bytes: u64) {
let mut timing = self.inner.timing.lock();
timing
.body_sizes
.get_or_insert_with(Default::default)
.encoded = bytes;
timing.body_bytes_received |= bytes > 0;
}
pub(crate) fn record_decoded_response_body_size(&self, bytes: usize) {
let mut timing = self.inner.timing.lock();
let sizes = timing.body_sizes.get_or_insert_with(Default::default);
sizes.decoded = sizes.decoded.saturating_add(bytes as u64);
}
fn finish_timing(&self) {
@@ -77,8 +107,12 @@ impl ResponseProgress {
.get_or_insert_with(Instant::now);
}
pub(crate) fn mark_cached_response_available(&self) -> CachedResponseBodyTiming {
pub(crate) fn mark_cached_response_available(
&self,
sizes: FetchResponseBodySizes,
) -> CachedResponseBodyTiming {
self.mark_response_started();
self.inner.timing.lock().body_sizes = Some(sizes);
self.commit_state();
CachedResponseBodyTiming(self.clone())
}
@@ -100,6 +134,7 @@ impl ResponseProgress {
/// Native response boundaries shared with observers of the selected transfer.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct FetchResponseTiming {
body_sizes: Option<FetchResponseBodySizes>,
request_started_at: Option<Instant>,
first_interim_response_started_at: Option<Instant>,
body_bytes_received: bool,
@@ -108,6 +143,9 @@ pub struct FetchResponseTiming {
}
impl FetchResponseTiming {
pub fn body_sizes(self) -> Option<FetchResponseBodySizes> {
self.body_sizes
}
pub fn body_bytes_received(self) -> bool {
self.body_bytes_received
}
@@ -255,6 +293,11 @@ impl FetchCancelHandle {
progress
}
/// Restore representation counts without changing this transfer's clock.
pub fn set_response_body_sizes(&self, sizes: FetchResponseBodySizes) {
self.response_progress().inner.timing.lock().body_sizes = Some(sizes);
}
pub fn response_timing(&self) -> FetchResponseTiming {
*self.response_progress().inner.timing.lock()
}
@@ -270,8 +313,12 @@ impl FetchCancelHandle {
}
#[cfg(test)]
fn mark_cached_response_available(&self) -> CachedResponseBodyTiming {
self.response_progress().mark_cached_response_available()
fn mark_cached_response_available(
&self,
sizes: FetchResponseBodySizes,
) -> CachedResponseBodyTiming {
self.response_progress()
.mark_cached_response_available(sizes)
}
#[cfg(test)]
@@ -286,7 +333,7 @@ impl FetchCancelHandle {
#[cfg(test)]
mod tests {
use super::FetchCancelHandle;
use super::{FetchCancelHandle, FetchResponseBodySizes};
use std::time::Instant;
#[test]
@@ -651,7 +698,10 @@ mod tests {
for reset_before_body_end in [false, true] {
let parent = FetchCancelHandle::new();
let response = parent.child_for_subrequest();
let recorder = response.mark_cached_response_available();
let recorder = response.mark_cached_response_available(FetchResponseBodySizes {
encoded: 23,
decoded: 3,
});
parent.adopt_response_progress(&response);
assert!(parent.response_completion_is_committed());
assert!(parent.response_timing().response_started_at().is_some());
@@ -712,3 +762,40 @@ mod tests {
assert_eq!(parent.response_timing(), Default::default());
}
}
#[cfg(test)]
mod body_size_generation_tests {
use super::*;
#[test]
fn response_body_sizes_remain_with_their_transfer_writer() {
let handle = FetchCancelHandle::new();
let old = handle.begin_response_progress();
old.mark_response_started();
old.record_encoded_response_body_size(23);
old.record_decoded_response_body_size(3);
assert_eq!(
handle.response_timing().body_sizes(),
Some(FetchResponseBodySizes {
encoded: 23,
decoded: 3
})
);
let current = handle.begin_response_progress();
current.mark_response_started();
current.record_encoded_response_body_size(7);
current.record_decoded_response_body_size(5);
old.record_encoded_response_body_size(99);
old.record_decoded_response_body_size(88);
old.commit();
assert_eq!(
handle.response_timing().body_sizes(),
Some(FetchResponseBodySizes {
encoded: 7,
decoded: 5
})
);
assert!(!handle.response_completion_is_committed());
current.commit();
assert!(handle.response_completion_is_committed());
}
}
+1 -1
View File
@@ -41,7 +41,7 @@ pub use blocking::{
clear_http_cache_root_for_origin, cookie_header_for_request, http_cache_stats,
observe_cookie_access_report_for_request, trim_http_cache,
};
pub use cancellation::{FetchCancelHandle, FetchResponseTiming};
pub use cancellation::{FetchCancelHandle, FetchResponseBodySizes, FetchResponseTiming};
pub use client::{FetchClient, FetchClientHandle};
pub use config::FetchConfig;
pub use cors::validate_cors_response_for_origin;
+13
View File
@@ -776,6 +776,7 @@ pub struct RawResponse {
pub status_text: Option<String>,
pub headers: Vec<(String, Vec<u8>)>,
body: ResponseBody,
body_sizes: Option<crate::FetchResponseBodySizes>,
pub request_cookie_report: Option<StoredCookieQueryReport>,
pub cookie_set_reports: Vec<StoredCookieSetReport>,
pub redirected: bool,
@@ -790,6 +791,7 @@ pub struct RawResponse {
impl Clone for RawResponse {
fn clone(&self) -> Self {
Self {
body_sizes: self.body_sizes,
final_url: self.final_url.clone(),
status: self.status,
status_text: self.status_text.clone(),
@@ -812,6 +814,15 @@ impl Clone for RawResponse {
}
impl RawResponse {
pub fn body_sizes(&self) -> Option<crate::FetchResponseBodySizes> {
self.body_sizes
}
pub fn with_body_sizes(mut self, sizes: Option<crate::FetchResponseBodySizes>) -> Self {
self.body_sizes = sizes;
self
}
pub fn with_network_request_extra_info(
mut self,
network_request_extra_info: Option<NetworkRequestExtraInfo>,
@@ -874,6 +885,7 @@ impl RawResponse {
status_text: head.status_text,
headers: head.headers,
body: ResponseBody::materialized_bytes(body),
body_sizes: None,
request_cookie_report: head.request_cookie_report,
cookie_set_reports: head.cookie_set_reports,
redirected: head.redirected,
@@ -894,6 +906,7 @@ impl RawResponse {
status_text: head.status_text,
headers: head.headers,
body: ResponseBody::materialized_bytes(body),
body_sizes: None,
request_cookie_report: head.request_cookie_report,
cookie_set_reports: head.cookie_set_reports,
redirected: head.redirected,
+27 -2
View File
@@ -2037,6 +2037,7 @@ impl RuntimeOwner {
status_text.as_deref(),
&headers,
false,
job.response_progress.timing().body_sizes(),
cache_body_writer,
)
{
@@ -2100,6 +2101,7 @@ impl RuntimeOwner {
status_text.as_deref(),
&headers,
false,
job.response_progress.timing().body_sizes(),
cache_body_writer,
)
{
@@ -2431,6 +2433,7 @@ impl RuntimeOwner {
status_text.as_deref(),
&headers,
false,
job.response_progress.timing().body_sizes(),
cache_body_writer,
)
{
@@ -2494,6 +2497,7 @@ impl RuntimeOwner {
status_text.as_deref(),
&headers,
false,
job.response_progress.timing().body_sizes(),
cache_body_writer,
)
{
@@ -2541,6 +2545,7 @@ impl RuntimeOwner {
status_text.as_deref(),
&headers,
false,
job.response_progress.timing().body_sizes(),
cache_body_writer,
)
{
@@ -3030,6 +3035,9 @@ impl Handler for FetchTransferHandler {
if !data.is_empty() {
self.mark_response_body_received();
}
if let Some(timing) = self.response_progress() {
timing.record_decoded_response_body_size(data.len());
}
match &mut self.response {
FetchResponseCollector::Buffered(collector) => collector.write(data),
FetchResponseCollector::Streaming(collector) => collector.write(data),
@@ -3038,6 +3046,12 @@ impl Handler for FetchTransferHandler {
}
fn header(&mut self, data: &[u8]) -> bool {
if crate::response::parse_http_response_status_line(data)
.is_some_and(|line| line.status >= 200)
&& let Some(timing) = self.response_progress()
{
timing.reset_response_body_sizes();
}
if let Some(recorder) = self.network_observation_recorder.as_ref() {
recorder.record_response_header_line(data);
}
@@ -3052,6 +3066,11 @@ impl Handler for FetchTransferHandler {
if dlnow > 0.0 {
self.mark_response_body_received();
}
if dlnow > 0.0
&& let Some(timing) = self.response_progress()
{
timing.record_encoded_response_body_size(dlnow as u64);
}
let keep_going = match &mut self.response {
FetchResponseCollector::Buffered(collector) => {
collector.progress(dltotal, dlnow, ultotal, ulnow)
@@ -3228,6 +3247,7 @@ fn complete_cached_streaming_html_job(
let CachedStreamingResponseLookup {
metadata,
cache_state,
body_sizes,
final_url,
status,
headers,
@@ -3250,7 +3270,9 @@ fn complete_cached_streaming_html_job(
}
};
let response_timing = job.response_progress.mark_cached_response_available();
let response_timing = job
.response_progress
.mark_cached_response_available(body_sizes);
if let Some(started_tx) = job.started_tx {
let _ = started_tx.send(Ok(StreamingHtmlResponseStart {
status_text: metadata.status_text,
@@ -3355,6 +3377,7 @@ fn complete_cached_streaming_raw_job(
let CachedStreamingResponseLookup {
metadata,
cache_state,
body_sizes,
final_url,
status,
headers,
@@ -3377,7 +3400,9 @@ fn complete_cached_streaming_raw_job(
}
};
let response_timing = job.response_progress.mark_cached_response_available();
let response_timing = job
.response_progress
.mark_cached_response_available(body_sizes);
if let Some(started_tx) = job.started_tx {
let _ = started_tx.send(Ok(StreamingHtmlResponseStart {
+16 -1
View File
@@ -193,6 +193,16 @@ pub struct StreamingRawResponse {
}
impl StreamingRawResponse {
pub fn response_timing(&self) -> crate::FetchResponseTiming {
self.cancel_handle.response_timing()
}
/// Shares observations with a tee's separate cancellation owner. This
/// does not give that owner authority to cancel the source transfer.
pub fn share_response_progress(&self, owner: &FetchCancelHandle) {
owner.adopt_response_progress(&self.cancel_handle);
}
pub fn new(
final_url: Url,
status: u16,
@@ -352,11 +362,16 @@ impl StreamingRawResponse {
/// Prefer chunked consumption for large bodies. This helper exists for
/// compatibility surfaces that still need a complete [`RawResponse`].
pub async fn into_materialized_raw_response(self) -> Result<RawResponse> {
let progress = self.cancel_handle.clone();
let network_request_extra_info = self.network_request_extra_info.clone();
let (head, body) = self.into_body();
RawResponse::from_head_and_body_source(head, body)
.await
.map(|response| response.with_network_request_extra_info(network_request_extra_info))
.map(|response| {
response
.with_body_sizes(progress.response_timing().body_sizes())
.with_network_request_extra_info(network_request_extra_info)
})
}
pub async fn into_lossy_materialized_text_response(self) -> Result<Response> {
+151
View File
@@ -81,6 +81,17 @@ async fn native_response_timing_records_encoded_bytes_before_decoding_failures()
"{method}/{coding}/chunked={chunked}"
);
assert!(timing.response_end_at().is_some());
assert_eq!(
timing.body_sizes(),
Some(crate::FetchResponseBodySizes {
encoded: if method == "GET" {
body.len() as u64
} else {
0
},
decoded: 0,
})
);
server.join().expect("encoded response server")?;
}
Ok(())
@@ -129,6 +140,17 @@ async fn native_response_timing_distinguishes_encoded_empty_bodies_from_head_hea
cancel.response_timing().body_bytes_received(),
method == "GET"
);
assert_eq!(
cancel.response_timing().body_sizes(),
Some(crate::FetchResponseBodySizes {
encoded: if method == "GET" {
GZIP.len() as u64
} else {
0
},
decoded: 0,
})
);
server.join().expect("server thread")?;
}
Ok(())
@@ -373,3 +395,132 @@ async fn native_request_timing_waits_for_the_proxy_tunnel() -> Result<()> {
server.shutdown();
Ok(())
}
#[tokio::test]
async fn native_response_body_sizes_survive_cache_replay_revalidation_and_legacy_entries()
-> Result<()> {
const GZIP: &[u8] = &[
31, 139, 8, 0, 0, 0, 0, 0, 2, 3, 75, 76, 74, 6, 0, 194, 65, 36, 53, 3, 0, 0, 0,
];
for coding in ["identity", "gzip"] {
for chunked in [false, true] {
for legacy in [false, true] {
let payload = if coding == "gzip" {
GZIP
} else {
b"abc".as_slice()
};
let cache_dir = unique_test_cache_dir();
let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
let url = format!("http://{}/compressed", listener.local_addr()?);
let expected_hits = if legacy && coding == "gzip" { 3 } else { 2 };
let server = thread::spawn(move || -> std::io::Result<()> {
for _ in 0..expected_hits {
let (mut stream, _) = listener.accept()?;
let mut request = Vec::new();
let mut byte = [0];
while !request.ends_with(b"\r\n\r\n") {
stream.read_exact(&mut byte)?;
request.push(byte[0]);
}
if String::from_utf8_lossy(&request)
.to_ascii_lowercase()
.contains("if-none-match: \"v1\"")
{
stream.write_all(b"HTTP/1.1 304 Not Modified\r\nCache-Control: max-age=600\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")?;
continue;
}
let framing = if chunked {
"Transfer-Encoding: chunked".to_owned()
} else {
format!("Content-Length: {}", payload.len())
};
write!(
stream,
"HTTP/1.1 200 OK\r\nContent-Encoding: {coding}\r\nContent-Type: text/plain\r\nETag: \"v1\"\r\nCache-Control: max-age=600\r\n{framing}\r\nConnection: close\r\n\r\n"
)?;
if chunked {
write!(stream, "{:x};test=value\r\n", payload.len())?;
stream.write_all(payload)?;
stream.write_all(b"\r\n0\r\nX-Trailer: present\r\n\r\n")?;
} else {
stream.write_all(payload)?;
}
}
Ok(())
});
let mut config = FetchConfig::default();
config.set_http_cache_dir(Some(cache_dir.display().to_string()));
for (index, mode) in [
RequestCacheMode::Default,
RequestCacheMode::Default,
RequestCacheMode::Validate,
RequestCacheMode::Default,
]
.into_iter()
.enumerate()
{
if legacy && index == 1 {
let mut pending = vec![cache_dir.clone()];
let mut changed = 0;
while let Some(directory) = pending.pop() {
for entry in fs::read_dir(directory)? {
let entry = entry?;
if entry.file_type()?.is_dir() {
pending.push(entry.path());
} else if entry.file_name() == "meta.json" {
let mut metadata: serde_json::Value =
serde_json::from_slice(&fs::read(entry.path())?)?;
metadata
.as_object_mut()
.unwrap()
.remove("encoded_body_size");
fs::write(entry.path(), serde_json::to_vec(&metadata)?)?;
changed += 1;
}
}
}
assert_eq!(changed, 1);
}
// A new client proves that the counts are stored in the cache,
// rather than retained only by the first transfer's owner.
let client = FetchClient::new(&config, new_shared_browser_cookie_store());
let cancel = FetchCancelHandle::new();
let mut response = client
.fetch_raw_stream_with_cancel(
Request::get(&url)?.with_cache_mode(mode),
cancel.clone(),
)
.await?;
let expected_state = match index {
0 => crate::ResponseCacheState::None,
1 if legacy && coding == "gzip" => crate::ResponseCacheState::None,
2 => crate::ResponseCacheState::Validated,
_ => crate::ResponseCacheState::Local,
};
assert_eq!(
response.cache_state, expected_state,
"{coding}/chunked={chunked}/legacy={legacy}/index={index}"
);
let mut decoded = Vec::new();
while let Some(chunk) = response.next_chunk().await {
decoded.extend_from_slice(&chunk);
}
response.finish().await?;
assert_eq!(decoded, b"abc");
assert_eq!(
cancel.response_timing().body_sizes(),
Some(crate::FetchResponseBodySizes {
encoded: payload.len() as u64,
decoded: 3
}),
"{coding}/chunked={chunked}/legacy={legacy}/index={index}"
);
}
server.join().expect("compressed cache server")?;
fs::remove_dir_all(cache_dir)?;
}
}
}
Ok(())
}
+5
View File
@@ -29,6 +29,10 @@ pub struct HttpCacheEntryMetadata {
pub status: u16,
pub status_text: Option<String>,
pub headers: Vec<(String, Vec<u8>)>,
/// Original encoded size; cache body files contain decoded bytes. Older
/// entries lack this fact and cannot reconstruct compressed sizes.
#[serde(default)]
pub encoded_body_size: Option<u64>,
pub stored_at_unix_ms: u64,
pub last_used_at_unix_ms: u64,
pub expires_at_unix_ms: Option<u64>,
@@ -54,6 +58,7 @@ impl HttpCacheEntryMetadata {
status,
status_text: None,
headers,
encoded_body_size: None,
stored_at_unix_ms,
last_used_at_unix_ms: stored_at_unix_ms,
expires_at_unix_ms,
+2
View File
@@ -681,6 +681,7 @@ fn missing_body_file_is_treated_as_incomplete_entry() -> Result<()> {
status: 200,
status_text: None,
headers: Vec::new(),
encoded_body_size: None,
stored_at_unix_ms: 1,
last_used_at_unix_ms: 1,
expires_at_unix_ms: Some(2),
@@ -806,6 +807,7 @@ fn metadata_body_file_must_not_escape_entry_directory() -> Result<()> {
status: 200,
status_text: None,
headers: Vec::new(),
encoded_body_size: None,
stored_at_unix_ms: 1,
last_used_at_unix_ms: 1,
expires_at_unix_ms: Some(2),
@@ -18,7 +18,7 @@ pub(crate) struct FetchResourceTiming {
#[derive(Clone, Default)]
struct FetchResourceResponseTiming {
request_start: Option<f64>,
body_bytes_received: bool,
body_sizes: Option<moli_fetch::FetchResponseBodySizes>,
final_headers_start: Option<f64>,
first_interim_start: Option<f64>,
end: Option<f64>,
@@ -106,13 +106,14 @@ impl FetchResourceTiming {
&& final_start.is_none()
&& first_interim.is_none()
&& end.is_none()
&& native.body_sizes().is_none()
{
return;
}
let mut response_timing = self.response_timing.borrow_mut();
let timing = response_timing.get_or_insert_with(Default::default);
timing.request_start = request_start;
timing.body_bytes_received = native.body_bytes_received();
timing.body_sizes = native.body_sizes();
if final_start.is_some() {
timing.final_headers_start = final_start;
timing.first_interim_start = first_interim;
@@ -151,16 +152,7 @@ impl FetchResourceTiming {
if readable && head.cache_state == ResponseCacheState::None {
entry.initiator_url.clone_from(&self.initiator_url);
}
if readable
&& self
.response_timing
.borrow()
.as_ref()
.is_some_and(|timing| timing.body_bytes_received)
{
entry.content_encoding =
moli_fetch::resource_timing_content_encoding(&head.headers).to_owned();
}
self.apply_native_body_sizes(&mut entry, head);
if !readable {
entry.response_status = 0.0;
entry.content_type.clear();
@@ -194,6 +186,28 @@ impl FetchResourceTiming {
entry
}
fn apply_native_body_sizes(&self, entry: &mut ResourcePerformanceEntry, head: &ResponseHead) {
if let Some(sizes) = self
.response_timing
.borrow()
.as_ref()
.and_then(|timing| timing.body_sizes)
{
entry.encoded_body_size = sizes.encoded as f64;
entry.decoded_body_size = sizes.decoded as f64;
entry.transfer_size = match head.cache_state {
ResponseCacheState::Local => 0.0,
ResponseCacheState::Validated => 300.0,
ResponseCacheState::None => entry.encoded_body_size + 300.0,
};
entry.content_encoding = if sizes.encoded > 0 {
moli_fetch::resource_timing_content_encoding(&head.headers).to_owned()
} else {
String::new()
};
}
}
pub(crate) fn failed(&self, url: &Url) -> ResourcePerformanceEntry {
let mut entry = ResourcePerformanceEntry::from_network_failure(
url.as_str(),
+40 -13
View File
@@ -1020,6 +1020,9 @@ impl ResourceRequestClient {
let mut network_request = request.clone();
let cached = match lookup {
Some(RawSubresourceCacheLookup::Local(cached)) => {
if let Some(sizes) = cached.body_sizes() {
cancel_handle.set_response_body_sizes(sizes);
}
return Ok(NetworkFetchResult::without_request_observation(
streaming_raw_response_from_cached_subresource(*cached)?,
));
@@ -1043,13 +1046,16 @@ impl ResourceRequestClient {
let observed = if observe_network {
self.resource_runtime
.client()
.fetch_raw_stream_with_cancel_and_network_metadata(network_request, cancel_handle)
.fetch_raw_stream_with_cancel_and_network_metadata(
network_request,
cancel_handle.clone(),
)
.await?
} else {
NetworkFetchResult::without_request_observation(
self.resource_runtime
.client()
.fetch_raw_stream_with_cancel(network_request, cancel_handle)
.fetch_raw_stream_with_cancel(network_request, cancel_handle.clone())
.await?,
)
};
@@ -1079,7 +1085,11 @@ impl ResourceRequestClient {
head.request_cookie_report = response.request_cookie_report.clone();
head.cookie_set_reports = response.cookie_set_reports.clone();
head.negotiated_http_version = response.negotiated_http_version;
let merged = RawResponse::from_head_and_body(head.clone(), cached.clone_body_bytes());
if let Some(sizes) = cached.body_sizes() {
cancel_handle.set_response_body_sizes(sizes);
}
let merged = RawResponse::from_head_and_body(head.clone(), cached.clone_body_bytes())
.with_body_sizes(cached.body_sizes());
if let Some(cache_key) = cache_key
&& let Some(expires_at) = raw_subresource_memory_cache_expiry(&request, &merged)
{
@@ -1088,11 +1098,12 @@ impl ResourceRequestClient {
.lock()
.insert_raw_subresource(cache_key, merged, expires_at, &cache_request_headers);
}
let completed =
streaming_raw_response_from_head_and_body(head, cached.clone_body_bytes())?
.with_network_request_extra_info(
response.network_request_extra_info().cloned(),
);
let completed = streaming_raw_response_from_head_and_body(
head,
cached.clone_body_bytes(),
cached.body_sizes(),
)?
.with_network_request_extra_info(response.network_request_extra_info().cloned());
return Ok(NetworkFetchResult::with_observation_journal(
completed,
observation_journal,
@@ -1145,6 +1156,8 @@ impl ResourceRequestClient {
let (body_tx, body_rx) = tokio::sync::mpsc::unbounded_channel();
let (completion_tx, completion_rx) = tokio::sync::oneshot::channel();
let resource_runtime = self.resource_runtime.clone();
let outward_cancel = FetchCancelHandle::new();
response.share_response_progress(&outward_cancel);
tokio::spawn(async move {
let mut body = Vec::new();
let completion = 'forwarding: {
@@ -1179,7 +1192,8 @@ impl ResourceRequestClient {
};
if completion.as_ref().is_some_and(Result::is_ok) {
let mut materialized = RawResponse::from_head_and_body(response.head(), body);
let mut materialized = RawResponse::from_head_and_body(response.head(), body)
.with_body_sizes(response.response_timing().body_sizes());
if !request.follow_redirects {
// The outer CORS loop owns the logical redirect history.
// Retain only this hop's representation, then let each
@@ -1213,7 +1227,7 @@ impl ResourceRequestClient {
let _ = completion_tx.send(completion);
}
});
StreamingRawResponse::new_with_head(head, body_rx, FetchCancelHandle::new(), completion_rx)
StreamingRawResponse::new_with_head(head, body_rx, outward_cancel, completion_rx)
}
pub(crate) fn fetch_text_callback<F>(&self, request: Request, callback: F) -> Result<()>
@@ -1593,7 +1607,11 @@ fn streaming_raw_response_from_cached_subresource(
head.cache_state = moli_fetch::ResponseCacheState::Local;
head.cookie_set_reports.clear();
mark_redirects_as_cached(&mut head.redirect_chain);
streaming_raw_response_from_head_and_body(head, response.clone_body_bytes())
streaming_raw_response_from_head_and_body(
head,
response.clone_body_bytes(),
response.body_sizes(),
)
}
fn local_text_response(request: &Request) -> Option<Result<Response>> {
@@ -1609,7 +1627,11 @@ pub(crate) fn streaming_raw_response_from_local_response(
response: Response,
) -> Result<StreamingRawResponse> {
let raw_response = response.into_materialized_raw_response();
streaming_raw_response_from_head_and_body(raw_response.head(), raw_response.clone_body_bytes())
streaming_raw_response_from_head_and_body(
raw_response.head(),
raw_response.clone_body_bytes(),
raw_response.body_sizes(),
)
}
fn response_with_memory_cache_hit(mut response: Response) -> Response {
@@ -1634,6 +1656,7 @@ fn mark_redirects_as_cached(redirects: &mut [moli_fetch::RedirectInfo]) {
fn streaming_raw_response_from_head_and_body(
head: ResponseHead,
body: Vec<u8>,
body_sizes: Option<moli_fetch::FetchResponseBodySizes>,
) -> Result<StreamingRawResponse> {
let (body_tx, body_rx) = tokio::sync::mpsc::unbounded_channel();
let (completion_tx, completion_rx) = tokio::sync::oneshot::channel();
@@ -1644,10 +1667,14 @@ fn streaming_raw_response_from_head_and_body(
}
drop(body_tx);
let _ = completion_tx.send(Ok(()));
let cancel = FetchCancelHandle::new();
if let Some(sizes) = body_sizes {
cancel.set_response_body_sizes(sizes);
}
Ok(StreamingRawResponse::new_with_head(
head,
body_rx,
FetchCancelHandle::new(),
cancel,
completion_rx,
))
}
@@ -57,6 +57,103 @@ async fn handle_timing_request(
let url = url::Url::parse(&format!("http://fixture.test{target}")).unwrap();
let query: HashMap<_, _> = url.query_pairs().into_owned().collect();
let get = |name: &str| query.get(name).map(String::as_str).unwrap_or("");
if url.path() == "/compressed-worker.js" {
let body = r#"self.onmessage = async event => {
const probe = (0, eval)('(' + event.data.source + ')');
postMessage(await probe(event.data.origins, event.data.label));
close();
};"#;
let head = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/javascript\r\nCache-Control: no-store\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
body.len()
);
let _ = socket.write_all(head.as_bytes()).await;
let _ = socket.write_all(body.as_bytes()).await;
return;
}
if url.path() == "/compressed" {
const GZIP: &[u8] = &[
31, 139, 8, 0, 0, 0, 0, 0, 2, 3, 75, 76, 74, 6, 0, 194, 65, 36, 53, 3, 0, 0, 0,
];
const EMPTY: &[u8] = &[
31, 139, 8, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
];
const OPAQUE_PNG: &[u8] = &[
137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0, 0, 1, 0, 0, 0, 1,
8, 4, 0, 0, 0, 181, 28, 12, 2, 0, 0, 0, 11, 73, 68, 65, 84, 120, 218, 99, 252, 255, 31,
0, 3, 3, 2, 0, 239, 163, 47, 89, 0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130,
];
const OPAQUE_GZIP: &[u8] = &[
31, 139, 8, 0, 0, 0, 0, 0, 2, 255, 235, 12, 240, 115, 231, 229, 146, 226, 98, 96, 96,
224, 245, 244, 112, 9, 2, 210, 140, 32, 204, 193, 2, 36, 183, 202, 240, 48, 1, 41, 110,
79, 23, 199, 144, 138, 91, 201, 127, 254, 203, 51, 48, 51, 51, 49, 188, 95, 172, 31, 9,
20, 102, 240, 116, 245, 115, 89, 231, 148, 208, 4, 0, 122, 254, 219, 225, 68, 0, 0, 0,
];
let body = match (get("opaque"), get("kind")) {
("1", "gzip") => OPAQUE_GZIP,
("1", "identity") => OPAQUE_PNG,
(_, "gzip") => GZIP,
(_, "empty") => EMPTY,
_ => b"abc",
};
let validate =
get("cache") == "1" && request.to_ascii_lowercase().contains("if-none-match:");
let status = if validate { 304 } else { 200 };
let chunked = !validate && get("chunked") == "1";
let length = if validate { 0 } else { body.len() };
let framing = if chunked {
"Transfer-Encoding: chunked".to_owned()
} else {
format!("Content-Length: {length}")
};
let mime = if get("opaque") == "1" {
"image/png"
} else {
"text/plain"
};
let mut headers = format!(
"HTTP/1.1 {status} Fixture\r\nContent-Type: {mime}\r\n{framing}\r\nConnection: close\r\n"
);
if get("kind") != "identity" && !validate {
headers.push_str("Content-Encoding: gzip\r\n");
}
headers.push_str(if get("cache") == "1" {
"Cache-Control: max-age=600\r\nETag: \"v1\"\r\n"
} else {
"Cache-Control: no-store\r\n"
});
for (query, header) in [
("cors", "Access-Control-Allow-Origin"),
("tao", "Timing-Allow-Origin"),
] {
if !get(query).is_empty() {
headers.push_str(&format!("{header}: {}\r\n", get(query)));
}
}
headers.push_str("\r\n");
if socket.write_all(headers.as_bytes()).await.is_err()
|| request.starts_with("HEAD ")
|| validate
{
return;
}
if chunked {
if socket
.write_all(format!("{:x};test=value\r\n", body.len()).as_bytes())
.await
.is_err()
{
return;
}
let _ = socket.write_all(body).await;
let _ = socket
.write_all(b"\r\n0\r\nX-Trailer: present\r\n\r\n")
.await;
} else {
let _ = socket.write_all(body).await;
}
return;
}
let key = get("key").to_owned();
let gate = {
let mut state = state.lock();
@@ -314,3 +411,12 @@ async fn run_resource_timing_fixture(fixture: &str, expected_total: usize) {
assert_eq!(result["total"], expected_total);
assert_eq!(result["failures"], serde_json::json!([]));
}
#[tokio::test(flavor = "current_thread")]
async fn compressed_resource_timing_sizes_survive_window_child_worker_and_memory_cache() {
run_resource_timing_fixture(
include_str!("../../../tests/fixtures/compressed-request-resource-timing.js"),
300,
)
.await;
}
@@ -0,0 +1,103 @@
(async () => {
const probe = async (origins, label) => {
const rows = [];
globalThis.__compressedTimingProgress = rows;
const checks = async (name, run) => {
try { await run(); rows.push({name: label + ': ' + name, passed: true}); }
catch (error) { rows.push({name: label + ': ' + name, passed: false, error: String(error)}); }
};
const assert = (condition, message) => { if (!condition) throw Error(message); };
const entryFor = url => new Promise((resolve, reject) => {
const existing = performance.getEntriesByName(url, 'resource');
if (existing.length) { resolve(existing[0]); return; }
const observer = new PerformanceObserver(list => {
const entry = list.getEntries().find(value => value.name === url);
if (entry) { clearTimeout(timer); observer.disconnect(); resolve(entry); }
});
observer.observe({type: 'resource', buffered: true});
const timer = setTimeout(() => { observer.disconnect(); reject(Error('Missing entry: ' + url)); }, 2000);
});
const request = async (api, url, method, opaque, validate) => {
if (api === 'fetch') return (await fetch(url, {method, mode: opaque ? 'no-cors' : 'cors', cache: validate ? 'no-cache' : 'default'})).text();
const xhr = new XMLHttpRequest();
xhr.open(method, url, api !== 'sync-xhr');
if (validate) xhr.setRequestHeader('Cache-Control', 'max-age=0');
if (api === 'sync-xhr') { xhr.send(); return xhr.responseText; }
return new Promise((resolve, reject) => {
xhr.onload = () => resolve(xhr.responseText);
xhr.onerror = () => reject(Error('XHR network error'));
xhr.send();
});
};
const apis = typeof document === 'undefined' ? ['fetch', 'xhr', 'sync-xhr'] : ['fetch', 'xhr'];
const specs = [
{kind: 'gzip', encoded: 23, decoded: 3},
{kind: 'gzip', chunked: true, encoded: 23, decoded: 3},
{kind: 'identity', encoded: 3, decoded: 3},
{kind: 'empty', encoded: 20, decoded: 0},
{kind: 'empty', chunked: true, encoded: 20, decoded: 0},
{kind: 'bad', encoded: 3, decoded: 0, fails: true},
{kind: 'bad', chunked: true, encoded: 3, decoded: 0, fails: true},
{kind: 'gzip', method: 'HEAD', encoded: 0, decoded: 0}
];
let next = 0;
for (const api of apis) for (const mode of ['same', 'cors', 'cors-tao', 'denied', ...(api === 'fetch' ? ['opaque', 'opaque-tao'] : [])]) for (const spec of specs) {
await checks(`${api}/${mode}/${spec.kind}/${spec.chunked ? 'chunked' : 'length'}/${spec.method || 'GET'}`, async () => {
const url = new URL('/compressed', origins[mode === 'same' ? 0 : 1]);
url.searchParams.set('key', `${label}-${++next}`);
url.searchParams.set('kind', spec.kind);
if (spec.chunked) url.searchParams.set('chunked', '1');
if (mode.startsWith('opaque')) url.searchParams.set('opaque', '1');
if (mode.startsWith('cors')) url.searchParams.set('cors', '*');
if (mode.endsWith('tao')) url.searchParams.set('tao', '*');
const name = url.href;
const opaque = mode.startsWith('opaque');
let failed = false;
try { await request(api, name, spec.method || 'GET', opaque, false); } catch { failed = true; }
const entry = await entryFor(name);
const hidden = opaque || mode === 'denied';
assert(failed === (mode === 'denied' || !!spec.fails && !opaque), 'Unexpected body result');
assert(entry.encodedBodySize === (hidden ? 0 : spec.encoded), `encoded=${entry.encodedBodySize}`);
assert(entry.decodedBodySize === (hidden ? 0 : spec.decoded), `decoded=${entry.decodedBodySize}`);
assert(entry.responseStatus === (hidden ? 0 : 200), `status=${entry.responseStatus}`);
const allowed = mode === 'same' || mode.endsWith('tao');
assert(entry.transferSize === (allowed ? (hidden ? 0 : spec.encoded) + 300 : 0), `transfer=${entry.transferSize}`);
assert(performance.getEntriesByName(name, 'resource').length === 1, 'Duplicate timing');
});
}
for (const api of apis) {
const base = `${origins[0]}/compressed?kind=gzip&cache=1&key=${label}-${api}-cache`;
for (let phase = 0; phase < 4; ++phase) await checks(`${api}/cache/${phase}`, async () => {
const url = base + '#phase-' + phase;
assert(await request(api, url, 'GET', false, phase === 2) === 'abc', 'Wrong cached representation');
const entry = await entryFor(url);
assert(entry.encodedBodySize === 23 && entry.decodedBodySize === 3, `cache sizes=${entry.encodedBodySize}/${entry.decodedBodySize}`);
assert(entry.transferSize === [323, 0, 300, 0][phase], `cache transfer=${entry.transferSize}`);
assert(performance.getEntriesByName(url, 'resource').length === 1, 'Duplicate cached timing');
});
}
return {total: rows.length, failures: rows.filter(row => !row.passed)};
};
const results = [await probe(__fetchOrigins, 'window')];
const iframe = document.createElement('iframe');
const child = new Promise((resolve, reject) => {
const timer = setTimeout(() => reject(Error('Child timing probe did not finish')), 30000);
const receive = event => {
if (event.source !== iframe.contentWindow || event.data?.kind !== 'compressed-timing') return;
clearTimeout(timer); removeEventListener('message', receive); resolve(event.data.result);
};
addEventListener('message', receive);
});
iframe.srcdoc = '<!doctype html><script>const probe = ' + probe.toString() + '; probe(' + JSON.stringify(__fetchOrigins) + ', "child").then(result => parent.postMessage({kind:"compressed-timing",result}, "*"));</scr' + 'ipt>';
document.body.appendChild(iframe);
try { results.push(await child); } finally { iframe.remove(); }
const worker = new Worker(__fetchOrigins[0] + '/compressed-worker.js');
try {
results.push(await new Promise((resolve, reject) => {
worker.onmessage = event => resolve(event.data);
worker.onerror = event => reject(Error(event.message));
worker.postMessage({source: probe.toString(), origins: __fetchOrigins, label: 'worker'});
}));
} finally { worker.terminate(); }
return JSON.stringify({total: results.reduce((sum, result) => sum + result.total, 0), failures: results.flatMap(result => result.failures)});
})()