cleanup, remove unused functions, clippy shenanigans

lib/codecs/tests/native.rs

@@ -5,11 +5,12 @@ use std::{
 };
 
 use bytes::{Bytes, BytesMut};
+use similar_asserts::assert_eq;
+
 use codecs::{
     decoding::format::Deserializer, encoding::format::Serializer, NativeDeserializerConfig,
     NativeJsonDeserializerConfig, NativeJsonSerializerConfig, NativeSerializerConfig,
 };
-use similar_asserts::assert_eq;
 use vector_core::{config::LogNamespace, event::Event};
 
 #[test]
@@ -46,7 +47,6 @@ fn roundtrip_current_native_proto_fixtures() {
 
 /// The event proto file was changed in v0.24. This test ensures we can still load the old version
 /// binary and that when serialized and deserialized in the new format we still get the same event.
-#[ignore]
 #[test]
 fn reserialize_pre_v24_native_json_fixtures() {
     roundtrip_fixtures(

lib/codecs/tests/native_json.rs

@@ -1,5 +1,4 @@
 use bytes::BytesMut;
-
 use codecs::decoding::format::Deserializer;
 use codecs::encoding::format::Serializer;
 use codecs::{NativeJsonDeserializerConfig, NativeJsonSerializerConfig};
@@ -35,7 +34,11 @@ fn histogram_metric_roundtrip() {
         MetricValue::AggregatedHistogram {
             count: 1,
             sum: 1.0,
-            buckets: buckets!(f64::NEG_INFINITY => 10 , f64::MIN => 10, 1.5 => 10, f64::MAX => 10, f64::INFINITY => 10),
+            buckets: buckets!(
+                f64::NEG_INFINITY => 10 ,
+                f64::MIN => 10, 1.5 => 10,
+                f64::MAX => 10,
+                f64::INFINITY => 10),
         },
     ));
 

lib/vector-core/src/event/metric/value.rs

@@ -1,8 +1,5 @@
 use core::fmt;
 use std::collections::BTreeSet;
-use std::fmt::Debug;
-use std::num::{ParseFloatError, ParseIntError};
-use std::str::FromStr;
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
@@ -454,7 +451,7 @@ impl fmt::Display for MetricValue {
             } => {
                 write!(fmt, "count={count} sum={sum} ")?;
                 write_list(fmt, " ", buckets, |fmt, bucket| {
-                    fmt::Display::fmt(&bucket, fmt)
+                    write!(fmt, "{}@{}", bucket.count, bucket.upper_limit)
                 })
             }
             MetricValue::AggregatedSummary {
@@ -603,39 +600,25 @@ impl ByteSizeOf for Sample {
     }
 }
 
-/// A histogram bucket.
-///
-/// Histogram buckets represent the `count` of observations where the value of the observations does
-/// not exceed the specified `upper_limit`.
-#[configurable_component(no_deser, no_ser)]
-#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
-pub struct Bucket {
-    /// The upper limit of values in the bucket.
-    #[serde(serialize_with = "serialize_f64", deserialize_with = "deserialize_f64")]
-    pub upper_limit: f64,
-
-    /// The number of values tracked in this bucket.
-    pub count: u64,
-}
-
+/// Custom serialization function which converts special f64 values to strings.
+#[allow(clippy::trivially_copy_pass_by_ref)]
 fn serialize_f64<S>(value: &f64, serializer: S) -> Result<S::Ok, S::Error>
 where
     S: Serializer,
 {
-    //println!("serializing {}", value);
     if value.is_infinite() || value.is_nan() {
-        serializer.serialize_str(&format!("{}", value))
+        serializer.serialize_str(&format!("{value}"))
     } else {
         serializer.serialize_f64(*value)
     }
 }
 
+/// Custom deserialization function for handling special f64 values.
 fn deserialize_f64<'de, D>(deserializer: D) -> Result<f64, D::Error>
 where
     D: Deserializer<'de>,
 {
     let value: serde_json::Value = Deserialize::deserialize(deserializer)?;
-    //println!("deserializing {}", value);
     match value {
         serde_json::Value::Number(num) => num
             .as_f64()
@@ -650,6 +633,21 @@ where
     }
 }
 
+/// A histogram bucket.
+///
+/// Histogram buckets represent the `count` of observations where the value of the observations does
+/// not exceed the specified `upper_limit`.
+#[configurable_component(no_deser, no_ser)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+pub struct Bucket {
+    /// The upper limit of values in the bucket.
+    #[serde(serialize_with = "serialize_f64", deserialize_with = "deserialize_f64")]
+    pub upper_limit: f64,
+
+    /// The number of values tracked in this bucket.
+    pub count: u64,
+}
+
 impl PartialEq for Bucket {
     fn eq(&self, other: &Self) -> bool {
         self.count == other.count && float_eq(self.upper_limit, other.upper_limit)
@@ -662,31 +660,6 @@ impl ByteSizeOf for Bucket {
     }
 }
 
-impl fmt::Display for Bucket {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}@{}", self.count, self.upper_limit)
-    }
-}
-
-impl FromStr for Bucket {
-    type Err = vector_common::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut parts = s.split('@');
-        let count: u64 = parts
-            .next()
-            .ok_or_else(|| "Missing count".to_string())?
-            .parse()
-            .map_err(|err: ParseIntError| err.to_string())?;
-        let upper_limit: f64 = parts
-            .next()
-            .ok_or_else(|| "Missing upper limit".to_string())?
-            .parse()
-            .map_err(|err: ParseFloatError| err.to_string())?;
-        Ok(Self { upper_limit, count })
-    }
-}
-
 /// A single quantile observation.
 ///
 /// Quantiles themselves are "cut points dividing the range of a probability distribution into