Use Cow<'static, str> for Metadata strings

tracing-core/src/metadata.rs

@@ -1,6 +1,7 @@
 //! Metadata describing trace data.
 use super::{callsite, field};
 use crate::stdlib::{
+    borrow::Cow,
     cmp, fmt,
     str::FromStr,
     sync::atomic::{AtomicUsize, Ordering},
@@ -60,11 +61,11 @@ use crate::stdlib::{
 /// [callsite identifier]: ../callsite/struct.Identifier.html
 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,
@@ -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>,
@@ -132,8 +133,8 @@ impl<'a> Metadata<'a> {
         kind: Kind,
     ) -> Self {
         Metadata {
-            name,
-            target,
+            name: Cow::Borrowed(name),
+            target: Cow::Borrowed(target),
             level,
             module_path,
             file,
@@ -154,17 +155,17 @@ 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

tracing-log/src/lib.rs

@@ -208,11 +208,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`
@@ -226,12 +226,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()
     }
 }
@@ -351,9 +351,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

@@ -244,8 +244,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

@@ -34,7 +34,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

@@ -29,7 +29,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

@@ -31,7 +31,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

tracing/tests/support/event.rs

@@ -69,7 +69,7 @@ impl MockEvent {
 
     pub fn with_explicit_parent(self, parent: Option<&str>) -> MockEvent {
         let parent = match parent {
-            Some(name) => Parent::Explicit(name.into()),
+            Some(name) => Parent::Explicit(name.to_string()),
             None => Parent::ExplicitRoot,
         };
         Self {

tracing/tests/support/metadata.rs

@@ -13,7 +13,7 @@ impl Expect {
         if let Some(ref expected_name) = self.name {
             let name = actual.name();
             assert!(
-                expected_name == name,
+                *expected_name == name,
                 "expected {} to be named `{}`, but got one named `{}`",
                 ctx,
                 expected_name,