perf(sampling): change api to avoid collecting meta and metrics

Author: bantonsson

libdd-sampling/src/datadog_sampler.rs

@@ -463,7 +463,10 @@ mod tests {
     }
 
     impl<'a> SpanProperties for TestSpan<'a> {
-        type Attribute = TestAttribute;
+        type Attribute<'b>
+            = &'b TestAttribute
+        where
+            Self: 'b;
 
         fn operation_name(&self) -> Cow<'_, str> {
             self.get_operation_name()
@@ -505,10 +508,7 @@ mod tests {
                 })
         }
 
-        fn attributes<'b>(&'b self) -> impl Iterator<Item = &'b Self::Attribute>
-        where
-            Self: 'b,
-        {
+        fn attributes(&self) -> impl Iterator<Item = &TestAttribute> + '_ {
             self.attributes.iter()
         }
 

libdd-sampling/src/types.rs

@@ -47,6 +47,18 @@ pub trait AttributeLike {
     fn value(&self) -> &Self::Value;
 }
 
+impl<T: AttributeLike> AttributeLike for &T {
+    type Value = T::Value;
+
+    fn key(&self) -> &str {
+        (**self).key()
+    }
+
+    fn value(&self) -> &Self::Value {
+        (**self).value()
+    }
+}
+
 /// A trait for extracting typed values from attribute values.
 ///
 /// Provides methods for converting attribute values to common types used in sampling logic.
@@ -86,7 +98,9 @@ pub trait AttributeFactory {
 /// resource name, and status codes used by sampling rules.
 pub trait SpanProperties {
     /// The type of attribute that implements `AttributeLike`.
-    type Attribute: AttributeLike;
+    type Attribute<'a>: AttributeLike
+    where
+        Self: 'a;
 
     /// Returns the operation name for the span.
     ///
@@ -115,9 +129,7 @@ pub trait SpanProperties {
     fn status_code(&self) -> Option<u32>;
 
     /// Returns an iterator over span attributes.
-    fn attributes<'a>(&'a self) -> impl Iterator<Item = &'a Self::Attribute>
-    where
-        Self: 'a;
+    fn attributes(&self) -> impl Iterator<Item = Self::Attribute<'_>> + '_;
 
     /// Returns an alternate key for the given attribute key.
     ///

libdd-sampling/src/v04_span.rs

@@ -101,22 +101,16 @@ impl<'a> AttributeLike for SpanAttribute<'a> {
     }
 }
 
-/// Span properties extracted from a v04 `Span<T>`, with attributes pre-collected.
-///
-/// Pre-collection is required because [`SpanProperties::attributes`] must return
-/// `impl Iterator<Item = &Self::Attribute>` — items need to exist in memory to be referenced.
-pub struct V04SpanProperties<'a> {
-    name: &'a str,
-    service: &'a str,
-    resource: &'a str,
+/// Span properties borrowing from a v04 `Span<T>`.
+pub struct V04SpanProperties<'a, T: TraceData> {
+    span: &'a Span<T>,
     env: Option<&'a str>,
     status_code: Option<u32>,
-    attributes: Vec<SpanAttribute<'a>>,
 }
 
-impl<'a> V04SpanProperties<'a> {
+impl<'a, T: TraceData> V04SpanProperties<'a, T> {
     /// Builds span properties by borrowing from `span` for lifetime `'a`.
-    pub fn from_span<T: TraceData>(span: &'a Span<T>) -> Self {
+    pub fn from_span(span: &'a Span<T>) -> Self {
         let env = span.meta.get("env").map(|v| v.borrow());
 
         let status_code = span
@@ -132,58 +126,52 @@ impl<'a> V04SpanProperties<'a> {
                     .and_then(|s| s.borrow().parse().ok())
             });
 
-        let attributes = span
-            .meta
-            .iter()
-            .map(|(k, v)| SpanAttribute {
-                key: k.borrow(),
-                value: SpanAttributeValue::Meta(v.borrow()),
-            })
-            .chain(span.metrics.iter().map(|(k, v)| SpanAttribute {
-                key: k.borrow(),
-                value: SpanAttributeValue::Metric(*v),
-            }))
-            .collect();
-
         V04SpanProperties {
-            name: span.name.borrow(),
-            service: span.service.borrow(),
-            resource: span.resource.borrow(),
+            span,
             env,
             status_code,
-            attributes,
         }
     }
 }
 
-impl<'a> SpanProperties for V04SpanProperties<'a> {
-    type Attribute = SpanAttribute<'a>;
+impl<'a, T: TraceData> SpanProperties for V04SpanProperties<'a, T> {
+    type Attribute<'b>
+        = SpanAttribute<'b>
+    where
+        Self: 'b;
 
     fn operation_name(&self) -> Cow<'_, str> {
-        Cow::Borrowed(self.name)
+        Cow::Borrowed(self.span.name.borrow())
     }
 
     fn service(&self) -> Cow<'_, str> {
-        Cow::Borrowed(self.service)
+        Cow::Borrowed(self.span.service.borrow())
     }
 
     fn env(&self) -> Cow<'_, str> {
         self.env.map_or(Cow::Borrowed(""), Cow::Borrowed)
     }
 
     fn resource(&self) -> Cow<'_, str> {
-        Cow::Borrowed(self.resource)
+        Cow::Borrowed(self.span.resource.borrow())
     }
 
     fn status_code(&self) -> Option<u32> {
         self.status_code
     }
 
-    fn attributes<'b>(&'b self) -> impl Iterator<Item = &'b Self::Attribute>
-    where
-        Self: 'b,
-    {
-        self.attributes.iter()
+    fn attributes(&self) -> impl Iterator<Item = SpanAttribute<'_>> + '_ {
+        self.span
+            .meta
+            .iter()
+            .map(|(k, v)| SpanAttribute {
+                key: k.borrow(),
+                value: SpanAttributeValue::Meta(v.borrow()),
+            })
+            .chain(self.span.metrics.iter().map(|(k, v)| SpanAttribute {
+                key: k.borrow(),
+                value: SpanAttributeValue::Metric(*v),
+            }))
     }
 
     fn get_alternate_key<'b>(&self, _key: &'b str) -> Option<Cow<'b, str>> {
@@ -204,7 +192,7 @@ pub struct V04SamplingData<'a, T: TraceData> {
 impl<'a, T: TraceData> SamplingData for V04SamplingData<'a, T> {
     type TraceId = u128;
     type Properties<'b>
-        = V04SpanProperties<'b>
+        = V04SpanProperties<'b, T>
     where
         Self: 'b;
 
@@ -218,7 +206,7 @@ impl<'a, T: TraceData> SamplingData for V04SamplingData<'a, T> {
 
     fn with_span_properties<S, R, F>(&self, s: &S, f: F) -> R
     where
-        F: for<'b> Fn(&S, &V04SpanProperties<'b>) -> R,
+        F: for<'b> Fn(&S, &V04SpanProperties<'b, T>) -> R,
     {
         let props = V04SpanProperties::from_span(self.span);
         f(s, &props)