Improve import style

Author: CAD97

.github/workflows/ci.yaml

@@ -49,10 +49,10 @@ jobs:
         uses: actions/checkout@v3
 
       # Pinned version to avoid unrelated breakage in PRs
-      - name: Install 1.59 toolchain
+      - name: Install nighly (2022-04-02) toolchain
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.59
+          toolchain: nightly-2022-04-02
           profile: minimal
           components: rustfmt
           override: true

Cargo.toml

@@ -23,6 +23,8 @@ sorted-vec = "0.7.0"
 thiserror = "1.0.30"
 thread_local = "1.1.4"
 
+# The only place tracing is used not in tests is for STATIC_MAX_LEVEL
+# Everything else just uses tracing-core; is this worth making optional?
 [dependencies.tracing]
 version = "0.1.32"
 default-features = false

examples/use_log_crate.rs

@@ -8,7 +8,7 @@ mod mock;
 
 use {
     crate::mock::MockLayer,
-    tracing::Level,
+    tracing_core::Level,
     tracing_filter::{legacy::Filter, FilterLayer},
     tracing_subscriber::prelude::*,
 };

rustfmt.toml

@@ -5,3 +5,5 @@ match_block_trailing_comma = true
 merge_derives = false
 newline_style = "Unix"
 use_field_init_shorthand = true
+
+imports_granularity = "One"

src/layer.rs

@@ -1,6 +1,6 @@
 use {
     crate::Filter,
-    tracing_core::{Metadata, Subscriber},
+    tracing_core::{span, Event, Interest, LevelFilter, Metadata, Subscriber},
     tracing_subscriber::layer::{Context, Layer},
 };
 
@@ -23,49 +23,39 @@ impl<F> FilterLayer<F> {
 }
 
 impl<S: Subscriber, F: 'static + Filter<S>> Layer<S> for FilterLayer<F> {
-    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> tracing_core::Interest {
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
         self.filter.callsite_enabled(metadata)
     }
 
     fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
         self.filter.enabled(metadata, &ctx)
     }
 
-    fn on_new_span(
-        &self,
-        attrs: &tracing_core::span::Attributes<'_>,
-        id: &tracing_core::span::Id,
-        ctx: Context<'_, S>,
-    ) {
+    fn on_new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
         self.filter.on_new_span(attrs, id, ctx);
     }
 
-    fn max_level_hint(&self) -> Option<tracing_core::LevelFilter> {
+    fn max_level_hint(&self) -> Option<LevelFilter> {
         self.filter.max_level_hint()
     }
 
-    fn on_record(
-        &self,
-        id: &tracing_core::span::Id,
-        values: &tracing_core::span::Record<'_>,
-        ctx: Context<'_, S>,
-    ) {
+    fn on_record(&self, id: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
         self.filter.on_record(id, values, ctx)
     }
 
-    fn on_event(&self, _event: &tracing::Event<'_>, _ctx: Context<'_, S>) {
+    fn on_event(&self, _event: &Event<'_>, _ctx: Context<'_, S>) {
         // FUTURE: allow event filtering; tokio-rs/tracing#2008
     }
 
-    fn on_enter(&self, id: &tracing_core::span::Id, ctx: Context<'_, S>) {
+    fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
         self.filter.on_enter(id, ctx)
     }
 
-    fn on_exit(&self, id: &tracing_core::span::Id, ctx: Context<'_, S>) {
+    fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
         self.filter.on_exit(id, ctx)
     }
 
-    fn on_close(&self, id: tracing_core::span::Id, ctx: Context<'_, S>) {
+    fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
         self.filter.on_close(id, ctx)
     }
 }

src/legacy/directive.rs

@@ -4,8 +4,7 @@ use {
     compact_str::CompactStr,
     sorted_vec::SortedSet,
     std::{cmp::Ordering, collections::HashMap, fmt},
-    tracing::Metadata,
-    tracing_core::LevelFilter,
+    tracing_core::{LevelFilter, Metadata},
 };
 
 #[derive(Debug, PartialEq, Eq)]
@@ -182,7 +181,7 @@ impl DynamicDirective {
 }
 
 impl Match for StaticDirective {
-    fn cares_about(&self, metadata: &tracing::Metadata<'_>) -> bool {
+    fn cares_about(&self, metadata: &Metadata<'_>) -> bool {
         // Does this directive have a target filter, and does it match the
         // metadata's target?
         if let Some(ref target) = self.target {

src/legacy/matcher.rs

@@ -8,8 +8,7 @@ use {
         fmt,
         sync::atomic::{AtomicBool, Ordering::*},
     },
-    tracing::{field::Visit, Metadata},
-    tracing_core::{span, Field, LevelFilter},
+    tracing_core::{field::Visit, span, Field, LevelFilter, Metadata},
 };
 
 #[derive(Debug)]

src/legacy/mod.rs

@@ -8,8 +8,7 @@ use {
     miette::ErrReport,
     std::{cell::RefCell, collections::HashMap, env, ffi::OsStr, fmt, sync::RwLock},
     thread_local::ThreadLocal,
-    tracing::{Metadata, Subscriber},
-    tracing_core::{callsite, span, Interest, LevelFilter},
+    tracing_core::{callsite, span, Interest, LevelFilter, Metadata, Subscriber},
     tracing_subscriber::layer::Context,
 };
 

src/simple/mod.rs

@@ -6,7 +6,8 @@ use {
     miette::ErrReport,
     sorted_vec::ReverseSortedVec,
     std::{borrow::Cow, cmp, env, ffi::OsStr, fmt},
-    tracing_core::{Interest, LevelFilter},
+    tracing_core::{Interest, LevelFilter, Metadata},
+    tracing_subscriber::layer::Context,
 };
 
 mod parse;
@@ -160,7 +161,7 @@ impl Filter {
         self
     }
 
-    fn is_enabled(&self, metadata: &tracing::Metadata<'_>) -> bool {
+    fn is_enabled(&self, metadata: &Metadata<'_>) -> bool {
         // this code is adapted directly from env_logger 0.9.0
         // env_logger is licensed under MIT OR Apache-2.0
 
@@ -183,19 +184,15 @@ impl Filter {
 }
 
 impl<S> crate::Filter<S> for Filter {
-    fn callsite_enabled(&self, metadata: &tracing::Metadata<'_>) -> tracing_core::Interest {
+    fn callsite_enabled(&self, metadata: &Metadata<'_>) -> Interest {
         if self.is_enabled(metadata) {
             Interest::always()
         } else {
             Interest::never()
         }
     }
 
-    fn enabled(
-        &self,
-        metadata: &tracing::Metadata<'_>,
-        _ctx: &tracing_subscriber::layer::Context<'_, S>,
-    ) -> bool {
+    fn enabled(&self, metadata: &Metadata<'_>, _ctx: &Context<'_, S>) -> bool {
         self.is_enabled(metadata)
     }
 }

tests/legacy_filters.rs

@@ -3,7 +3,8 @@
 
 use {
     crate::mock::{self, MockLayer},
-    tracing::{subscriber::with_default, Level},
+    tracing::subscriber::with_default,
+    tracing_core::Level,
     tracing_filter::{legacy::Filter, FilterLayer},
     tracing_subscriber::prelude::*,
 };

tests/mock.rs

@@ -1,12 +1,14 @@
-use std::{
-    sync::{
-        atomic::{AtomicU8, Ordering},
-        Arc,
+use {
+    std::{
+        sync::{
+            atomic::{AtomicU8, Ordering},
+            Arc,
+        },
+        thread,
     },
-    thread,
+    tracing_core::{span, Event, Subscriber},
+    tracing_subscriber::{layer::Context, Layer},
 };
-use tracing::Subscriber;
-use tracing_subscriber::Layer;
 
 pub fn subscribe() -> MockLayer {
     MockLayer {
@@ -29,18 +31,14 @@ pub struct MockLayer {
 }
 
 impl<S: Subscriber> Layer<S> for MockLayer {
-    fn on_event(&self, event: &tracing::Event<'_>, ctx: tracing_subscriber::layer::Context<'_, S>) {
+    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
         let _ = (event, ctx);
         if self.expect_event.fetch_sub(1, Ordering::SeqCst) == 0 {
             panic!("[{}] received unexpected event", self.name);
         }
     }
 
-    fn on_enter(
-        &self,
-        id: &tracing_core::span::Id,
-        ctx: tracing_subscriber::layer::Context<'_, S>,
-    ) {
+    fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
         let _ = (id, ctx);
         if self.expect_span.fetch_sub(1, Ordering::SeqCst) == 0 {
             panic!("[{}] received unexpected span", self.name);

tests/simple_filters.rs

@@ -1,10 +1,12 @@
 //! These tests are adapted directly from env_logger 0.9.0
 //! env_logger is licensed under MIT OR Apache-2.0
 
-use crate::mock::{self, MockLayer};
-use tracing::{level_filters::LevelFilter, subscriber::with_default, Level};
-use tracing_filter::{simple::Filter, FilterLayer};
-use tracing_subscriber::layer::SubscriberExt;
+use {
+    crate::mock::{self, MockLayer},
+    tracing::{level_filters::LevelFilter, subscriber::with_default, Level},
+    tracing_filter::{simple::Filter, FilterLayer},
+    tracing_subscriber::layer::SubscriberExt,
+};
 
 fn test(filter: Filter, f: impl FnOnce(&MockLayer)) {
     let filter = FilterLayer::new(filter);