chore(deps): Bump Rust to 1.75.0 (vectordotdev#19518)

* bump rust ver

* clippy clip clip clip lib

* clippy clip cliperoo src

* windowwwwwwwwwwwwwwwwwwwwwwwwwwwwwws

* just allow it

* add back panic expectation

* fix issues with lint on ConfigTargetPath

Tiltfile

@@ -7,7 +7,7 @@ load('ext://helm_resource', 'helm_resource', 'helm_repo')
 docker_build(
     ref='timberio/vector',
     context='.',
-    build_args={'RUST_VERSION': '1.72.1'},
+    build_args={'RUST_VERSION': '1.75.0'},
     dockerfile='tilt/Dockerfile'
     )
 

lib/codecs/Cargo.toml

@@ -16,7 +16,7 @@ chrono = { version = "0.4", default-features = false }
 csv-core = { version = "0.1.10", default-features = false }
 derivative = { version = "2", default-features = false }
 dyn-clone = { version = "1", default-features = false }
-lookup = { package = "vector-lookup", path = "../vector-lookup", default-features = false }
+lookup = { package = "vector-lookup", path = "../vector-lookup", default-features = false, features = ["test"] }
 memchr = { version = "2", default-features = false }
 once_cell = { version = "1.19", default-features = false }
 ordered-float = { version = "4.2.0", default-features = false }

lib/codecs/src/encoding/format/csv.rs

@@ -318,7 +318,7 @@ mod tests {
         let mut tree = ObjectMap::new();
 
         for (field_name, field_value) in field_data.into_iter() {
-            let field = ConfigTargetPath::try_from(field_name).unwrap();
+            let field = field_name.into();
             fields.push(field);
 
             let field_value = Value::from(field_value.to_string());
@@ -351,15 +351,15 @@ mod tests {
             "other" => Value::from("data"),
         }));
         let fields = vec![
-            ConfigTargetPath::try_from("foo".to_string()).unwrap(),
-            ConfigTargetPath::try_from("int".to_string()).unwrap(),
-            ConfigTargetPath::try_from("comma".to_string()).unwrap(),
-            ConfigTargetPath::try_from("float".to_string()).unwrap(),
-            ConfigTargetPath::try_from("missing".to_string()).unwrap(),
-            ConfigTargetPath::try_from("space".to_string()).unwrap(),
-            ConfigTargetPath::try_from("time".to_string()).unwrap(),
-            ConfigTargetPath::try_from("quote".to_string()).unwrap(),
-            ConfigTargetPath::try_from("bool".to_string()).unwrap(),
+            "foo".into(),
+            "int".into(),
+            "comma".into(),
+            "float".into(),
+            "missing".into(),
+            "space".into(),
+            "time".into(),
+            "quote".into(),
+            "bool".into(),
         ];
 
         let opts = CsvSerializerOptions {
@@ -388,11 +388,11 @@ mod tests {
             "field5" => Value::from("value5"),
         }));
         let fields = vec![
-            ConfigTargetPath::try_from("field1".to_string()).unwrap(),
-            ConfigTargetPath::try_from("field5".to_string()).unwrap(),
-            ConfigTargetPath::try_from("field5".to_string()).unwrap(),
-            ConfigTargetPath::try_from("field3".to_string()).unwrap(),
-            ConfigTargetPath::try_from("field2".to_string()).unwrap(),
+            "field1".into(),
+            "field5".into(),
+            "field5".into(),
+            "field3".into(),
+            "field2".into(),
         ];
         let opts = CsvSerializerOptions {
             fields,
@@ -419,10 +419,10 @@ mod tests {
             "field4" => Value::from("baz,bas"),
         }));
         let fields = vec![
-            ConfigTargetPath::try_from("field1".to_string()).unwrap(),
-            ConfigTargetPath::try_from("field2".to_string()).unwrap(),
-            ConfigTargetPath::try_from("field3".to_string()).unwrap(),
-            ConfigTargetPath::try_from("field4".to_string()).unwrap(),
+            "field1".into(),
+            "field2".into(),
+            "field3".into(),
+            "field4".into(),
         ];
 
         let mut default_bytes = BytesMut::new();

lib/dnsmsg-parser/src/dns_message_parser.rs

@@ -131,7 +131,7 @@ impl DnsMessageParser {
             .collect::<Vec<ZoneInfo>>();
 
         zones
-            .get(0)
+            .first()
             .cloned()
             .ok_or_else(|| DnsMessageParserError::SimpleError {
                 cause: format!(

lib/prometheus-parser/src/lib.rs

@@ -282,7 +282,7 @@ impl MetricGroup {
 }
 
 fn matching_group<T: Default>(values: &mut MetricMap<T>, group: GroupKey) -> &mut T {
-    values.entry(group).or_insert_with(T::default)
+    values.entry(group).or_default()
 }
 
 /// Parse the given text input, and group the result into higher-level

lib/vector-buffers/src/config.rs

@@ -425,19 +425,19 @@ mod test {
 
     #[test]
     fn parse_partial_invalid_keys() {
-        let source = r#"max_size: 100
+        let source = r"max_size: 100
 max_events: 42
-"#;
+";
         let error = serde_yaml::from_str::<BufferConfig>(source).unwrap_err();
         assert_eq!(error.to_string(), BUFFER_CONFIG_NO_MATCH_ERR);
     }
 
     #[test]
     fn parse_without_type_tag() {
         check_single_stage(
-            r#"
+            r"
           max_events: 100
-          "#,
+          ",
             BufferType::Memory {
                 max_events: NonZeroUsize::new(100).unwrap(),
                 when_full: WhenFull::Block,
@@ -448,11 +448,11 @@ max_events: 42
     #[test]
     fn parse_multiple_stages() {
         check_multiple_stages(
-            r#"
+            r"
           - max_events: 42
           - max_events: 100
             when_full: drop_newest
-          "#,
+          ",
             &[
                 BufferType::Memory {
                     max_events: NonZeroUsize::new(42).unwrap(),
@@ -469,53 +469,53 @@ max_events: 42
     #[test]
     fn ensure_field_defaults_for_all_types() {
         check_single_stage(
-            r#"
+            r"
           type: memory
-          "#,
+          ",
             BufferType::Memory {
                 max_events: NonZeroUsize::new(500).unwrap(),
                 when_full: WhenFull::Block,
             },
         );
 
         check_single_stage(
-            r#"
+            r"
           type: memory
           max_events: 100
-          "#,
+          ",
             BufferType::Memory {
                 max_events: NonZeroUsize::new(100).unwrap(),
                 when_full: WhenFull::Block,
             },
         );
 
         check_single_stage(
-            r#"
+            r"
           type: memory
           when_full: drop_newest
-          "#,
+          ",
             BufferType::Memory {
                 max_events: NonZeroUsize::new(500).unwrap(),
                 when_full: WhenFull::DropNewest,
             },
         );
 
         check_single_stage(
-            r#"
+            r"
           type: memory
           when_full: overflow
-          "#,
+          ",
             BufferType::Memory {
                 max_events: NonZeroUsize::new(500).unwrap(),
                 when_full: WhenFull::Overflow,
             },
         );
 
         check_single_stage(
-            r#"
+            r"
           type: disk
           max_size: 1024
-          "#,
+          ",
             BufferType::DiskV2 {
                 max_size: NonZeroU64::new(1024).unwrap(),
                 when_full: WhenFull::Block,

lib/vector-buffers/src/encoding.rs

@@ -177,7 +177,7 @@ impl<T: FixedEncodable> Encodable for T {
 
     fn get_metadata() -> Self::Metadata {}
 
-    fn can_decode(_: Self::Metadata) -> bool {
+    fn can_decode((): Self::Metadata) -> bool {
         true
     }
 
@@ -189,7 +189,7 @@ impl<T: FixedEncodable> Encodable for T {
         FixedEncodable::encoded_size(self)
     }
 
-    fn decode<B: Buf + Clone>(_: Self::Metadata, buffer: B) -> Result<Self, Self::DecodeError> {
+    fn decode<B: Buf + Clone>((): Self::Metadata, buffer: B) -> Result<Self, Self::DecodeError> {
         <Self as FixedEncodable>::decode(buffer)
     }
 }

lib/vector-buffers/src/test/variant.rs

@@ -103,12 +103,8 @@ impl Arbitrary for Variant {
         let use_memory_buffer = bool::arbitrary(g);
 
         // Using a u16 ensures we avoid any allocation errors for our holding buffers, etc.
-        let max_events = NonZeroU16::arbitrary(g)
-            .try_into()
-            .expect("we don't support 16-bit platforms");
-        let max_size = NonZeroU16::arbitrary(g)
-            .try_into()
-            .expect("we don't support 16-bit platforms");
+        let max_events = NonZeroU16::arbitrary(g).into();
+        let max_size = NonZeroU16::arbitrary(g).into();
 
         let when_full = WhenFull::arbitrary(g);
 

lib/vector-buffers/src/topology/acks.rs

@@ -730,7 +730,7 @@ mod tests {
     }
 
     #[test]
-    #[should_panic]
+    #[should_panic(expected = "overflowing unclaimed acknowledgements is a serious bug")]
     fn panic_when_unclaimed_acks_overflows() {
         let actions = vec![Action::Acknowledge(u64::MAX), Action::Acknowledge(1)];
 

lib/vector-buffers/src/topology/channel/receiver.rs

@@ -24,7 +24,7 @@ pub enum ReceiverAdapter<T: Bufferable> {
     InMemory(LimitedReceiver<T>),
 
     /// The disk v2 buffer.
-    DiskV2(disk_v2::Reader<T, ProductionFilesystem>),
+    DiskV2(disk_v2::BufferReader<T, ProductionFilesystem>),
 }
 
 impl<T: Bufferable> From<LimitedReceiver<T>> for ReceiverAdapter<T> {
@@ -33,8 +33,8 @@ impl<T: Bufferable> From<LimitedReceiver<T>> for ReceiverAdapter<T> {
     }
 }
 
-impl<T: Bufferable> From<disk_v2::Reader<T, ProductionFilesystem>> for ReceiverAdapter<T> {
-    fn from(v: disk_v2::Reader<T, ProductionFilesystem>) -> Self {
+impl<T: Bufferable> From<disk_v2::BufferReader<T, ProductionFilesystem>> for ReceiverAdapter<T> {
+    fn from(v: disk_v2::BufferReader<T, ProductionFilesystem>) -> Self {
         Self::DiskV2(v)
     }
 }

lib/vector-buffers/src/topology/channel/sender.rs

@@ -21,7 +21,7 @@ pub enum SenderAdapter<T: Bufferable> {
     InMemory(LimitedSender<T>),
 
     /// The disk v2 buffer.
-    DiskV2(Arc<Mutex<disk_v2::Writer<T, ProductionFilesystem>>>),
+    DiskV2(Arc<Mutex<disk_v2::BufferWriter<T, ProductionFilesystem>>>),
 }
 
 impl<T: Bufferable> From<LimitedSender<T>> for SenderAdapter<T> {
@@ -30,8 +30,8 @@ impl<T: Bufferable> From<LimitedSender<T>> for SenderAdapter<T> {
     }
 }
 
-impl<T: Bufferable> From<disk_v2::Writer<T, ProductionFilesystem>> for SenderAdapter<T> {
-    fn from(v: disk_v2::Writer<T, ProductionFilesystem>) -> Self {
+impl<T: Bufferable> From<disk_v2::BufferWriter<T, ProductionFilesystem>> for SenderAdapter<T> {
+    fn from(v: disk_v2::BufferWriter<T, ProductionFilesystem>) -> Self {
         Self::DiskV2(Arc::new(Mutex::new(v)))
     }
 }

lib/vector-buffers/src/variants/disk_v2/common.rs

@@ -428,7 +428,7 @@ mod tests {
     };
 
     #[test]
-    #[should_panic]
+    #[should_panic(expected = "`amount` must be less than `MAX_ALIGNABLE_AMOUNT`")]
     fn test_align16_too_large() {
         // We forcefully panic if the input to `align16` is too large to align without overflow, primarily because
         // that's a huge amount even on 32-bit systems and in non-test code, we only use `align16` in a const context,