feat: Span::record() to allow recording a value after the span was created.

Author: Byron

gix-trace/src/disabled.rs

@@ -3,6 +3,13 @@
 #[derive(Clone)]
 pub struct Span;
 
+impl Span {
+    /// A no-op
+    pub fn record<V>(&self, _field: &str, _value: V) -> &Self {
+        self
+    }
+}
+
 /// A macro to create a span.
 #[macro_export]
 macro_rules! span {

gix-trace/src/enabled.rs

@@ -1,16 +1,18 @@
-use tracing_core::{dispatcher::get_default as with_dispatcher, span::Id, Dispatch};
+use tracing_core::{dispatcher::get_default as with_dispatcher, span, span::Id, Dispatch};
 
 // these are used later in macros.
 pub use tracing_core::{field, metadata, Metadata};
 
 /// An entered span which will exit on drop.
 #[derive(Clone)]
 pub struct Span {
-    id: Option<(Id, Dispatch)>,
+    id: Option<(Id, Dispatch, &'static Metadata<'static>)>,
 }
 
 impl Span {
-    #[allow(missing_docs)]
+    /// Create a new span.
+    ///
+    /// This constructor is typically invoked by the [`crate::span!`] macro.
     pub fn new(
         level: crate::Level,
         meta: &'static Metadata<'static>,
@@ -23,16 +25,40 @@ impl Span {
                 let id = dispatch.new_span(&tracing_core::span::Attributes::new(meta, values));
                 dispatch.enter(&id);
                 Self {
-                    id: Some((id, dispatch.clone())),
+                    id: Some((id, dispatch.clone(), meta)),
                 }
             })
         }
     }
+
+    /// Record a single `field` to take `value`.
+    ///
+    /// Note that this silently fails if the field name wasn't mentioned when the span was created.
+    pub fn record<V>(&self, field: &str, value: V) -> &Self
+    where
+        V: field::Value,
+    {
+        if let Some((_, _, meta)) = &self.id {
+            let fields = meta.fields();
+            if let Some(field) = fields.field(field) {
+                self.record_all(&fields.value_set(&[(&field, Some(&value as &dyn field::Value))]));
+            }
+        }
+        self
+    }
+
+    fn record_all(&self, values: &field::ValueSet<'_>) -> &Self {
+        if let Some((id, dispatch, _)) = &self.id {
+            let record = span::Record::new(values);
+            dispatch.record(id, &record);
+        }
+        self
+    }
 }
 
 impl Drop for Span {
     fn drop(&mut self) {
-        if let Some((id, dispatch)) = self.id.take() {
+        if let Some((id, dispatch, _meta)) = self.id.take() {
             dispatch.exit(&id);
             dispatch.try_close(id);
         }

gix-trace/src/lib.rs

@@ -35,7 +35,7 @@ pub const MAX_LEVEL: Level = Level::Coarse;
 mod enabled;
 
 #[cfg(feature = "tracing")]
-pub use enabled::Span;
+pub use enabled::{field, Span};
 
 impl Span {
     /// Execute `f` in with this span active, consuming it.
@@ -46,7 +46,7 @@ impl Span {
 
 #[cfg(feature = "tracing")]
 #[doc(hidden)]
-pub use enabled::{field, metadata, MetaOnlyCallsite, Metadata};
+pub use enabled::{metadata, MetaOnlyCallsite, Metadata};
 
 #[cfg(not(feature = "tracing"))]
 mod disabled;

gix-trace/tests/trace.rs

@@ -4,7 +4,8 @@ fn span() {
     let _x = span!(gix_trace::Level::Coarse, "hello");
     let fourty_two = span!(gix_trace::Level::Coarse, "hello", x = "value", y = 42).into_scope(|| 42);
     assert_eq!(fourty_two, 42);
-    span!(target: "other", gix_trace::Level::Coarse, "hello", x = "value", y = 42);
+    let span = span!(target: "other", gix_trace::Level::Coarse, "hello", x = "value", y = 42);
+    span.record("y", "hello").record("x", 36);
 }
 
 #[test]