chore(sampling): appease the linting and miri gods

Author: bantonsson

libdd-sampling/Cargo.toml

@@ -7,6 +7,7 @@ version = "0.1.0"
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true
+homepage = "https://github.com/DataDog/libdatadog/tree/main/libdd-sampling"
 repository = "https://github.com/DataDog/libdatadog/tree/main/libdd-sampling"
 description = "Core sampling logic for Datadog tracing"
 authors.workspace = true
@@ -33,4 +34,4 @@ v04_span = ["dep:libdd-trace-utils"]
 [dev-dependencies]
 criterion = "0.5"
 libdd-common = { path = "../libdd-common", features = ["bench-utils"] }
-libdd-trace-utils = { path = "../libdd-trace-utils" }
+libdd-trace-utils = { path = "../libdd-trace-utils", version = "3.0.1" }

libdd-sampling/src/datadog_sampler.rs

@@ -462,7 +462,7 @@ mod tests {
         }
     }
 
-    impl<'a> SpanProperties for TestSpan<'a> {
+    impl SpanProperties for TestSpan<'_> {
         type Attribute<'b>
             = &'b TestAttribute
         where
@@ -544,7 +544,7 @@ mod tests {
         }
     }
 
-    impl<'a> SamplingData for TestSamplingData<'a> {
+    impl SamplingData for TestSamplingData<'_> {
         type TraceId = TestTraceId;
         type Properties<'b>
             = TestSpan<'b>

libdd-sampling/src/rate_limiter.rs

@@ -247,6 +247,34 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_rate_limiter_accumulates_fractional_tokens() {
+        // With rate=2/s each token takes 500ms. Sleeping 300ms twice (600ms total) must
+        // yield at least one token. Before the fix, each sub-token call reset last_update
+        // to the call time, so the second 300ms window also computed only 0.6 tokens and
+        // the limiter starved indefinitely. Margins: the first assert!(!..) has 200ms of
+        // headroom below 500ms; the final assert!(..) has 100ms of headroom above 500ms.
+        let limiter = RateLimiter::new(2, None);
+
+        // Drain all initial tokens.
+        for _ in 0..2 {
+            assert!(limiter.is_allowed());
+        }
+        assert!(!limiter.is_allowed());
+
+        // First sleep: 300ms → 0.6 tokens, not enough to allow.
+        thread::sleep(Duration::from_millis(300));
+        assert!(!limiter.is_allowed());
+
+        // Second sleep: another 300ms. Total elapsed since drain ≈ 600ms → 1.2 tokens.
+        // The fix preserves fractional progress so this succeeds; the old code reset
+        // last_update on the first call and only saw another 0.6 tokens here.
+        thread::sleep(Duration::from_millis(300));
+        assert!(limiter.is_allowed());
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_rate_limiter_limit_rate() {
         let limiter = RateLimiter::new(5, None); // 5 per second
 
@@ -269,6 +297,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_rate_limiter_effective_rate() {
         let limiter = RateLimiter::new(50, None); // 50 per second
 
@@ -292,6 +321,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_rate_limiter_thread_safety() {
         let limiter = RateLimiter::new(100, None);
         let limiter_clone = limiter.clone();

libdd-sampling/src/sampling_rule.rs

@@ -241,6 +241,19 @@ impl From<&str> for RuleProvenance {
     }
 }
 
+/// Helper struct for representing i64 values as ValueLike
+struct ValueI64(i64);
+
+impl ValueLike for ValueI64 {
+    fn extract_float(&self) -> Option<f64> {
+        Some(self.0 as f64)
+    }
+
+    fn extract_string(&self) -> Option<std::borrow::Cow<'_, str>> {
+        Some(std::borrow::Cow::Owned(self.0.to_string()))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -595,16 +608,3 @@ mod tests {
         assert!(RuleProvenance::Dynamic < RuleProvenance::Default);
     }
 }
-
-/// Helper struct for representing i64 values as ValueLike
-struct ValueI64(i64);
-
-impl ValueLike for ValueI64 {
-    fn extract_float(&self) -> Option<f64> {
-        Some(self.0 as f64)
-    }
-
-    fn extract_string(&self) -> Option<std::borrow::Cow<'_, str>> {
-        Some(std::borrow::Cow::Owned(self.0.to_string()))
-    }
-}

libdd-sampling/src/v04_span.rs

@@ -134,7 +134,7 @@ impl<'a, T: TraceData> V04SpanProperties<'a, T> {
     }
 }
 
-impl<'a, T: TraceData> SpanProperties for V04SpanProperties<'a, T> {
+impl<T: TraceData> SpanProperties for V04SpanProperties<'_, T> {
     type Attribute<'b>
         = SpanAttribute<'b>
     where
@@ -189,7 +189,7 @@ pub struct V04SamplingData<'a, T: TraceData> {
     pub span: &'a Span<T>,
 }
 
-impl<'a, T: TraceData> SamplingData for V04SamplingData<'a, T> {
+impl<T: TraceData> SamplingData for V04SamplingData<'_, T> {
     type TraceId = u128;
     type Properties<'b>
         = V04SpanProperties<'b, T>
@@ -286,9 +286,9 @@ mod tests {
 
     #[test]
     fn test_span_attribute_value_metric() {
-        let val = SpanAttributeValue::Metric(3.14);
-        assert_eq!(val.extract_float(), Some(3.14));
-        assert_eq!(val.extract_string(), Some(Cow::Owned("3.14".to_string())));
+        let val = SpanAttributeValue::Metric(1.5);
+        assert_eq!(val.extract_float(), Some(1.5));
+        assert_eq!(val.extract_string(), Some(Cow::Owned("1.5".to_string())));
     }
 
     #[test]
@@ -521,9 +521,11 @@ mod tests {
     #[test]
     fn test_integration_tags_apply_to_span() {
         let sampler = DatadogSampler::new(vec![], 100);
-        let mut span = Span::<SliceData<'static>>::default();
-        span.name = "op";
-        span.service = "svc";
+        let span = Span::<SliceData<'static>> {
+            name: "op",
+            service: "svc",
+            ..Default::default()
+        };
 
         let data = V04SamplingData {
             is_parent_sampled: None,