perf: add a reserve method to Injector to avoid repeated resizing

Author: bantonsson

opentelemetry-http/src/lib.rs

@@ -22,6 +22,11 @@ impl Injector for HeaderInjector<'_> {
             }
         }
     }
+
+    /// Reserves capacity for at least `additional` more entries to be inserted.
+    fn reserve(&mut self, additional: usize) {
+        self.0.reserve(additional);
+    }
 }
 
 /// Helper for extracting headers from HTTP Requests. This is used for OpenTelemetry context
@@ -303,4 +308,52 @@ mod tests {
         assert!(got.contains(&"headername1"));
         assert!(got.contains(&"headername2"));
     }
+
+    #[test]
+    fn http_headers_reserve() {
+        let mut carrier = http::HeaderMap::new();
+
+        // Test that reserve doesn't panic and works correctly
+        {
+            let mut injector = HeaderInjector(&mut carrier);
+            injector.reserve(10);
+
+            // Verify the HeaderMap still works after reserve
+            injector.set("test-header", "test-value".to_string());
+        }
+        assert_eq!(
+            HeaderExtractor(&carrier).get("test-header"),
+            Some("test-value")
+        );
+
+        // Test reserve with zero capacity
+        {
+            let mut injector = HeaderInjector(&mut carrier);
+            injector.reserve(0);
+            injector.set("another-header", "another-value".to_string());
+        }
+        assert_eq!(
+            HeaderExtractor(&carrier).get("another-header"),
+            Some("another-value")
+        );
+
+        // Test that capacity is actually reserved (at least the requested amount)
+        let mut new_carrier = http::HeaderMap::new();
+        {
+            let mut new_injector = HeaderInjector(&mut new_carrier);
+            new_injector.reserve(5);
+        }
+        let initial_capacity = new_carrier.capacity();
+
+        // Add some headers and verify capacity doesn't decrease
+        {
+            let mut new_injector = HeaderInjector(&mut new_carrier);
+            for i in 0..3 {
+                new_injector.set(&format!("header-{}", i), format!("value-{}", i));
+            }
+        }
+
+        assert!(new_carrier.capacity() >= initial_capacity);
+        assert!(new_carrier.capacity() >= 5);
+    }
 }

opentelemetry/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## vNext
 
+- Add `reserve` method to `opentelemetry::propagation::Injector` to hint at the number of elements that will be added to avoid multiple resize operations of the underlying data structure. Has an empty default implementation.
+
 ## v0.31.0
 
 Released 2025-Sep-25

opentelemetry/src/propagation/mod.rs

@@ -31,6 +31,10 @@ pub use text_map_propagator::TextMapPropagator;
 pub trait Injector {
     /// Add a key and value to the underlying data.
     fn set(&mut self, key: &str, value: String);
+
+    #[allow(unused_variables)]
+    /// Hint to reserve capacity for at least `additional` more entries to be inserted.
+    fn reserve(&mut self, additional: usize) {}
 }
 
 /// Extractor provides an interface for removing fields from an underlying struct like `HashMap`
@@ -52,6 +56,11 @@ impl<S: std::hash::BuildHasher> Injector for HashMap<String, String, S> {
     fn set(&mut self, key: &str, value: String) {
         self.insert(key.to_lowercase(), value);
     }
+
+    /// Reserves capacity for at least `additional` more entries to be inserted.
+    fn reserve(&mut self, additional: usize) {
+        self.reserve(additional);
+    }
 }
 
 impl<S: std::hash::BuildHasher> Extractor for HashMap<String, String, S> {
@@ -117,4 +126,53 @@ mod tests {
         assert!(got.contains(&"headername1"));
         assert!(got.contains(&"headername2"));
     }
+
+    #[test]
+    fn hash_map_injector_reserve() {
+        let mut carrier = HashMap::new();
+
+        // Test that reserve doesn't panic and works correctly
+        Injector::reserve(&mut carrier, 10);
+
+        // Verify the HashMap still works after reserve
+        Injector::set(&mut carrier, "test_key", "test_value".to_string());
+        assert_eq!(Extractor::get(&carrier, "test_key"), Some("test_value"));
+
+        // Test reserve with zero capacity
+        Injector::reserve(&mut carrier, 0);
+        Injector::set(&mut carrier, "another_key", "another_value".to_string());
+        assert_eq!(
+            Extractor::get(&carrier, "another_key"),
+            Some("another_value")
+        );
+
+        // Test that capacity is actually reserved (at least the requested amount)
+        let mut new_carrier = HashMap::new();
+        Injector::reserve(&mut new_carrier, 5);
+        let initial_capacity = new_carrier.capacity();
+
+        // Add some elements and verify capacity doesn't decrease
+        for i in 0..3 {
+            Injector::set(
+                &mut new_carrier,
+                &format!("key{}", i),
+                format!("value{}", i),
+            );
+        }
+
+        assert!(new_carrier.capacity() >= initial_capacity);
+        assert!(new_carrier.capacity() >= 5);
+    }
+
+    #[test]
+    fn injector_reserve() {
+        // Test to have full line coverage of default method
+        struct TestInjector();
+        impl Injector for TestInjector {
+            fn set(&mut self, _key: &str, _value: String) {}
+        }
+        let mut test_injector = TestInjector();
+        Injector::reserve(&mut test_injector, 4711);
+        Injector::set(&mut test_injector, "key", "value".to_string());
+    }
 }