[tracing-core] Remove `static requirement from Event

examples/examples/counters.rs

@@ -89,7 +89,7 @@ impl Collect for CounterCollector {
         values.record(&mut self.visitor())
     }
 
-    fn event(&self, event: &Event<'_>) {
+    fn event(&self, event: &Event<'_, '_>) {
         event.record(&mut self.visitor())
     }
 

examples/examples/serde-yak-shave.rs

@@ -58,7 +58,7 @@ impl Collect for JsonSubscriber {
         println!("{}", json);
     }
 
-    fn event(&self, event: &Event<'_>) {
+    fn event(&self, event: &Event<'_, '_>) {
         let json = json!({
             "event": event.as_serde(),
         });

examples/examples/sloggish/sloggish_subscriber.rs

@@ -247,7 +247,7 @@ impl Collect for SloggishSubscriber {
         }
     }
 
-    fn event(&self, event: &tracing::Event<'_>) {
+    fn event(&self, event: &tracing::Event<'_, '_>) {
         let mut stderr = self.stderr.lock();
         let indent = self.stack.lock().unwrap().len();
         self.print_indent(&mut stderr, indent).unwrap();

tracing-core/src/collect.rs

@@ -299,7 +299,7 @@ pub trait Collect: 'static {
     /// [visitor]: super::field::Visit
     /// [`record` method]: super::event::Event::record
     /// [`dispatch` method]: super::event::Event::dispatch
-    fn event(&self, event: &Event<'_>);
+    fn event<'a>(&'a self, event: &'a Event<'a, '_>);
 
     /// Records that a span has been entered.
     ///

tracing-core/src/dispatch.rs

@@ -666,7 +666,7 @@ impl Dispatch {
     /// [`Collect`]: super::collect::Collect
     /// [`event`]: super::collect::Collect::event
     #[inline]
-    pub fn event(&self, event: &Event<'_>) {
+    pub fn event<'a>(&'a self, event: &'a Event<'a, '_>) {
         self.collector().event(event)
     }
 
@@ -829,7 +829,7 @@ impl Collect for NoCollector {
         span::Id::from_u64(0xDEAD)
     }
 
-    fn event(&self, _event: &Event<'_>) {}
+    fn event(&self, _event: &Event<'_, '_>) {}
 
     fn record(&self, _span: &span::Id, _values: &span::Record<'_>) {}
 
@@ -993,7 +993,7 @@ mod test {
 
             fn record_follows_from(&self, _: &span::Id, _: &span::Id) {}
 
-            fn event(&self, _: &Event<'_>) {
+            fn event(&self, _: &Event<'_, '_>) {
                 static EVENTS: AtomicUsize = AtomicUsize::new(0);
                 assert_eq!(
                     EVENTS.fetch_add(1, Ordering::Relaxed),
@@ -1049,7 +1049,7 @@ mod test {
 
             fn record_follows_from(&self, _: &span::Id, _: &span::Id) {}
 
-            fn event(&self, _: &Event<'_>) {}
+            fn event(&self, _: &Event<'_, '_>) {}
 
             fn enter(&self, _: &span::Id) {}
 
@@ -1082,7 +1082,7 @@ mod test {
 
             fn record_follows_from(&self, _: &span::Id, _: &span::Id) {}
 
-            fn event(&self, _: &Event<'_>) {}
+            fn event(&self, _: &Event<'_, '_>) {}
 
             fn enter(&self, _: &span::Id) {}
 

tracing-core/src/event.rs

@@ -20,16 +20,16 @@ use crate::{field, Metadata};
 /// [span]: ../span
 /// [fields]: ../field
 #[derive(Debug)]
-pub struct Event<'a> {
+pub struct Event<'a, 'b> {
     fields: &'a field::ValueSet<'a>,
-    metadata: &'static Metadata<'static>,
+    metadata: &'a Metadata<'b>,
     parent: Parent,
 }
 
-impl<'a> Event<'a> {
+impl<'a, 'b: 'a> Event<'a, 'b> {
     /// Constructs a new `Event` with the specified metadata and set of values,
     /// and observes it with the current collector.
-    pub fn dispatch(metadata: &'static Metadata<'static>, fields: &'a field::ValueSet<'_>) {
+    pub fn dispatch(metadata: &'a Metadata<'_>, fields: &'a field::ValueSet<'_>) {
         let event = Event::new(metadata, fields);
         crate::dispatch::get_default(|current| {
             current.event(&event);
@@ -39,7 +39,7 @@ impl<'a> Event<'a> {
     /// Returns a new `Event` in the current span, with the specified metadata
     /// and set of values.
     #[inline]
-    pub fn new(metadata: &'static Metadata<'static>, fields: &'a field::ValueSet<'a>) -> Self {
+    pub fn new(metadata: &'a Metadata<'b>, fields: &'a field::ValueSet<'a>) -> Self {
         Event {
             metadata,
             fields,
@@ -52,7 +52,7 @@ impl<'a> Event<'a> {
     #[inline]
     pub fn new_child_of(
         parent: impl Into<Option<Id>>,
-        metadata: &'static Metadata<'static>,
+        metadata: &'a Metadata<'b>,
         fields: &'a field::ValueSet<'a>,
     ) -> Self {
         let parent = match parent.into() {
@@ -70,7 +70,7 @@ impl<'a> Event<'a> {
     /// and observes it with the current collector and an explicit parent.
     pub fn child_of(
         parent: impl Into<Option<Id>>,
-        metadata: &'static Metadata<'static>,
+        metadata: &'a Metadata<'b>,
         fields: &'a field::ValueSet<'_>,
     ) {
         let event = Self::new_child_of(parent, metadata, fields);
@@ -95,8 +95,8 @@ impl<'a> Event<'a> {
     /// Returns [metadata] describing this `Event`.
     ///
     /// [metadata]: super::Metadata
-    pub fn metadata(&self) -> &'static Metadata<'static> {
-        self.metadata
+    pub fn metadata(&'a self) -> &'a Metadata<'_> {
+        &self.metadata
     }
 
     /// Returns true if the new event should be a root.

tracing-core/src/metadata.rs

@@ -1,5 +1,7 @@
 //! Metadata describing trace data.
 use super::{callsite, field};
+#[cfg(feature = "alloc")]
+use alloc::borrow::Cow;
 use core::{
     cmp, fmt,
     str::FromStr,
@@ -60,21 +62,33 @@ use core::{
 /// [callsite identifier]: super::callsite::Identifier
 pub struct Metadata<'a> {
     /// The name of the span described by this metadata.
-    name: &'static str,
+    #[cfg(feature = "alloc")]
+    name: Cow<'a, str>,
+    #[cfg(not(feature = "alloc"))]
+    name: &'a str,
 
     /// The part of the system that the span that this metadata describes
     /// occurred in.
+    #[cfg(feature = "alloc")]
+    target: Cow<'a, str>,
+    #[cfg(not(feature = "alloc"))]
     target: &'a str,
 
     /// The level of verbosity of the described span.
     level: Level,
 
     /// The name of the Rust module where the span occurred, or `None` if this
     /// could not be determined.
+    #[cfg(feature = "alloc")]
+    module_path: Option<Cow<'a, str>>,
+    #[cfg(not(feature = "alloc"))]
     module_path: Option<&'a str>,
 
     /// The name of the source code file where the span occurred, or `None` if
     /// this could not be determined.
+    #[cfg(feature = "alloc")]
+    file: Option<Cow<'a, str>>,
+    #[cfg(not(feature = "alloc"))]
     file: Option<&'a str>,
 
     /// The line number in the source code file where the span occurred, or
@@ -122,7 +136,7 @@ impl<'a> Metadata<'a> {
     /// Construct new metadata for a span or event, with a name, target, level, field
     /// names, and optional source code location.
     pub const fn new(
-        name: &'static str,
+        name: &'a str,
         target: &'a str,
         level: Level,
         file: Option<&'a str>,
@@ -131,8 +145,31 @@ impl<'a> Metadata<'a> {
         fields: field::FieldSet,
         kind: Kind,
     ) -> Self {
+        #[cfg(feature = "alloc")]
+        let file = {
+            if let Some(file) = file {
+                Some(Cow::Borrowed(file))
+            } else {
+                None
+            }
+        };
+        #[cfg(feature = "alloc")]
+        let module_path = {
+            if let Some(module_path) = module_path {
+                Some(Cow::Borrowed(module_path))
+            } else {
+                None
+            }
+        };
+
         Metadata {
+            #[cfg(feature = "alloc")]
+            name: Cow::Borrowed(name),
+            #[cfg(not(feature = "alloc"))]
             name,
+            #[cfg(feature = "alloc")]
+            target: Cow::Borrowed(target),
+            #[cfg(not(feature = "alloc"))]
             target,
             level,
             module_path,
@@ -143,6 +180,32 @@ impl<'a> Metadata<'a> {
         }
     }
 
+    /// Construct new metadata for a span or event, with a name, target, level, field
+    /// names, and optional source code location using dynamically allocated data.
+    #[cfg(feature = "alloc")]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    pub fn from_cow(
+        name: impl Into<Cow<'a, str>>,
+        target: impl Into<Cow<'a, str>>,
+        level: Level,
+        file: Option<impl Into<Cow<'a, str>>>,
+        line: Option<u32>,
+        module_path: Option<impl Into<Cow<'a, str>>>,
+        fields: field::FieldSet,
+        kind: Kind,
+    ) -> Self {
+        Metadata {
+            name: name.into(),
+            target: target.into(),
+            level,
+            module_path: module_path.map(Into::into),
+            file: file.map(Into::into),
+            line,
+            fields,
+            kind,
+        }
+    }
+
     /// Returns the names of the fields on the described span or event.
     pub fn fields(&self) -> &field::FieldSet {
         &self.fields
@@ -154,29 +217,29 @@ impl<'a> Metadata<'a> {
     }
 
     /// Returns the name of the span.
-    pub fn name(&self) -> &'static str {
-        self.name
+    pub fn name(&self) -> &str {
+        &self.name
     }
 
     /// Returns a string describing the part of the system where the span or
     /// event that this metadata describes occurred.
     ///
     /// Typically, this is the module path, but alternate targets may be set
     /// when spans or events are constructed.
-    pub fn target(&self) -> &'a str {
-        self.target
+    pub fn target(&self) -> &str {
+        &self.target
     }
 
     /// Returns the path to the Rust module where the span occurred, or
     /// `None` if the module path is unknown.
-    pub fn module_path(&self) -> Option<&'a str> {
-        self.module_path
+    pub fn module_path(&'a self) -> Option<&'a str> {
+        self.module_path.as_ref().map(|p| p.as_ref())
     }
 
     /// Returns the name of the source code file where the span
     /// occurred, or `None` if the file is unknown
-    pub fn file(&self) -> Option<&'a str> {
-        self.file
+    pub fn file(&'a self) -> Option<&'a str> {
+        self.file.as_ref().map(|f| f.as_ref())
     }
 
     /// Returns the line number in the source code file where the span
@@ -799,6 +862,12 @@ impl PartialOrd<Level> for LevelFilter {
 #[cfg(test)]
 mod tests {
     use super::*;
+    #[cfg(feature = "alloc")]
+    use crate::{
+        callsite::{Callsite, Identifier},
+        field::FieldSet,
+        Interest,
+    };
     use core::mem;
 
     #[test]
@@ -863,4 +932,31 @@ mod tests {
             assert_eq!(expected, repr, "repr changed for {:?}", filter)
         }
     }
+
+    #[cfg(feature = "alloc")]
+    #[test]
+    fn create_metadata_from_dynamic_data() {
+        struct TestCallsite;
+        static CS1: TestCallsite = TestCallsite;
+
+        impl Callsite for TestCallsite {
+            fn set_interest(&self, _interest: Interest) {}
+            fn metadata(&self) -> &Metadata<'_> {
+                unimplemented!("not needed for this test")
+            }
+        }
+        let callsite_id = Identifier(&CS1);
+        let field_set = FieldSet::new(&["one", "fine", "day"], callsite_id);
+
+        let _metadata = Metadata::from_cow(
+            "a name".to_string(),
+            "a target",
+            Level::TRACE,
+            Some("a file".to_string()),
+            None,
+            None::<Cow<'_, str>>,
+            field_set,
+            Kind::EVENT,
+        );
+    }
 }

tracing-core/tests/common/mod.rs

@@ -10,7 +10,7 @@ impl Collect for TestCollectorA {
     }
     fn record(&self, _: &span::Id, _: &span::Record<'_>) {}
     fn record_follows_from(&self, _: &span::Id, _: &span::Id) {}
-    fn event(&self, _: &Event<'_>) {}
+    fn event(&self, _: &Event<'_, '_>) {}
     fn enter(&self, _: &span::Id) {}
     fn exit(&self, _: &span::Id) {}
 }
@@ -24,7 +24,7 @@ impl Collect for TestCollectorB {
     }
     fn record(&self, _: &span::Id, _: &span::Record<'_>) {}
     fn record_follows_from(&self, _: &span::Id, _: &span::Id) {}
-    fn event(&self, _: &Event<'_>) {}
+    fn event(&self, _: &Event<'_, '_>) {}
     fn enter(&self, _: &span::Id) {}
     fn exit(&self, _: &span::Id) {}
 }

tracing-journald/src/lib.rs

@@ -10,7 +10,7 @@
 //! [`tracing-subscriber::Subscriber`][subscriber] implementation for logging `tracing` spans
 //! and events to [`systemd-journald`][journald], on Linux distributions that
 //! use `systemd`.
-//!  
+//!
 //! *Compiler support: [requires `rustc` 1.42+][msrv]*
 //!
 //! [msrv]: #supported-rust-versions
@@ -154,7 +154,7 @@ where
         });
     }
 
-    fn on_event(&self, event: &Event, ctx: Context<C>) {
+    fn on_event(&self, event: &Event<'_, '_>, ctx: Context<C>) {
         let mut buf = Vec::with_capacity(256);
 
         // Record span fields