v0.34.0_2

src/cache/lookup/hot.rs

@@ -1,29 +1,20 @@
 impl Cache {
     fn get_hot(&self, ticket: &Ticket, count_miss: bool) -> Option<Hit> {
+        // Only metadata, hit counters and exact LRU ordering require the store
+        // mutex. Materializing an HTTP response may allocate (headers, Body,
+        // Age formatting) and must be done *after* dropping that mutex.
         let mut store = self.store.lock().unwrap_or_else(|e| e.into_inner());
-        let expired = store.sweep();
-        self.counters
-            .expired
-            .fetch_add(expired as u64, Ordering::Relaxed);
         if store.revision != ticket.revision
             || store.generation != ticket.generation
-            || store
-                .scope_generations
-                .get(&ticket.scope)
-                .copied()
-                .unwrap_or(0)
+            || store.scope_generations.get(&ticket.scope).copied().unwrap_or(0)
                 != ticket.scope_generation
-            || store.key_generations.get(&ticket.key).copied().unwrap_or(0) != ticket.key_generation
+            || store.key_generations.get(&ticket.key).copied().unwrap_or(0)
+                != ticket.key_generation
         {
             return None;
         }
         if let Some(storage_key) = matching_hot_key(&store, ticket) {
-            // Don't remove and reinsert the entire Entry + variant index on
-            // every HOT hit. A cache hit changes only the LRU sequence, hits
-            // counter, and last-access clock; body/headers remain immutable.
-            let banned = store
-                .entries
-                .get(&storage_key)
+            let banned = store.entries.get(&storage_key)
                 .is_some_and(|entry| self.hot_entry_banned(&storage_key, entry));
             if banned {
                 store.remove(&storage_key);
@@ -34,14 +25,9 @@ impl Cache {
                 release_allocator_memory();
                 return None;
             }
-            let Some(entry) = store.entries.get(&storage_key) else {
-                return None;
-            };
+            let entry = store.entries.get(&storage_key)?;
             let resident_age_seconds = hot_resident_age(entry).as_secs();
-            let age = entry
-                .initial_age
-                .saturating_add(entry.received.elapsed())
-                .as_secs();
+            let age = entry.initial_age.saturating_add(entry.received.elapsed()).as_secs();
             let state = cache_state(
                 age,
                 entry.ttl,
@@ -53,48 +39,54 @@ impl Cache {
             );
             if state.servable() {
                 let sequence = store.next_sequence();
-                let (old_sequence, scope, domain, body_bytes, result) = {
+                let (old_sequence, headers, body, hits, transformed, skip_compression,
+                    remaining_ttl, body_bytes) = {
                     let entry = store.entries.get_mut(&storage_key)?;
                     let old_sequence = entry.sequence;
                     entry.hits = entry.hits.saturating_add(1);
                     entry.last_access = Instant::now();
                     entry.sequence = sequence;
-                    let mut response = Response::new(Body::from(entry.body.clone()));
-                    *response.headers_mut() = entry.headers.clone();
-                    if entry.transformed {
-                        response
-                            .extensions_mut()
-                            .insert(crate::transform::CachedTransformed);
-                    }
-                    if entry.skip_compression {
-                        response.extensions_mut().insert(crate::compression::Skip);
-                    }
-                    response.headers_mut().insert(
-                        "age",
-                        HeaderValue::from_str(&age.to_string()).expect("integer header"),
-                    );
-                    let result = Hit {
-                        response,
-                        body: entry.body.clone(),
-                        hits: entry.hits,
-                        transformed: entry.transformed,
-                        remaining_ttl: entry.ttl.saturating_sub(age),
-                        resident_age_seconds,
-                        stale: state.stale(),
-                        background_revalidate: state.background_revalidate(),
-                    };
-                    (old_sequence, entry.scope.clone(), entry.domain.clone(), entry.body.len(), result)
+                    (
+                        old_sequence,
+                        Arc::clone(&entry.headers),
+                        entry.body.clone(),
+                        entry.hits,
+                        entry.transformed,
+                        entry.skip_compression,
+                        entry.ttl.saturating_sub(age),
+                        entry.body.len(),
+                    )
                 };
                 store.lru.remove(&old_sequence);
                 store.lru.insert(sequence, storage_key);
-                // `store.bytes`, `store.logical_bytes` and the Vary schema index
-                // did not change. In particular, this path does not allocate a
-                // replacement variants Vec for every response.
-                if let Some(counter) = store.domain(&scope, &domain) {
-                    counter.saved_body_bytes = counter.saved_body_bytes.saturating_add(body_bytes as u64);
-                }
+                // Preserve the exact LRU and domain-byte counters, without
+                // allocating a replacement variant index or String keys.
+                store.saved_body_hit(&ticket.scope, &ticket.domain, body_bytes);
                 self.counters.hits.fetch_add(1, Ordering::Relaxed);
-                return Some(result);
+                drop(store);
+
+                let mut response = Response::new(Body::from(body.clone()));
+                *response.headers_mut() = headers.as_ref().clone();
+                if transformed {
+                    response.extensions_mut().insert(crate::transform::CachedTransformed);
+                }
+                if skip_compression {
+                    response.extensions_mut().insert(crate::compression::Skip);
+                }
+                response.headers_mut().insert(
+                    "age",
+                    HeaderValue::from_str(&age.to_string()).expect("integer header"),
+                );
+                return Some(Hit {
+                    response,
+                    body,
+                    hits,
+                    transformed,
+                    remaining_ttl,
+                    resident_age_seconds,
+                    stale: state.stale(),
+                    background_revalidate: state.background_revalidate(),
+                });
             }
         }
         if count_miss {
@@ -243,7 +235,7 @@ impl Cache {
             target: entry.target.clone(),
             tags: entry.tags.clone(),
             created_at: entry.created_at,
-            headers: metadata.headers.clone(),
+            headers: Arc::new(metadata.headers.clone()),
             body: body.clone(),
             body_allocated,
             received: Instant::now(),

src/cache/lookup/insert.rs

@@ -51,9 +51,6 @@ impl Cache {
             store.remove(&key);
         }
         store.remove(&storage_key);
-        self.counters
-            .expired
-            .fetch_add(store.sweep() as u64, Ordering::Relaxed);
         let revision = store.revision;
         let generation = store.generation;
         let mut released_hot = false;

src/cache/lookup/tiered.rs

@@ -77,7 +77,7 @@ impl Cache {
             target: ticket.target.clone(),
             tags,
             created_at: ticket.created_at,
-            headers: headers.clone(),
+            headers: Arc::new(headers.clone()),
             body: cached.body.clone(),
             body_allocated: cached.body_allocated,
             received: plan.received,