Quick move to Rust 2018 using cargo fix

Cargo.toml

@@ -13,6 +13,7 @@ repository = "https://github.com/fralalonde/dipstick"
 readme = "README.md"
 keywords = ["metrics", "statsd", "graphite", "timer", "prometheus"]
 license = "MIT/Apache-2.0"
+edition = "2018"
 
 [badges]
 travis-ci = { repository = "fralalonde/dipstick", branch = "master" }

src/bucket/atomic.rs

@@ -1,14 +1,14 @@
 //! Maintain aggregated metrics for deferred reporting,
 
-use bucket::ScoreType::*;
-use bucket::{stats_summary, ScoreType};
-use core::attributes::{Attributes, MetricId, OnFlush, Prefixed, WithAttributes};
-use core::clock::TimeHandle;
-use core::error;
-use core::input::{InputKind, InputMetric, InputScope};
-use core::name::MetricName;
-use core::output::{output_none, Output, OutputDyn, OutputMetric, OutputScope};
-use core::{Flush, MetricValue};
+use crate::bucket::ScoreType::*;
+use crate::bucket::{stats_summary, ScoreType};
+use crate::core::attributes::{Attributes, MetricId, OnFlush, Prefixed, WithAttributes};
+use crate::core::clock::TimeHandle;
+use crate::core::error;
+use crate::core::input::{InputKind, InputMetric, InputScope};
+use crate::core::name::MetricName;
+use crate::core::output::{output_none, Output, OutputDyn, OutputMetric, OutputScope};
+use crate::core::{Flush, MetricValue};
 
 use std::collections::BTreeMap;
 use std::isize;
@@ -445,7 +445,6 @@ fn swap_if(counter: &AtomicIsize, new_value: isize, compare: fn(isize, isize) ->
 mod bench {
 
     use super::*;
-    use test;
 
     #[bench]
     fn update_marker(b: &mut test::Bencher) {
@@ -483,12 +482,12 @@ mod bench {
 }
 
 #[cfg(test)]
-mod test {
+mod mtest {
     use super::*;
-    use bucket::{stats_all, stats_average, stats_summary};
+    use crate::bucket::{stats_all, stats_average, stats_summary};
 
-    use core::clock::{mock_clock_advance, mock_clock_reset};
-    use output::map::StatsMapScope;
+    use crate::core::clock::{mock_clock_advance, mock_clock_reset};
+    use crate::output::map::StatsMapScope;
 
     use std::collections::BTreeMap;
     use std::time::Duration;

src/bucket/mod.rs

@@ -1,8 +1,8 @@
 pub mod atomic;
 
-use core::input::InputKind;
-use core::name::MetricName;
-use core::MetricValue;
+use crate::core::input::InputKind;
+use crate::core::name::MetricName;
+use crate::core::MetricValue;
 
 /// Possibly aggregated scores.
 #[derive(Debug, Clone, Copy)]

src/cache/cache_in.rs

@@ -1,11 +1,11 @@
 //! Metric input scope caching.
 
-use cache::lru_cache as lru;
-use core::attributes::{Attributes, OnFlush, Prefixed, WithAttributes};
-use core::error;
-use core::input::{Input, InputDyn, InputKind, InputMetric, InputScope};
-use core::name::MetricName;
-use core::Flush;
+use crate::cache::lru_cache as lru;
+use crate::core::attributes::{Attributes, OnFlush, Prefixed, WithAttributes};
+use crate::core::error;
+use crate::core::input::{Input, InputDyn, InputKind, InputMetric, InputScope};
+use crate::core::name::MetricName;
+use crate::core::Flush;
 
 use std::sync::Arc;
 

src/cache/cache_out.rs

@@ -1,12 +1,12 @@
 //! Metric output scope caching.
 
-use cache::lru_cache as lru;
-use core::attributes::{Attributes, OnFlush, Prefixed, WithAttributes};
-use core::error;
-use core::input::InputKind;
-use core::name::MetricName;
-use core::output::{Output, OutputDyn, OutputMetric, OutputScope};
-use core::Flush;
+use crate::cache::lru_cache as lru;
+use crate::core::attributes::{Attributes, OnFlush, Prefixed, WithAttributes};
+use crate::core::error;
+use crate::core::input::InputKind;
+use crate::core::name::MetricName;
+use crate::core::output::{Output, OutputDyn, OutputMetric, OutputScope};
+use crate::core::Flush;
 
 use std::sync::Arc;
 

src/core/attributes.rs

@@ -4,19 +4,19 @@ use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 
-use core::name::{MetricName, NameParts};
-use core::scheduler::{Cancel, SCHEDULER};
+use crate::core::name::{MetricName, NameParts};
+use crate::core::scheduler::{Cancel, SCHEDULER};
+use crate::{CancelHandle, Flush, InputMetric, InputScope, MetricValue};
 use std::fmt;
 use std::time::{Duration, Instant};
-use {CancelHandle, Flush, InputMetric, InputScope, MetricValue};
 
 #[cfg(not(feature = "parking_lot"))]
 use std::sync::RwLock;
 
+use crate::Labels;
 #[cfg(feature = "parking_lot")]
 use parking_lot::RwLock;
 use std::ops::Deref;
-use Labels;
 
 /// The actual distribution (random, fixed-cycled, etc) depends on selected sampling method.
 #[derive(Debug, Clone, Copy)]
@@ -338,12 +338,12 @@ pub trait Buffered: WithAttributes {
 
 #[cfg(test)]
 mod test {
-    use core::attributes::*;
-    use core::input::Input;
-    use core::input::*;
-    use core::Flush;
-    use output::map::StatsMap;
-    use StatsMapScope;
+    use crate::core::attributes::*;
+    use crate::core::input::Input;
+    use crate::core::input::*;
+    use crate::core::Flush;
+    use crate::output::map::StatsMap;
+    use crate::StatsMapScope;
 
     #[test]
     fn on_flush() {

src/core/clock.rs

@@ -6,7 +6,7 @@ use std::time::Duration;
 
 use std::time::Instant;
 
-use core::MetricValue;
+use crate::core::MetricValue;
 
 #[derive(Debug, Copy, Clone)]
 /// A handle to the start time of a counter.

src/core/input.rs

@@ -1,8 +1,8 @@
-use core::attributes::MetricId;
-use core::clock::TimeHandle;
-use core::label::Labels;
-use core::name::MetricName;
-use core::{Flush, MetricValue};
+use crate::core::attributes::MetricId;
+use crate::core::clock::TimeHandle;
+use crate::core::label::Labels;
+use crate::core::name::MetricName;
+use crate::core::{Flush, MetricValue};
 
 use std::fmt;
 use std::sync::Arc;

src/core/locking.rs

@@ -2,12 +2,12 @@
 //! This makes all outputs also immediately usable as inputs.
 //! The alternatives are queuing or thread local.
 
-use core::attributes::{Attributes, MetricId, OnFlush, Prefixed, WithAttributes};
-use core::error;
-use core::input::{Input, InputKind, InputMetric, InputScope};
-use core::name::MetricName;
-use core::output::{Output, OutputScope};
-use core::Flush;
+use crate::core::attributes::{Attributes, MetricId, OnFlush, Prefixed, WithAttributes};
+use crate::core::error;
+use crate::core::input::{Input, InputKind, InputMetric, InputScope};
+use crate::core::name::MetricName;
+use crate::core::output::{Output, OutputScope};
+use crate::core::Flush;
 use std::rc::Rc;
 
 use std::ops;

src/core/metrics.rs

@@ -2,9 +2,9 @@
 //! Because the possibly high volume of data, this is pre-set to use aggregation.
 //! This is also kept in a separate module because it is not to be exposed outside of the crate.
 
-use core::attributes::Prefixed;
-use core::input::{Counter, InputScope, Marker};
-use core::proxy::Proxy;
+use crate::core::attributes::Prefixed;
+use crate::core::input::{Counter, InputScope, Marker};
+use crate::core::proxy::Proxy;
 
 metrics! {
     /// Dipstick's own internal metrics.

src/core/mod.rs

@@ -40,7 +40,6 @@ pub mod bench {
     use super::super::bucket::atomic::*;
     use super::clock::*;
     use super::input::*;
-    use test;
 
     #[bench]
     fn get_instant(b: &mut test::Bencher) {

src/core/output.rs

@@ -1,8 +1,8 @@
-use core::input::InputKind;
-use core::label::Labels;
-use core::name::MetricName;
-use core::void::Void;
-use core::{Flush, MetricValue};
+use crate::core::input::InputKind;
+use crate::core::label::Labels;
+use crate::core::name::MetricName;
+use crate::core::void::Void;
+use crate::core::{Flush, MetricValue};
 
 use std::rc::Rc;
 

src/core/pcg32.rs

@@ -5,7 +5,6 @@
 #![allow(clippy::unreadable_literal)]
 
 use std::cell::RefCell;
-use time;
 
 fn seed() -> u64 {
     let seed = 5573589319906701683_u64;

src/core/proxy.rs

@@ -1,11 +1,11 @@
 //! Decouple metric definition from configuration with trait objects.
 
-use core::attributes::{Attributes, MetricId, OnFlush, Prefixed, WithAttributes};
-use core::error;
-use core::input::{InputKind, InputMetric, InputScope};
-use core::name::{MetricName, NameParts};
-use core::void::VOID_INPUT;
-use core::Flush;
+use crate::core::attributes::{Attributes, MetricId, OnFlush, Prefixed, WithAttributes};
+use crate::core::error;
+use crate::core::input::{InputKind, InputMetric, InputScope};
+use crate::core::name::{MetricName, NameParts};
+use crate::core::void::VOID_INPUT;
+use crate::core::Flush;
 
 use std::collections::{BTreeMap, HashMap};
 use std::fmt;
@@ -280,8 +280,7 @@ impl WithAttributes for Proxy {
 mod bench {
 
     use super::*;
-    use bucket::atomic::AtomicBucket;
-    use test;
+    use crate::bucket::atomic::AtomicBucket;
 
     #[bench]
     fn proxy_marker_to_aggregate(b: &mut test::Bencher) {

src/core/scheduler.rs

@@ -1,6 +1,6 @@
 //! Task scheduling facilities.
 
-use core::input::InputScope;
+use crate::core::input::InputScope;
 
 use std::cmp::{max, Ordering};
 use std::collections::BinaryHeap;

src/core/void.rs

@@ -1,7 +1,7 @@
-use core::input::{InputDyn, InputKind, InputScope};
-use core::name::MetricName;
-use core::output::{Output, OutputMetric, OutputScope};
-use core::Flush;
+use crate::core::input::{InputDyn, InputKind, InputScope};
+use crate::core::name::MetricName;
+use crate::core::output::{Output, OutputMetric, OutputScope};
+use crate::core::Flush;
 
 use std::error::Error;
 use std::sync::Arc;

src/lib.rs

@@ -18,21 +18,10 @@ extern crate log;
 
 #[macro_use]
 extern crate lazy_static;
-extern crate atomic_refcell;
-extern crate num;
-
-// FIXME required only for pcg32 seed (for sampling)
-extern crate time;
-
-#[cfg(feature = "crossbeam-channel")]
-extern crate crossbeam_channel;
-
-#[cfg(feature = "parking_lot")]
-extern crate parking_lot;
 
 #[macro_use]
 mod macros;
-pub use macros::*;
+pub use crate::macros::*;
 
 #[cfg(not(feature = "parking_lot"))]
 macro_rules! write_lock {
@@ -63,50 +52,52 @@ macro_rules! read_lock {
 }
 
 mod core;
-pub use core::attributes::{
+pub use crate::core::attributes::{
     Buffered, Buffering, Observe, ObserveWhen, OnFlush, Prefixed, Sampled, Sampling,
 };
-pub use core::clock::TimeHandle;
-pub use core::error::Result;
-pub use core::input::{
+pub use crate::core::clock::TimeHandle;
+pub use crate::core::error::Result;
+pub use crate::core::input::{
     Counter, Gauge, Input, InputDyn, InputKind, InputMetric, InputScope, Level, Marker, Timer,
 };
-pub use core::label::{AppLabel, Labels, ThreadLabel};
-pub use core::locking::LockingOutput;
-pub use core::name::{MetricName, NameParts};
-pub use core::output::{Output, OutputDyn, OutputMetric, OutputScope};
-pub use core::scheduler::{Cancel, CancelHandle, ScheduleFlush};
-pub use core::void::Void;
-pub use core::{Flush, MetricValue};
+pub use crate::core::label::{AppLabel, Labels, ThreadLabel};
+pub use crate::core::locking::LockingOutput;
+pub use crate::core::name::{MetricName, NameParts};
+pub use crate::core::output::{Output, OutputDyn, OutputMetric, OutputScope};
+pub use crate::core::scheduler::{Cancel, CancelHandle, ScheduleFlush};
+pub use crate::core::void::Void;
+pub use crate::core::{Flush, MetricValue};
 
 #[cfg(test)]
-pub use core::clock::{mock_clock_advance, mock_clock_reset};
+pub use crate::core::clock::{mock_clock_advance, mock_clock_reset};
 
-pub use core::proxy::Proxy;
+pub use crate::core::proxy::Proxy;
 
 mod output;
-pub use output::format::{Formatting, LabelOp, LineFormat, LineOp, LineTemplate, SimpleFormat};
-pub use output::graphite::{Graphite, GraphiteMetric, GraphiteScope};
-pub use output::log::{Log, LogScope};
-pub use output::map::StatsMapScope;
-pub use output::statsd::{Statsd, StatsdMetric, StatsdScope};
-pub use output::stream::{Stream, TextScope};
+pub use crate::output::format::{
+    Formatting, LabelOp, LineFormat, LineOp, LineTemplate, SimpleFormat,
+};
+pub use crate::output::graphite::{Graphite, GraphiteMetric, GraphiteScope};
+pub use crate::output::log::{Log, LogScope};
+pub use crate::output::map::StatsMapScope;
+pub use crate::output::statsd::{Statsd, StatsdMetric, StatsdScope};
+pub use crate::output::stream::{Stream, TextScope};
 
 //#[cfg(feature="prometheus")]
-pub use output::prometheus::{Prometheus, PrometheusScope};
+pub use crate::output::prometheus::{Prometheus, PrometheusScope};
 
 mod bucket;
-pub use bucket::atomic::AtomicBucket;
-pub use bucket::{stats_all, stats_average, stats_summary, ScoreType};
+pub use crate::bucket::atomic::AtomicBucket;
+pub use crate::bucket::{stats_all, stats_average, stats_summary, ScoreType};
 
 mod cache;
-pub use cache::cache_in::CachedInput;
-pub use cache::cache_out::CachedOutput;
+pub use crate::cache::cache_in::CachedInput;
+pub use crate::cache::cache_out::CachedOutput;
 
 mod multi;
-pub use multi::multi_in::{MultiInput, MultiInputScope};
-pub use multi::multi_out::{MultiOutput, MultiOutputScope};
+pub use crate::multi::multi_in::{MultiInput, MultiInputScope};
+pub use crate::multi::multi_out::{MultiOutput, MultiOutputScope};
 
 mod queue;
-pub use queue::queue_in::{InputQueue, InputQueueScope, QueuedInput};
-pub use queue::queue_out::{OutputQueue, OutputQueueScope, QueuedOutput};
+pub use crate::queue::queue_in::{InputQueue, InputQueueScope, QueuedInput};
+pub use crate::queue::queue_out::{OutputQueue, OutputQueueScope, QueuedOutput};

src/macros.rs

@@ -52,7 +52,7 @@ macro_rules! labels {
             $(
                 let _ = _map.insert($key.into(), ::std::sync::Arc::new($value.into()));
             )*
-            ::Labels::from(_map)
+            crate::Labels::from(_map)
         }
     };
     () => {
@@ -167,8 +167,8 @@ macro_rules! metrics {
 
 #[cfg(test)]
 mod test {
-    use core::input::*;
-    use core::proxy::Proxy;
+    use crate::core::input::*;
+    use crate::core::proxy::Proxy;
 
     metrics! {TEST: Proxy = "test_prefix" => {
         pub M1: Marker = "failed";

src/multi/multi_in.rs

@@ -1,10 +1,10 @@
 //! Dispatch metrics to multiple sinks.
 
-use core::attributes::{Attributes, MetricId, OnFlush, Prefixed, WithAttributes};
-use core::error;
-use core::input::{Input, InputDyn, InputKind, InputMetric, InputScope};
-use core::name::MetricName;
-use core::Flush;
+use crate::core::attributes::{Attributes, MetricId, OnFlush, Prefixed, WithAttributes};
+use crate::core::error;
+use crate::core::input::{Input, InputDyn, InputKind, InputMetric, InputScope};
+use crate::core::name::MetricName;
+use crate::core::Flush;
 
 use std::sync::Arc;
 

src/multi/multi_out.rs

@@ -1,11 +1,11 @@
 //! Dispatch metrics to multiple sinks.
 
-use core::attributes::{Attributes, OnFlush, Prefixed, WithAttributes};
-use core::error;
-use core::input::InputKind;
-use core::name::MetricName;
-use core::output::{Output, OutputDyn, OutputMetric, OutputScope};
-use core::Flush;
+use crate::core::attributes::{Attributes, OnFlush, Prefixed, WithAttributes};
+use crate::core::error;
+use crate::core::input::InputKind;
+use crate::core::name::MetricName;
+use crate::core::output::{Output, OutputDyn, OutputMetric, OutputScope};
+use crate::core::Flush;
 
 use std::rc::Rc;
 use std::sync::Arc;

src/output/format.rs

@@ -1,7 +1,7 @@
 use self::LineOp::*;
-use core::input::InputKind;
-use core::name::MetricName;
-use core::MetricValue;
+use crate::core::input::InputKind;
+use crate::core::name::MetricName;
+use crate::core::MetricValue;
 
 use std::io;
 use std::sync::Arc;
@@ -110,7 +110,7 @@ impl LineFormat for SimpleFormat {
 #[cfg(test)]
 pub mod test {
     use super::*;
-    use core::label::Labels;
+    use crate::core::label::Labels;
 
     pub struct TestFormat;
 

src/output/graphite.rs

@@ -1,15 +1,15 @@
 //! Send metrics to a graphite server.
 
-use cache::cache_out;
-use core::attributes::{Attributes, Buffered, OnFlush, Prefixed, WithAttributes};
-use core::error;
-use core::input::InputKind;
-use core::metrics;
-use core::name::MetricName;
-use core::output::{Output, OutputMetric, OutputScope};
-use core::{Flush, MetricValue};
-use output::socket::RetrySocket;
-use queue::queue_out;
+use crate::cache::cache_out;
+use crate::core::attributes::{Attributes, Buffered, OnFlush, Prefixed, WithAttributes};
+use crate::core::error;
+use crate::core::input::InputKind;
+use crate::core::metrics;
+use crate::core::name::MetricName;
+use crate::core::output::{Output, OutputMetric, OutputScope};
+use crate::core::{Flush, MetricValue};
+use crate::output::socket::RetrySocket;
+use crate::queue::queue_out;
 
 use std::net::ToSocketAddrs;
 
@@ -204,9 +204,8 @@ impl Drop for GraphiteScope {
 mod bench {
 
     use super::*;
-    use core::attributes::*;
-    use core::input::*;
-    use test;
+    use crate::core::attributes::*;
+    use crate::core::input::*;
 
     #[bench]
     pub fn immediate_graphite(b: &mut test::Bencher) {

src/output/log.rs

@@ -1,11 +1,11 @@
-use cache::cache_in;
-use core::attributes::{Attributes, Buffered, MetricId, OnFlush, Prefixed, WithAttributes};
-use core::error;
-use core::input::{Input, InputKind, InputMetric, InputScope};
-use core::name::MetricName;
-use core::Flush;
-use output::format::{Formatting, LineFormat, SimpleFormat};
-use queue::queue_in;
+use crate::cache::cache_in;
+use crate::core::attributes::{Attributes, Buffered, MetricId, OnFlush, Prefixed, WithAttributes};
+use crate::core::error;
+use crate::core::input::{Input, InputKind, InputMetric, InputScope};
+use crate::core::name::MetricName;
+use crate::core::Flush;
+use crate::output::format::{Formatting, LineFormat, SimpleFormat};
+use crate::queue::queue_in;
 
 use std::sync::Arc;
 
@@ -177,7 +177,7 @@ impl Drop for LogScope {
 
 #[cfg(test)]
 mod test {
-    use core::input::*;
+    use crate::core::input::*;
 
     #[test]
     fn test_to_log() {

src/output/map.rs

@@ -1,14 +1,14 @@
-use core::attributes::{Attributes, MetricId, OnFlush, Prefixed, WithAttributes};
-use core::input::InputKind;
-use core::input::{Input, InputMetric, InputScope};
-use core::name::MetricName;
-use core::{Flush, MetricValue};
+use crate::core::attributes::{Attributes, MetricId, OnFlush, Prefixed, WithAttributes};
+use crate::core::input::InputKind;
+use crate::core::input::{Input, InputMetric, InputScope};
+use crate::core::name::MetricName;
+use crate::core::{Flush, MetricValue};
 
 use std::collections::BTreeMap;
 use std::error::Error;
 
+use crate::{OutputMetric, OutputScope};
 use std::sync::{Arc, RwLock};
-use {OutputMetric, OutputScope};
 
 /// A BTreeMap wrapper to receive metrics or stats values.
 /// Every received value for a metric replaces the previous one (if any).

src/output/prometheus.rs

@@ -1,15 +1,15 @@
 //! Send metrics to a Prometheus server.
 
-use cache::cache_out;
-use core::attributes::{Attributes, Buffered, OnFlush, Prefixed, WithAttributes};
-use core::error;
-use core::input::InputKind;
-use core::label::Labels;
-use core::metrics;
-use core::name::MetricName;
-use core::output::{Output, OutputMetric, OutputScope};
-use core::{Flush, MetricValue};
-use queue::queue_out;
+use crate::cache::cache_out;
+use crate::core::attributes::{Attributes, Buffered, OnFlush, Prefixed, WithAttributes};
+use crate::core::error;
+use crate::core::input::InputKind;
+use crate::core::label::Labels;
+use crate::core::metrics;
+use crate::core::name::MetricName;
+use crate::core::output::{Output, OutputMetric, OutputScope};
+use crate::core::{Flush, MetricValue};
+use crate::queue::queue_out;
 
 use std::cell::{RefCell, RefMut};
 use std::rc::Rc;
@@ -204,9 +204,8 @@ impl Drop for PrometheusScope {
 mod bench {
 
     use super::*;
-    use core::attributes::*;
-    use core::input::*;
-    use test;
+    use crate::core::attributes::*;
+    use crate::core::input::*;
 
     #[bench]
     pub fn immediate_prometheus(b: &mut test::Bencher) {

src/output/statsd.rs

@@ -1,17 +1,17 @@
 //! Send metrics to a statsd server.
 
-use cache::cache_out;
-use core::attributes::{
+use crate::cache::cache_out;
+use crate::core::attributes::{
     Attributes, Buffered, OnFlush, Prefixed, Sampled, Sampling, WithAttributes,
 };
-use core::error;
-use core::input::InputKind;
-use core::metrics;
-use core::name::MetricName;
-use core::output::{Output, OutputMetric, OutputScope};
-use core::pcg32;
-use core::{Flush, MetricValue};
-use queue::queue_out;
+use crate::core::error;
+use crate::core::input::InputKind;
+use crate::core::metrics;
+use crate::core::name::MetricName;
+use crate::core::output::{Output, OutputMetric, OutputScope};
+use crate::core::pcg32;
+use crate::core::{Flush, MetricValue};
+use crate::queue::queue_out;
 
 use std::cell::{RefCell, RefMut};
 use std::net::ToSocketAddrs;
@@ -266,9 +266,8 @@ impl Drop for StatsdScope {
 mod bench {
 
     use super::*;
-    use core::attributes::*;
-    use core::input::*;
-    use test;
+    use crate::core::attributes::*;
+    use crate::core::input::*;
 
     #[bench]
     pub fn immediate_statsd(b: &mut test::Bencher) {

src/output/stream.rs

@@ -2,16 +2,16 @@
 
 // TODO parameterize templates
 
-use core::attributes::{Attributes, Buffered, OnFlush, Prefixed, WithAttributes};
-use core::error;
-use core::input::InputKind;
-use core::name::MetricName;
-use core::output::{Output, OutputMetric, OutputScope};
-use core::Flush;
+use crate::core::attributes::{Attributes, Buffered, OnFlush, Prefixed, WithAttributes};
+use crate::core::error;
+use crate::core::input::InputKind;
+use crate::core::name::MetricName;
+use crate::core::output::{Output, OutputMetric, OutputScope};
+use crate::core::Flush;
 
-use cache::cache_out;
-use output::format::{Formatting, LineFormat, SimpleFormat};
-use queue::queue_out;
+use crate::cache::cache_out;
+use crate::output::format::{Formatting, LineFormat, SimpleFormat};
+use crate::queue::queue_out;
 
 use std::cell::RefCell;
 use std::fs::{File, OpenOptions};
@@ -222,7 +222,7 @@ impl<W: Write + Send + Sync + 'static> Drop for TextScope<W> {
 #[cfg(test)]
 mod test {
     use super::*;
-    use core::input::InputKind;
+    use crate::core::input::InputKind;
     use std::io;
 
     #[test]

src/queue/queue_in.rs

@@ -2,14 +2,14 @@
 //! Metrics definitions are still synchronous.
 //! If queue size is exceeded, calling code reverts to blocking.
 
-use cache::cache_in::CachedInput;
-use core::attributes::{Attributes, MetricId, OnFlush, Prefixed, WithAttributes};
-use core::error;
-use core::input::{Input, InputDyn, InputKind, InputMetric, InputScope};
-use core::label::Labels;
-use core::metrics;
-use core::name::MetricName;
-use core::{Flush, MetricValue};
+use crate::cache::cache_in::CachedInput;
+use crate::core::attributes::{Attributes, MetricId, OnFlush, Prefixed, WithAttributes};
+use crate::core::error;
+use crate::core::input::{Input, InputDyn, InputKind, InputMetric, InputScope};
+use crate::core::label::Labels;
+use crate::core::metrics;
+use crate::core::name::MetricName;
+use crate::core::{Flush, MetricValue};
 
 #[cfg(not(feature = "crossbeam-channel"))]
 use std::sync::mpsc;

src/queue/queue_out.rs

@@ -2,15 +2,15 @@
 //! RawMetrics definitions are still synchronous.
 //! If queue size is exceeded, calling code reverts to blocking.
 
-use cache::cache_in;
-use core::attributes::{Attributes, MetricId, OnFlush, Prefixed, WithAttributes};
-use core::error;
-use core::input::{Input, InputKind, InputMetric, InputScope};
-use core::label::Labels;
-use core::metrics;
-use core::name::MetricName;
-use core::output::{Output, OutputDyn, OutputMetric, OutputScope};
-use core::{Flush, MetricValue};
+use crate::cache::cache_in;
+use crate::core::attributes::{Attributes, MetricId, OnFlush, Prefixed, WithAttributes};
+use crate::core::error;
+use crate::core::input::{Input, InputKind, InputMetric, InputScope};
+use crate::core::label::Labels;
+use crate::core::metrics;
+use crate::core::name::MetricName;
+use crate::core::output::{Output, OutputDyn, OutputMetric, OutputScope};
+use crate::core::{Flush, MetricValue};
 
 use std::fmt;
 use std::ops;