Take into account key size for MemorySizedCache

docs/configuration/node-config.md

@@ -313,6 +313,11 @@ This section contains the configuration options for a Searcher.
 | `request_timeout_secs` | The time before a search request is cancelled. This should match the timeout of the stack calling into quickwit if there is one set.  | `30` |
 | `use_metastore_read_replica` | If true, routes read-only metastore requests from searchers, including DataFusion when enabled, to nodes running the `metastore_read_replica` service. Searchers require at least one `metastore_read_replica` node at startup and do not fall back to the primary metastore. | `false` |
 
+These in-memory cache capacities bound the memory held by cached entries, keys included, not just
+the size of the cached values. `partial_request_cache_capacity` is the most affected by this, since
+its keys embed the search request itself: at an unchanged setting it holds somewhat fewer entries
+than a value-only budget would suggest.
+
 ### Searcher split cache configuration
 
 This section contains the configuration options for the on-disk searcher split cache. Files are stored in the data directory under `searcher-split-cache/`.

quickwit/quickwit-config/src/node_config/mod.rs

@@ -561,6 +561,14 @@ impl CacheConfig {
         }
     }
 
+    pub fn with_capacity_and_policy(capacity: ByteSize, policy: CachePolicy) -> Self {
+        CacheConfig {
+            capacity: Some(capacity),
+            policy: Some(policy),
+            virtual_caches: Vec::new(),
+        }
+    }
+
     pub fn capacity(&self) -> ByteSize {
         // this should always be there
         self.capacity.unwrap_or_default()

quickwit/quickwit-search/src/leaf_cache.rs

@@ -19,7 +19,7 @@ use quickwit_config::CacheConfig;
 use quickwit_proto::search::{
     CountHits, LeafResourceStats, LeafSearchResponse, SearchRequest, SplitIdAndFooterOffsets,
 };
-use quickwit_storage::{MemorySizedCache, OwnedBytes};
+use quickwit_storage::{MemUsage, MemorySizedCache, OwnedBytes};
 use tantivy::index::SegmentId;
 
 /// A cache to memoize `leaf_search_single_split` results.
@@ -118,6 +118,14 @@ impl CacheKey {
     }
 }
 
+impl MemUsage for CacheKey {
+    fn heap_mem_usage(&self) -> usize {
+        // `SearchRequest` cannot easily implement `MemUsage`, but `encoded_len()` is a good proxy
+        // for its memory footprint.
+        self.split_id.heap_mem_usage() + self.request.encoded_len()
+    }
+}
+
 /// A (half-open) range bounded inclusively below and exclusively above [start..end).
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 struct HalfOpenRange {
@@ -249,7 +257,45 @@ mod tests {
         SplitIdAndFooterOffsets,
     };
 
-    use super::LeafSearchCache;
+    use super::{CacheKey, LeafSearchCache, MemUsage};
+
+    #[test]
+    fn test_cache_key_mem_usage_accounts_the_request() {
+        let split_info = SplitIdAndFooterOffsets {
+            split_id: "01H4V2E9K7XQZ8N3M5P6R7S8T9".to_string(),
+            split_footer_start: 0,
+            split_footer_end: 100,
+            timestamp_start: None,
+            timestamp_end: None,
+            num_docs: 0,
+        };
+        let short_request = SearchRequest {
+            index_id_patterns: vec!["test-idx".to_string()],
+            query_ast: "short".to_string(),
+            max_hits: 10,
+            ..Default::default()
+        };
+        let padding = "x".repeat(10_000);
+        let long_request = SearchRequest {
+            query_ast: format!("short{padding}"),
+            ..short_request.clone()
+        };
+
+        let short_key = CacheKey::from_split_meta_and_request(split_info.clone(), short_request);
+        let long_key = CacheKey::from_split_meta_and_request(split_info, long_request);
+
+        // The split id and the request are both owned outside the struct itself.
+        assert!(short_key.mem_usage() > size_of::<CacheKey>());
+        // A longer query AST is charged for, roughly byte for byte. `encoded_len` is a proxy, so
+        // only the order of magnitude is pinned here: the extra length must show up, and must not
+        // be wildly over-counted.
+        let delta = long_key.mem_usage() - short_key.mem_usage();
+        assert!(
+            delta >= padding.len() && delta <= padding.len() + 16,
+            "a {} byte longer query AST grew the key by {delta} bytes",
+            padding.len()
+        );
+    }
 
     #[test]
     fn test_leaf_search_cache_no_timestamp() {