chore: reformatting imports (vectordotdev#10496)

With

```
imports_granularity = "Crate"
group_imports = "StdExternalCrate"
```

Both of these are unstable though so I just left them commented in
rustfmt.toml.

Signed-off-by: Jesse Szwedko <[email protected]>

.rustfmt.toml

@@ -1,5 +1,7 @@
 # Using defaults.
 # Not stable yet.
 # indent_style = "Block"
+# group_imports = "StdExternalCrate"
+# imports_granularity = "Crate"
 reorder_imports = true
 edition = "2021"

benches/batch.rs

@@ -1,7 +1,8 @@
+use std::{convert::Infallible, time::Duration};
+
 use bytes::Bytes;
 use criterion::{criterion_group, Criterion, SamplingMode, Throughput};
 use futures::{future, stream, SinkExt, StreamExt};
-use std::{convert::Infallible, time::Duration};
 use vector::{
     sinks::util::{
         batch::{Batch, BatchConfig, BatchError, BatchSettings, BatchSize, PushResult},

benches/distribution_statistic.rs

@@ -1,11 +1,9 @@
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
-
-use rand::distributions::Distribution;
-use rand::distributions::Uniform;
-use rand::seq::SliceRandom;
-
-use vector::event::metric::Sample;
-use vector::sinks::util::statistic::DistributionStatistic;
+use rand::{
+    distributions::{Distribution, Uniform},
+    seq::SliceRandom,
+};
+use vector::{event::metric::Sample, sinks::util::statistic::DistributionStatistic};
 
 fn generate_samples(mut size: u32, max_bin_count: u32) -> Vec<Sample> {
     let mut rng = rand::thread_rng();

benches/dnstap/mod.rs

@@ -1,7 +1,9 @@
 use bytes::Bytes;
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput};
-use vector::event::Event;
-use vector::sources::dnstap::{schema::DnstapEventSchema, DnstapParser};
+use vector::{
+    event::Event,
+    sources::dnstap::{schema::DnstapEventSchema, DnstapParser},
+};
 
 fn benchmark_query_parsing(c: &mut Criterion) {
     let mut event = Event::new_empty_log();

benches/enrichment_tables_file.rs

@@ -1,7 +1,8 @@
+use std::{collections::BTreeMap, time::SystemTime};
+
 use chrono::prelude::*;
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use enrichment::Case;
-use std::{collections::BTreeMap, time::SystemTime};
 use vector::enrichment_tables::{file::File, Condition, Table};
 use vrl::Value;
 

benches/files.rs

@@ -1,8 +1,8 @@
+use std::{convert::TryInto, path::PathBuf};
+
 use bytes::Bytes;
 use criterion::{criterion_group, BatchSize, Criterion, SamplingMode, Throughput};
 use futures::{stream, SinkExt, StreamExt};
-use std::convert::TryInto;
-use std::path::PathBuf;
 use tempfile::tempdir;
 use tokio::fs::OpenOptions;
 use tokio_util::codec::{BytesCodec, FramedWrite};

benches/http.rs

@@ -1,10 +1,11 @@
+use std::net::SocketAddr;
+
 use criterion::{criterion_group, BatchSize, BenchmarkId, Criterion, SamplingMode, Throughput};
 use futures::TryFutureExt;
 use hyper::{
     service::{make_service_fn, service_fn},
     Body, Response, Server,
 };
-use std::net::SocketAddr;
 use tokio::runtime::Runtime;
 use vector::{
     config, sinks,

benches/loki.rs

@@ -1,7 +1,7 @@
-use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use std::convert::TryFrom;
-use vector::sinks::loki::valid_label_name;
-use vector::template::Template;
+
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use vector::{sinks::loki::valid_label_name, template::Template};
 
 const VALID: [&str; 4] = ["name", " name ", "bee_bop", "a09b"];
 const INVALID: [&str; 4] = ["0ab", "*", "", " "];

benches/lua.rs

@@ -1,8 +1,9 @@
+use std::pin::Pin;
+
 use criterion::{criterion_group, BatchSize, Criterion, Throughput};
 use futures::{stream, SinkExt, Stream, StreamExt};
 use indexmap::IndexMap;
 use indoc::indoc;
-use std::pin::Pin;
 use transforms::lua::v2::LuaConfig;
 use vector::{
     config::{TransformConfig, TransformContext},

benches/regex.rs

@@ -1,8 +1,6 @@
 use criterion::{criterion_group, BatchSize, Criterion, Throughput};
-
 use rand::{rngs::SmallRng, thread_rng, Rng, SeedableRng};
 use rand_distr::{Alphanumeric, Distribution, Uniform};
-
 use vector::{
     config::{TransformConfig, TransformContext},
     event::Event,

benches/remap.rs

@@ -1,8 +1,9 @@
+use std::collections::HashMap;
+
 use chrono::{DateTime, Utc};
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use indexmap::IndexMap;
 use shared::TimeZone;
-use std::collections::HashMap;
 use vector::{
     event::{Event, Value},
     transforms::{

benches/template.rs

@@ -1,8 +1,7 @@
-use criterion::{criterion_group, BatchSize, Criterion};
-
-use chrono::Utc;
 use std::convert::TryFrom;
 
+use chrono::Utc;
+use criterion::{criterion_group, BatchSize, Criterion};
 use vector::{config::log_schema, event::Event};
 
 fn bench_elasticsearch_index(c: &mut Criterion) {

benches/topology.rs

@@ -2,7 +2,6 @@ use criterion::{criterion_group, BatchSize, Criterion, SamplingMode, Throughput}
 use futures::{future, stream, StreamExt};
 use indoc::indoc;
 use rand::{rngs::SmallRng, thread_rng, Rng, SeedableRng};
-
 use vector::{
     config, sinks, sources,
     test_util::{

benches/transform/common.rs

@@ -1,12 +1,13 @@
 //! A common suite of structs, functions et al that are useful for the
 //! benchmarking of vector transforms.
-use futures::task::noop_waker;
-use futures::Stream;
-use std::num::NonZeroUsize;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use vector::conditions::Condition;
-use vector::event::Event;
+use std::{
+    num::NonZeroUsize,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use futures::{task::noop_waker, Stream};
+use vector::{conditions::Condition, event::Event};
 
 // == Conditions ==
 

benches/transform/dedupe.rs

@@ -1,15 +1,15 @@
-use crate::common::{consume, FixedLogStream};
 use core::fmt;
-use criterion::BenchmarkId;
+use std::{num::NonZeroUsize, time::Duration};
+
 use criterion::{
-    criterion_group, measurement::WallTime, BatchSize, BenchmarkGroup, Criterion, SamplingMode,
-    Throughput,
+    criterion_group, measurement::WallTime, BatchSize, BenchmarkGroup, BenchmarkId, Criterion,
+    SamplingMode, Throughput,
 };
-use std::num::NonZeroUsize;
-use std::time::Duration;
 use vector::transforms::dedupe::{CacheConfig, Dedupe, DedupeConfig, FieldMatchConfig};
 use vector_core::transform::Transform;
 
+use crate::common::{consume, FixedLogStream};
+
 #[derive(Debug)]
 struct Param {
     slug: &'static str,

benches/transform/filter.rs

@@ -1,15 +1,17 @@
-use crate::common::AlwaysFail;
-use crate::common::AlwaysPass;
+use std::time::Duration;
+
 use criterion::{
     criterion_group, measurement::WallTime, BatchSize, BenchmarkGroup, Criterion, SamplingMode,
     Throughput,
 };
-use std::time::Duration;
-use vector::conditions::Condition;
-use vector::transforms::filter::Filter;
-use vector::transforms::FunctionTransform;
+use vector::{
+    conditions::Condition,
+    transforms::{filter::Filter, FunctionTransform},
+};
 use vector_core::event::{Event, LogEvent};
 
+use crate::common::{AlwaysFail, AlwaysPass};
+
 #[derive(Debug)]
 struct Payload {
     filter: Filter,

benches/transform/reduce.rs

@@ -1,16 +1,16 @@
-use crate::common::{consume, FixedLogStream};
 use core::fmt;
-use criterion::BenchmarkId;
+use std::{num::NonZeroUsize, time::Duration};
+
 use criterion::{
-    criterion_group, measurement::WallTime, BatchSize, BenchmarkGroup, Criterion, SamplingMode,
-    Throughput,
+    criterion_group, measurement::WallTime, BatchSize, BenchmarkGroup, BenchmarkId, Criterion,
+    SamplingMode, Throughput,
 };
 use indexmap::IndexMap;
-use std::num::NonZeroUsize;
-use std::time::Duration;
 use vector::transforms::reduce::{Reduce, ReduceConfig};
 use vector_core::transform::Transform;
 
+use crate::common::{consume, FixedLogStream};
+
 #[derive(Debug)]
 struct Param {
     slug: &'static str,

lib/datadog/filter/src/filter.rs

@@ -1,7 +1,9 @@
-use super::{Matcher, Run};
+use std::fmt::Debug;
+
 use datadog_search_syntax::{Comparison, ComparisonValue, Field};
 use dyn_clone::{clone_trait_object, DynClone};
-use std::fmt::Debug;
+
+use super::{Matcher, Run};
 
 /// A `Filter` is a generic type that contains methods that are invoked by the `build_filter`
 /// function. Each method returns a heap-allocated `Matcher<V>` (typically a closure) containing

lib/datadog/filter/src/matcher.rs

@@ -1,7 +1,9 @@
-use crate::{Filter, Resolver};
+use std::{fmt, marker::PhantomData};
+
 use datadog_search_syntax::{BooleanType, QueryNode};
 use dyn_clone::{clone_trait_object, DynClone};
-use std::{fmt, marker::PhantomData};
+
+use crate::{Filter, Resolver};
 
 /// A `Matcher` is a type that contains a "run" method which returns true/false if value `V`
 /// matches a filter.

lib/datadog/grok/src/filters/array.rs

@@ -1,22 +1,23 @@
-use crate::grok_filter::GrokFilter;
-use crate::{
-    ast::{Function, FunctionArgument},
-    parse_grok_rules::Error as GrokStaticError,
-};
+use std::convert::TryFrom;
+
 use bytes::Bytes;
 use nom::{
     branch::alt,
     bytes::complete::{tag, take, take_until},
     character::complete::char,
-    combinator::cut,
-    combinator::map,
+    combinator::{cut, map},
     multi::separated_list0,
     sequence::{preceded, terminated},
     IResult,
 };
-use std::convert::TryFrom;
 use vrl_compiler::Value;
 
+use crate::{
+    ast::{Function, FunctionArgument},
+    grok_filter::GrokFilter,
+    parse_grok_rules::Error as GrokStaticError,
+};
+
 pub fn filter_from_function(f: &Function) -> Result<GrokFilter, GrokStaticError> {
     let args = f.args.as_ref();
     let args_len = args.map_or(0, |args| args.len());

lib/datadog/grok/src/filters/keyvalue.rs

@@ -1,9 +1,5 @@
-use crate::{
-    ast::{Function, FunctionArgument},
-    grok_filter::GrokFilter,
-    parse_grok::Error as GrokRuntimeError,
-    parse_grok_rules::Error as GrokStaticError,
-};
+use std::fmt::Formatter;
+
 use bytes::Bytes;
 use nom::{
     self,
@@ -19,9 +15,15 @@ use nom::{
 use nom_regex::str::re_find;
 use ordered_float::NotNan;
 use regex::Regex;
-use std::fmt::Formatter;
 use vrl_compiler::Value;
 
+use crate::{
+    ast::{Function, FunctionArgument},
+    grok_filter::GrokFilter,
+    parse_grok::Error as GrokRuntimeError,
+    parse_grok_rules::Error as GrokStaticError,
+};
+
 pub fn filter_from_function(f: &Function) -> Result<GrokFilter, GrokStaticError> {
     {
         let args_len = f.args.as_ref().map_or(0, |args| args.len());
@@ -362,9 +364,10 @@ fn parse_key<'a>(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use regex::Regex;
 
+    use super::*;
+
     #[test]
     fn test_parse_keyvalue() {
         // DD examples from https://docs.datadoghq.com/logs/log_configuration/parsing/?tab=filters#key-value-or-logfmt

lib/datadog/grok/src/grok_filter.rs

@@ -1,14 +1,16 @@
+use std::{convert::TryFrom, string::ToString};
+
+use ordered_float::NotNan;
+use strum_macros::Display;
+use vrl_compiler::Value;
+
 use crate::{
     ast::{Function, FunctionArgument},
     filters::{array, keyvalue, keyvalue::KeyValueFilter},
     matchers::date::{apply_date_filter, DateFilter},
     parse_grok::Error as GrokRuntimeError,
     parse_grok_rules::Error as GrokStaticError,
 };
-use ordered_float::NotNan;
-use std::{convert::TryFrom, string::ToString};
-use strum_macros::Display;
-use vrl_compiler::Value;
 
 #[derive(Debug, Display, Clone)]
 pub enum GrokFilter {

lib/datadog/grok/src/lexer.rs

@@ -1,6 +1,7 @@
-use ordered_float::NotNan;
 use std::{iter::Peekable, str::CharIndices};
 
+use ordered_float::NotNan;
+
 pub type Tok<'input> = Token<&'input str>;
 pub type SpannedResult<'input, Loc> = Result<Spanned<'input, Loc>, Error>;
 pub type Spanned<'input, Loc> = (Loc, Tok<'input>, Loc);

lib/datadog/grok/src/matchers/date.rs

@@ -1,11 +1,13 @@
-use crate::parse_grok::Error as GrokRuntimeError;
+use std::fmt::Formatter;
+
 use chrono::{DateTime, FixedOffset, NaiveDate, NaiveDateTime, NaiveTime, Offset, TimeZone, Utc};
 use chrono_tz::{Tz, UTC};
 use peeking_take_while::PeekableExt;
 use regex::Regex;
-use std::fmt::Formatter;
 use vrl_compiler::Value;
 
+use crate::parse_grok::Error as GrokRuntimeError;
+
 /// converts Joda time format to strptime format
 pub fn convert_time_format(format: &str) -> std::result::Result<String, String> {
     let mut time_format = String::new();