tracing-subscriber: Switch to unconditional no_std

Author: jplatte

tracing-subscriber/src/filter/directive.rs

@@ -1,7 +1,6 @@
 use crate::filter::level::{self, LevelFilter};
-#[cfg(not(feature = "smallvec"))]
-use alloc::vec;
-#[cfg(not(feature = "std"))]
+#[cfg(feature = "std")]
+use alloc::boxed::Box;
 use alloc::{string::String, vec::Vec};
 
 use core::{cmp::Ordering, fmt, iter::FromIterator, slice, str::FromStr};
@@ -126,7 +125,7 @@ impl<T> IntoIterator for DirectiveSet<T> {
     #[cfg(feature = "smallvec")]
     type IntoIter = smallvec::IntoIter<[T; 8]>;
     #[cfg(not(feature = "smallvec"))]
-    type IntoIter = vec::IntoIter<T>;
+    type IntoIter = alloc::vec::IntoIter<T>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.directives.into_iter()

tracing-subscriber/src/filter/env/builder.rs

@@ -3,7 +3,12 @@ use super::{
     EnvFilter, FromEnvError,
 };
 use crate::sync::RwLock;
-use std::env;
+use alloc::{
+    format,
+    string::{String, ToString},
+    vec::Vec,
+};
+use std::{env, eprintln};
 use thread_local::ThreadLocal;
 use tracing::level_filters::STATIC_MAX_LEVEL;
 

tracing-subscriber/src/filter/env/directive.rs

@@ -4,6 +4,7 @@ use crate::filter::{
     env::{field, FieldMap},
     level::LevelFilter,
 };
+use alloc::{borrow::ToOwned, string::String, vec::Vec};
 use std::{cmp::Ordering, fmt, iter::FromIterator, str::FromStr};
 use tracing_core::{span, Level, Metadata};
 
@@ -481,6 +482,7 @@ impl SpanMatcher {
 #[cfg(test)]
 mod test {
     use super::*;
+    use alloc::{format, string::ToString, vec};
 
     fn parse_directives(dirs: impl AsRef<str>) -> Vec<Directive> {
         dirs.as_ref()

tracing-subscriber/src/filter/env/field.rs

@@ -1,14 +1,17 @@
-use matchers::Pattern;
-use std::{
+use alloc::{
+    borrow::ToOwned,
+    boxed::Box,
+    string::{String, ToString},
+    sync::Arc,
+};
+use core::{
     cmp::Ordering,
-    error::Error,
     fmt::{self, Write},
     str::FromStr,
-    sync::{
-        atomic::{AtomicBool, Ordering::*},
-        Arc,
-    },
+    sync::atomic::{AtomicBool, Ordering::*},
 };
+use matchers::Pattern;
+use std::error::Error;
 
 use super::{FieldMap, LevelFilter};
 use tracing_core::field::{Field, Visit};
@@ -507,9 +510,7 @@ impl Visit for MatchVisitor<'_> {
             Some((ValueMatch::NaN, ref matched)) if value.is_nan() => {
                 matched.store(true, Release);
             }
-            Some((ValueMatch::F64(ref e), ref matched))
-                if (value - *e).abs() < f64::EPSILON =>
-            {
+            Some((ValueMatch::F64(ref e), ref matched)) if (value - *e).abs() < f64::EPSILON => {
                 matched.store(true, Release);
             }
             _ => {}
@@ -576,6 +577,8 @@ impl Visit for MatchVisitor<'_> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use alloc::format;
+
     #[derive(Debug)]
     #[allow(dead_code)]
     struct MyStruct {

tracing-subscriber/src/filter/env/mod.rs

@@ -14,8 +14,10 @@ use crate::{
     layer::{Context, Layer},
     sync::RwLock,
 };
+use alloc::{fmt, str::FromStr, vec::Vec};
+use core::cell::RefCell;
 use directive::ParseError;
-use std::{cell::RefCell, collections::HashMap, env, error::Error, fmt, str::FromStr};
+use std::{collections::HashMap, env, error::Error};
 use thread_local::ThreadLocal;
 use tracing_core::{
     callsite,
@@ -835,6 +837,8 @@ impl Error for FromEnvError {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use alloc::format;
+    use std::println;
     use tracing_core::field::FieldSet;
     use tracing_core::*;
 

tracing-subscriber/src/filter/layer_filters/mod.rs

@@ -32,15 +32,14 @@ use crate::{
     layer::{self, Context, Layer},
     registry,
 };
-use std::{
+use alloc::{boxed::Box, fmt, sync::Arc};
+use core::{
     any::TypeId,
     cell::{Cell, RefCell},
-    fmt,
     marker::PhantomData,
     ops::Deref,
-    sync::Arc,
-    thread_local,
 };
+use std::thread_local;
 use tracing_core::{
     span,
     subscriber::{Interest, Subscriber},

tracing-subscriber/src/filter/targets.rs

@@ -13,7 +13,6 @@ use crate::{
     },
     layer,
 };
-#[cfg(not(feature = "std"))]
 use alloc::string::String;
 use core::{
     fmt,
@@ -596,16 +595,17 @@ impl<'a> Iterator for Iter<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use alloc::{string::ToString, vec, vec::Vec};
+    #[cfg(feature = "std")]
+    use std::dbg;
 
-    feature! {
-        #![not(feature = "std")]
-        use alloc::{vec, vec::Vec, string::ToString};
-
-        // `dbg!` is only available with `libstd`; just nop it out when testing
-        // with alloc only.
-        macro_rules! dbg {
-            ($x:expr) => { $x }
-        }
+    // `dbg!` is only available with `libstd`; just nop it out when testing
+    // with alloc only.
+    #[cfg(not(feature = "std"))]
+    macro_rules! dbg {
+        ($x:expr) => {
+            $x
+        };
     }
 
     fn expect_parse(s: &str) -> Targets {
@@ -775,6 +775,8 @@ mod tests {
     // `println!` is only available with `libstd`.
     #[cfg(feature = "std")]
     fn size_of_filters() {
+        use std::println;
+
         fn print_sz(s: &str) {
             let filter = s.parse::<Targets>().expect("filter should parse");
             println!(

tracing-subscriber/src/fmt/fmt_layer.rs

@@ -4,10 +4,10 @@ use crate::{
     layer::{self, Context},
     registry::{self, LookupSpan, SpanRef},
 };
+use alloc::{fmt, format, string::String};
+use core::{any::TypeId, marker::PhantomData, ops::Deref};
 use format::{FmtSpan, TimingDisplay};
-use std::{
-    any::TypeId, cell::RefCell, env, fmt, io, marker::PhantomData, ops::Deref, time::Instant,
-};
+use std::{cell::RefCell, env, eprintln, io, thread_local, time::Instant};
 use tracing_core::{
     field,
     span::{Attributes, Current, Id, Record},
@@ -1257,6 +1257,7 @@ mod test {
         time,
     };
     use crate::Registry;
+    use alloc::{string::ToString, vec, vec::Vec};
     use format::FmtSpan;
     use regex::Regex;
     use tracing::subscriber::with_default;
@@ -1631,8 +1632,7 @@ mod test {
             .with_timer(MockTime)
             .with_span_events(FmtSpan::ACTIVE);
 
-        let (reloadable_layer, reload_handle) =
-            crate::reload::Layer::new(inner_layer);
+        let (reloadable_layer, reload_handle) = crate::reload::Layer::new(inner_layer);
         let reload = reloadable_layer.with_subscriber(Registry::default());
 
         with_default(reload, || {

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

@@ -7,12 +7,14 @@ use crate::{
     },
     registry::LookupSpan,
 };
-use serde::ser::{SerializeMap, Serializer as _};
-use serde_json::Serializer;
-use std::{
+use alloc::{
     collections::BTreeMap,
     fmt::{self, Write},
+    format,
+    string::String,
 };
+use serde::ser::{SerializeMap, Serializer as _};
+use serde_json::Serializer;
 use tracing_core::{
     field::{self, Field},
     span::Record,

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

@@ -48,7 +48,6 @@ use tracing_log::NormalizeEvent;
 #[cfg(feature = "ansi")]
 use nu_ansi_term::{Color, Style};
 
-
 mod escape;
 use escape::Escape;
 
@@ -433,6 +432,8 @@ impl<'writer> Writer<'writer> {
     /// value implementing [`fmt::Write`] is a [`String`], it will contain
     /// the formatted output of [`Format::format_event`], which may then be
     /// used for other purposes.
+    ///
+    /// [`String`]: alloc::string::String
     #[must_use]
     pub fn new(writer: &'writer mut impl fmt::Write) -> Self {
         Self {
@@ -1269,7 +1270,10 @@ impl field::Visit for DefaultVisitor<'_> {
                 ),
             )
         } else {
-            self.record_debug(field, &format_args!("{}", Escape(&format_args!("{}", value))))
+            self.record_debug(
+                field,
+                &format_args!("{}", Escape(&format_args!("{}", value))),
+            )
         }
     }
 
@@ -1294,7 +1298,7 @@ impl field::Visit for DefaultVisitor<'_> {
             "message" => {
                 // Escape ANSI characters to prevent malicious patterns (e.g., terminal injection attacks)
                 write!(self.writer, "{:?}", Escape(value))
-            },
+            }
             name if name.starts_with("r#") => write!(
                 self.writer,
                 "{}{}{:?}",
@@ -1750,6 +1754,11 @@ impl Display for TimingDisplay {
 #[cfg(test)]
 pub(super) mod test {
     use crate::fmt::{test::MockMakeWriter, time::FormatTime};
+    use alloc::{
+        borrow::ToOwned,
+        format,
+        string::{String, ToString},
+    };
     use tracing::{
         self,
         dispatcher::{set_default, Dispatch},