Merge remote-tracking branch 'upstream/master' into tag_cardinality_cache_ttl

# Conflicts:
#	src/transforms/tag_cardinality_limit/mod.rs
#	src/transforms/tag_cardinality_limit/tag_value_set.rs

Author: kaarolch

changelog.d/tag_cardinality_limit_improve_memory_usage.enhancement.md

@@ -0,0 +1,3 @@
+Reduce the memory usage of the `tag_cardinality_limit` transform when running in `exact` mode by allocating less unused memory on initialization.
+
+authors: ArunPiduguDD

src/transforms/tag_cardinality_limit/mod.rs

@@ -221,12 +221,7 @@ impl TagCardinalityLimit {
 
         let metric_accepted_tags = self.accepted_tags.entry(metric_key_owned).or_default();
         let tag_value_set = metric_accepted_tags.entry_ref(key).or_insert_with(|| {
-            AcceptedTagValueSet::new(
-                config.value_limit,
-                &config.mode,
-                config.ttl_secs,
-                config.ttl_generations,
-            )
+            AcceptedTagValueSet::new(&config.mode, config.ttl_secs, config.ttl_generations)
         });
 
         if tag_value_set.contains(value) {
@@ -329,12 +324,7 @@ impl TagCardinalityLimit {
         metric_accepted_tags
             .entry_ref(key)
             .or_insert_with(|| {
-                AcceptedTagValueSet::new(
-                    config.value_limit,
-                    &config.mode,
-                    config.ttl_secs,
-                    config.ttl_generations,
-                )
+                AcceptedTagValueSet::new(&config.mode, config.ttl_secs, config.ttl_generations)
             })
             .insert(value.clone());
         false

src/transforms/tag_cardinality_limit/tag_value_set.rs

@@ -91,12 +91,12 @@ struct TtlExactStorage {
 }
 
 impl TtlExactStorage {
-    fn new(value_limit: usize, ttl: Duration, generations: u8) -> Self {
+    fn new(ttl: Duration, generations: u8) -> Self {
         let now = Instant::now();
         let divisor = generations.max(1) as u32;
         let sweep_interval = (ttl / divisor).max(Duration::from_secs(1));
         Self {
-            map: HashMap::with_capacity(value_limit),
+            map: HashMap::new(),
             ttl,
             sweep_interval,
             last_sweep: now,
@@ -284,23 +284,20 @@ impl fmt::Debug for TagValueSetStorage {
 }
 
 impl AcceptedTagValueSet {
-    /// Construct the appropriate backend.
+    /// Construct the appropriate backend from `(mode, ttl_secs, ttl_generations)`.
     ///
-    /// When `ttl_secs` is `None` (default), the backend is identical to the pre-TTL
-    /// behavior — `HashSet` for exact, single `BloomFilter` for probabilistic — so
-    /// existing configs see zero behavioral change.
-    pub fn new(
-        value_limit: usize,
-        mode: &Mode,
-        ttl_secs: Option<u64>,
-        ttl_generations: u8,
-    ) -> Self {
+    /// When `ttl_secs` is `None` or `0`, this is identical to the pre-TTL
+    /// behavior — `HashSet` for exact, single `BloomFilter` for probabilistic —
+    /// so existing configs see zero behavioral change. Neither backend
+    /// pre-allocates with `value_limit` capacity (see vectordotdev/vector#25480
+    /// for the memory rationale).
+    pub fn new(mode: &Mode, ttl_secs: Option<u64>, ttl_generations: u8) -> Self {
         let ttl = ttl_secs.and_then(|s| (s > 0).then(|| Duration::from_secs(s)));
 
         let storage = match (mode, ttl) {
-            (Mode::Exact, None) => TagValueSetStorage::Set(HashSet::with_capacity(value_limit)),
+            (Mode::Exact, None) => TagValueSetStorage::Set(HashSet::new()),
             (Mode::Exact, Some(ttl)) => {
-                TagValueSetStorage::TtlSet(TtlExactStorage::new(value_limit, ttl, ttl_generations))
+                TagValueSetStorage::TtlSet(TtlExactStorage::new(ttl, ttl_generations))
             }
             (Mode::Probabilistic(config), None) => {
                 TagValueSetStorage::Bloom(BloomFilterStorage::new(config.cache_size_per_key))
@@ -392,7 +389,7 @@ mod tests {
 
     #[test]
     fn exact_no_ttl_preserves_today_behavior() {
-        let mut set = AcceptedTagValueSet::new(2, &Mode::Exact, None, 4);
+        let mut set = AcceptedTagValueSet::new(&Mode::Exact, None, 4);
         assert!(!set.contains(&v("a")));
         assert_eq!(set.len(), 0);
         set.insert(v("a"));
@@ -407,7 +404,7 @@ mod tests {
         let mode = Mode::Probabilistic(BloomFilterConfig {
             cache_size_per_key: default_cache_size(),
         });
-        let mut set = AcceptedTagValueSet::new(2, &mode, None, 4);
+        let mut set = AcceptedTagValueSet::new(&mode, None, 4);
         set.insert(v("a"));
         set.insert(v("a"));
         assert_eq!(set.len(), 1, "duplicate insert must not bump count");
@@ -426,7 +423,7 @@ mod tests {
     #[test]
     fn ttl_exact_expires_values_past_ttl() {
         let ttl = Duration::from_secs(60);
-        let mut s = TtlExactStorage::new(8, ttl, 4);
+        let mut s = TtlExactStorage::new(ttl, 4);
         // t0: insert v=a manually so we control its timestamp.
         let t0 = Instant::now();
         s.map.insert(v("a"), t0);
@@ -446,7 +443,7 @@ mod tests {
         // forward — otherwise sweeps continue to use the old (potentially
         // expired) timestamp. A short sleep guarantees `Instant::now()` is
         // strictly after `t_insert` on every platform.
-        let mut s = TtlExactStorage::new(8, Duration::from_secs(60), 4);
+        let mut s = TtlExactStorage::new(Duration::from_secs(60), 4);
         let t_insert = Instant::now();
         s.map.insert(v("a"), t_insert);
         s.last_sweep = t_insert;
@@ -465,7 +462,7 @@ mod tests {
     fn ttl_exact_sweep_interval_floors_to_one_second() {
         // ttl=2s, generations=8 → naive slice = 250ms; we floor to 1s so sweeps
         // never become dominant. Verify the floor.
-        let s = TtlExactStorage::new(8, Duration::from_secs(2), 8);
+        let s = TtlExactStorage::new(Duration::from_secs(2), 8);
         assert!(s.sweep_interval >= Duration::from_secs(1));
     }
 
@@ -474,7 +471,7 @@ mod tests {
         // Regression for the `DropEvent` pre-check bug: a read-only check
         // must NOT update the stored Instant.
         let ttl = Duration::from_secs(60);
-        let mut s = TtlExactStorage::new(8, ttl, 4);
+        let mut s = TtlExactStorage::new(ttl, 4);
         let t0 = Instant::now();
         s.map.insert(v("a"), t0);
         s.last_sweep = t0;

src/transforms/tag_cardinality_limit/tests.rs

@@ -1513,19 +1513,19 @@ fn contains_no_refresh_finds_inserted_values_on_all_backends() {
     for (label, mut set) in [
         (
             "exact no-ttl",
-            AcceptedTagValueSet::new(4, &Mode::Exact, None, 4),
+            AcceptedTagValueSet::new(&Mode::Exact, None, 4),
         ),
         (
             "bloom no-ttl",
-            AcceptedTagValueSet::new(4, &bloom_mode, None, 4),
+            AcceptedTagValueSet::new(&bloom_mode, None, 4),
         ),
         (
             "exact ttl",
-            AcceptedTagValueSet::new(4, &Mode::Exact, Some(60), 4),
+            AcceptedTagValueSet::new(&Mode::Exact, Some(60), 4),
         ),
         (
             "bloom ttl",
-            AcceptedTagValueSet::new(4, &bloom_mode, Some(60), 4),
+            AcceptedTagValueSet::new(&bloom_mode, Some(60), 4),
         ),
     ] {
         set.insert(v1.clone());
@@ -1551,19 +1551,19 @@ fn ttl_zero_disables_ttl() {
     for (label, set) in [
         (
             "exact ttl=0",
-            AcceptedTagValueSet::new(4, &Mode::Exact, Some(0), 4),
+            AcceptedTagValueSet::new(&Mode::Exact, Some(0), 4),
         ),
         (
             "bloom ttl=0",
-            AcceptedTagValueSet::new(4, &bloom_mode, Some(0), 4),
+            AcceptedTagValueSet::new(&bloom_mode, Some(0), 4),
         ),
         (
             "exact ttl=None",
-            AcceptedTagValueSet::new(4, &Mode::Exact, None, 4),
+            AcceptedTagValueSet::new(&Mode::Exact, None, 4),
         ),
         (
             "bloom ttl=None",
-            AcceptedTagValueSet::new(4, &bloom_mode, None, 4),
+            AcceptedTagValueSet::new(&bloom_mode, None, 4),
         ),
     ] {
         assert!(
@@ -1573,7 +1573,7 @@ fn ttl_zero_disables_ttl() {
     }
 
     // Sanity: TTL with a positive value DOES select the TTL backend.
-    let ttl_set = AcceptedTagValueSet::new(4, &Mode::Exact, Some(60), 4);
+    let ttl_set = AcceptedTagValueSet::new(&Mode::Exact, Some(60), 4);
     assert!(ttl_set.ttl_enabled(), "ttl=Some(60) should enable TTL");
 }