Use Cow<'static, str> for Metadata strings

tracing-core/src/metadata.rs

@@ -1,5 +1,6 @@
 //! Metadata describing trace data.
 use super::{callsite, field};
+use alloc::borrow::Cow;
 use core::{
     cmp, fmt,
     str::FromStr,
@@ -60,22 +61,22 @@ use core::{
 /// [callsite identifier]: super::callsite::Identifier
 pub struct Metadata<'a> {
     /// The name of the span described by this metadata.
-    name: &'static str,
+    name: Cow<'a, str>,
 
     /// The part of the system that the span that this metadata describes
     /// occurred in.
-    target: &'a str,
+    target: Cow<'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.
-    module_path: Option<&'a str>,
+    module_path: Option<Cow<'a, str>>,
 
     /// The name of the source code file where the span occurred, or `None` if
     /// this could not be determined.
-    file: Option<&'a str>,
+    file: Option<Cow<'a, str>>,
 
     /// The line number in the source code file where the span occurred, or
     /// `None` if this could not be determined.
@@ -122,7 +123,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,9 +132,23 @@ impl<'a> Metadata<'a> {
         fields: field::FieldSet,
         kind: Kind,
     ) -> Self {
+        let file = {
+            if let Some(file) = file {
+                Some(Cow::Borrowed(file))
+            } else {
+                None
+            }
+        };
+        let module_path = {
+            if let Some(module_path) = module_path {
+                Some(Cow::Borrowed(module_path))
+            } else {
+                None
+            }
+        };
         Metadata {
-            name,
-            target,
+            name: Cow::Borrowed(name),
+            target: Cow::Borrowed(target),
             level,
             module_path,
             file,
@@ -154,29 +169,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

tracing-log/src/lib.rs

@@ -209,11 +209,11 @@ pub fn format_trace(record: &log::Record<'_>) -> io::Result<()> {
 
 /// Trait implemented for `tracing` types that can be converted to a `log`
 /// equivalent.
-pub trait AsLog: crate::sealed::Sealed {
+pub trait AsLog<'a>: crate::sealed::Sealed {
     /// The `log` type that this type can be converted into.
     type Log;
     /// Returns the `log` equivalent of `self`.
-    fn as_log(&self) -> Self::Log;
+    fn as_log<'b: 'a>(&'b self) -> Self::Log;
 }
 
 /// Trait implemented for `log` types that can be converted to a `tracing`
@@ -227,12 +227,12 @@ pub trait AsTrace: crate::sealed::Sealed {
 
 impl<'a> crate::sealed::Sealed for Metadata<'a> {}
 
-impl<'a> AsLog for Metadata<'a> {
+impl<'a> AsLog<'a> for Metadata<'a> {
     type Log = log::Metadata<'a>;
-    fn as_log(&self) -> Self::Log {
+    fn as_log<'b: 'a>(&'b self) -> Self::Log {
         log::Metadata::builder()
             .level(self.level().as_log())
-            .target(self.target())
+            .target(&self.target())
             .build()
     }
 }
@@ -352,9 +352,9 @@ impl<'a> AsTrace for log::Record<'a> {
 
 impl crate::sealed::Sealed for tracing_core::Level {}
 
-impl AsLog for tracing_core::Level {
+impl<'a> AsLog<'a> for tracing_core::Level {
     type Log = log::Level;
-    fn as_log(&self) -> log::Level {
+    fn as_log<'b: 'a>(&'b self) -> log::Level {
         match *self {
             tracing_core::Level::ERROR => log::Level::Error,
             tracing_core::Level::WARN => log::Level::Warn,

tracing-log/src/trace_logger.rs

@@ -19,6 +19,7 @@
 )]
 use crate::AsLog;
 use std::{
+    borrow::Cow,
     cell::RefCell,
     collections::HashMap,
     fmt::{self, Write},
@@ -42,9 +43,9 @@ use tracing_core::{
 ///
 /// [`Subscriber`]: https://docs.rs/tracing/0.1.7/tracing/subscriber/trait.Subscriber.html
 /// [flags]: https://docs.rs/tracing/latest/tracing/#crate-feature-flags
-pub struct TraceLogger {
+pub struct TraceLogger<'a> {
     settings: Builder,
-    spans: Mutex<HashMap<Id, SpanLineBuilder>>,
+    spans: Mutex<HashMap<Id, SpanLineBuilder<'a>>>,
     next_id: AtomicUsize,
 }
 
@@ -66,7 +67,7 @@ pub struct Builder {
 
 // ===== impl TraceLogger =====
 
-impl TraceLogger {
+impl TraceLogger<'static> {
     /// Returns a new `TraceLogger` with the default configuration.
     pub fn new() -> Self {
         Self::builder().finish()
@@ -152,7 +153,7 @@ impl Builder {
     /// Complete the builder, returning a configured [`TraceLogger`].
     ///
     /// [`TraceLogger`]: struct.TraceLogger.html
-    pub fn finish(self) -> TraceLogger {
+    pub fn finish(self) -> TraceLogger<'static> {
         TraceLogger::from_builder(self)
     }
 }
@@ -170,7 +171,7 @@ impl Default for Builder {
     }
 }
 
-impl Default for TraceLogger {
+impl Default for TraceLogger<'_> {
     fn default() -> Self {
         TraceLogger {
             settings: Default::default(),
@@ -181,7 +182,7 @@ impl Default for TraceLogger {
 }
 
 #[derive(Debug)]
-struct SpanLineBuilder {
+struct SpanLineBuilder<'a> {
     parent: Option<Id>,
     ref_count: usize,
     fields: String,
@@ -190,11 +191,11 @@ struct SpanLineBuilder {
     module_path: Option<String>,
     target: String,
     level: log::Level,
-    name: &'static str,
+    name: Cow<'a, str>,
 }
 
-impl SpanLineBuilder {
-    fn new(parent: Option<Id>, meta: &Metadata<'_>, fields: String) -> Self {
+impl<'a> SpanLineBuilder<'a> {
+    fn new(parent: Option<Id>, meta: &'a Metadata<'_>, fields: String) -> Self {
         Self {
             parent,
             ref_count: 1,
@@ -204,7 +205,7 @@ impl SpanLineBuilder {
             module_path: meta.module_path().map(String::from),
             target: String::from(meta.target()),
             level: meta.level().as_log(),
-            name: meta.name(),
+            name: meta.name().into(),
         }
     }
 
@@ -233,14 +234,14 @@ impl SpanLineBuilder {
     }
 }
 
-impl field::Visit for SpanLineBuilder {
+impl field::Visit for SpanLineBuilder<'_> {
     fn record_debug(&mut self, field: &field::Field, value: &dyn fmt::Debug) {
         write!(self.fields, " {}={:?};", field.name(), value)
             .expect("write to string should never fail")
     }
 }
 
-impl Subscriber for TraceLogger {
+impl Subscriber for TraceLogger<'static> {
     fn enabled(&self, metadata: &Metadata<'_>) -> bool {
         log::logger().enabled(&metadata.as_log())
     }
@@ -373,7 +374,7 @@ impl Subscriber for TraceLogger {
                 .map(|span| {
                     let fields = span.fields.as_ref();
                     let parent = if self.settings.log_parent {
-                        Some(span.name)
+                        Some(span.name.as_ref())
                     } else {
                         None
                     };
@@ -383,7 +384,7 @@ impl Subscriber for TraceLogger {
             logger.log(
                 &log::Record::builder()
                     .metadata(log_meta)
-                    .target(meta.target())
+                    .target(&meta.target())
                     .module_path(meta.module_path().as_ref().cloned())
                     .file(meta.file().as_ref().cloned())
                     .line(meta.line())
@@ -424,7 +425,7 @@ impl Subscriber for TraceLogger {
     }
 }
 
-impl TraceLogger {
+impl TraceLogger<'static> {
     #[inline]
     fn current_id(&self) -> Option<Id> {
         CURRENT
@@ -455,7 +456,7 @@ impl<'a> fmt::Display for LogEvent<'a> {
     }
 }
 
-impl fmt::Debug for TraceLogger {
+impl fmt::Debug for TraceLogger<'static> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("TraceLogger")
             .field("settings", &self.settings)

tracing-serde/src/lib.rs

@@ -263,8 +263,8 @@ impl<'a> Serialize for SerializeMetadata<'a> {
         S: Serializer,
     {
         let mut state = serializer.serialize_struct("Metadata", 9)?;
-        state.serialize_field("name", self.0.name())?;
-        state.serialize_field("target", self.0.target())?;
+        state.serialize_field("name", &self.0.name())?;
+        state.serialize_field("target", &self.0.target())?;
         state.serialize_field("level", &SerializeLevel(self.0.level()))?;
         state.serialize_field("module_path", &self.0.module_path())?;
         state.serialize_field("file", &self.0.file())?;

tracing-subscriber/src/fmt/format/json.rs

@@ -170,7 +170,7 @@ where
             // that the fields are not supposed to be missing.
             Err(e) => serializer.serialize_entry("field_error", &format!("{}", e))?,
         };
-        serializer.serialize_entry("name", self.0.metadata().name())?;
+        serializer.serialize_entry("name", &self.0.metadata().name())?;
         serializer.end()
     }
 }

tracing-subscriber/src/registry/mod.rs

@@ -213,8 +213,8 @@ where
     }
 
     /// Returns the span's name,
-    pub fn name(&self) -> &'static str {
-        self.data.metadata().name()
+    pub fn name(&self) -> &str {
+        self.metadata().name()
     }
 
     /// Returns a list of [fields] defined by the span.

tracing-subscriber/src/registry/sharded.rs

@@ -422,8 +422,8 @@ mod tests {
 
     #[derive(Default)]
     struct CloseState {
-        open: HashMap<&'static str, Weak<()>>,
-        closed: Vec<(&'static str, Weak<()>)>,
+        open: HashMap<String, Weak<()>>,
+        closed: Vec<(String, Weak<()>)>,
     }
 
     struct SetRemoved(Arc<()>);
@@ -438,7 +438,7 @@ mod tests {
             let is_removed = Arc::new(());
             assert!(
                 lock.open
-                    .insert(span.name(), Arc::downgrade(&is_removed))
+                    .insert(span.name().to_string(), Arc::downgrade(&is_removed))
                     .is_none(),
                 "test layer saw multiple spans with the same name, the test is probably messed up"
             );
@@ -461,7 +461,7 @@ mod tests {
             if let Ok(mut lock) = self.inner.lock() {
                 if let Some(is_removed) = lock.open.remove(name) {
                     assert!(is_removed.upgrade().is_some());
-                    lock.closed.push((name, is_removed));
+                    lock.closed.push((name.to_string(), is_removed));
                 }
             }
         }
@@ -554,14 +554,14 @@ mod tests {
         }
 
         #[allow(unused)] // may want this for future tests
-        fn assert_last_closed(&self, span: Option<&str>) {
+        fn assert_last_closed(&self, span: Option<String>) {
             let lock = self.state.lock().unwrap();
             let last = lock.closed.last().map(|(span, _)| span);
             assert_eq!(
                 last,
                 span.as_ref(),
                 "expected {:?} to have closed last",
-                span
+                span.as_ref()
             );
         }
 
@@ -570,8 +570,8 @@ mod tests {
             let order = order.as_ref();
             for (i, name) in order.iter().enumerate() {
                 assert_eq!(
-                    lock.closed.get(i).map(|(span, _)| span),
-                    Some(name),
+                    lock.closed.get(i).map(|(span, _)| span.as_ref()),
+                    Some(*name),
                     "expected close order: {:?}, actual: {:?}",
                     order,
                     lock.closed.iter().map(|(name, _)| name).collect::<Vec<_>>()

tracing/tests/filter_caching_is_lexically_scoped.rs

@@ -38,7 +38,7 @@ fn filter_caching_is_lexically_scoped() {
     let count2 = count.clone();
 
     let subscriber = subscriber::mock()
-        .with_filter(move |meta| match meta.name() {
+        .with_filter(move |meta| match meta.name().as_ref() {
             "emily" | "frank" => {
                 count2.fetch_add(1, Ordering::Relaxed);
                 true

tracing/tests/filters_are_not_reevaluated_for_the_same_span.rs

@@ -34,7 +34,7 @@ fn filters_are_not_reevaluated_for_the_same_span() {
     let bob_count2 = bob_count.clone();
 
     let (subscriber, handle) = subscriber::mock()
-        .with_filter(move |meta| match meta.name() {
+        .with_filter(move |meta| match meta.name().as_ref() {
             "alice" => {
                 alice_count2.fetch_add(1, Ordering::Relaxed);
                 false

tracing/tests/filters_are_reevaluated_for_different_call_sites.rs

@@ -36,7 +36,7 @@ fn filters_are_reevaluated_for_different_call_sites() {
     let subscriber = subscriber::mock()
         .with_filter(move |meta| {
             println!("Filter: {:?}", meta.name());
-            match meta.name() {
+            match meta.name().as_ref() {
                 "charlie" => {
                     charlie_count2.fetch_add(1, Ordering::Relaxed);
                     false