move keyvalue eq and hash to common

Author: cijothomas

opentelemetry/src/common.rs

@@ -2,6 +2,8 @@ use std::borrow::{Borrow, Cow};
 use std::sync::Arc;
 use std::{fmt, hash};
 
+use std::hash::{Hash, Hasher};
+
 /// The key part of attribute [KeyValue] pairs.
 ///
 /// See the [attribute naming] spec for guidelines.
@@ -399,6 +401,42 @@ impl KeyValue {
     }
 }
 
+struct F64Hashable(f64);
+
+impl PartialEq for F64Hashable {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.to_bits() == other.0.to_bits()
+    }
+}
+
+impl Eq for F64Hashable {}
+
+impl Hash for F64Hashable {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.to_bits().hash(state);
+    }
+}
+
+impl Hash for KeyValue {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.key.hash(state);
+        match &self.value {
+            Value::F64(f) => F64Hashable(*f).hash(state),
+            Value::Array(a) => match a {
+                Array::Bool(b) => b.hash(state),
+                Array::I64(i) => i.hash(state),
+                Array::F64(f) => f.iter().for_each(|f| F64Hashable(*f).hash(state)),
+                Array::String(s) => s.hash(state),
+            },
+            Value::Bool(b) => b.hash(state),
+            Value::I64(i) => i.hash(state),
+            Value::String(s) => s.hash(state),
+        };
+    }
+}
+
+impl Eq for KeyValue {}
+
 /// Information about a library or crate providing instrumentation.
 ///
 /// An instrumentation scope should be named to follow any naming conventions
@@ -579,6 +617,77 @@ mod tests {
 
     use crate::{InstrumentationScope, KeyValue};
 
+    use rand::random;
+    use std::collections::hash_map::DefaultHasher;
+    use std::f64;
+
+    #[test]
+    fn kv_float_equality() {
+        let kv1 = KeyValue::new("key", 1.0);
+        let kv2 = KeyValue::new("key", 1.0);
+        assert_eq!(kv1, kv2);
+
+        let kv1 = KeyValue::new("key", 1.0);
+        let kv2 = KeyValue::new("key", 1.01);
+        assert_ne!(kv1, kv2);
+
+        let kv1 = KeyValue::new("key", f64::NAN);
+        let kv2 = KeyValue::new("key", f64::NAN);
+        assert_ne!(kv1, kv2, "NAN is not equal to itself");
+
+        for float_val in [
+            f64::INFINITY,
+            f64::NEG_INFINITY,
+            f64::MAX,
+            f64::MIN,
+            f64::MIN_POSITIVE,
+        ]
+        .iter()
+        {
+            let kv1 = KeyValue::new("key", *float_val);
+            let kv2 = KeyValue::new("key", *float_val);
+            assert_eq!(kv1, kv2);
+        }
+
+        for _ in 0..100 {
+            let random_value = random::<f64>();
+            let kv1 = KeyValue::new("key", random_value);
+            let kv2 = KeyValue::new("key", random_value);
+            assert_eq!(kv1, kv2);
+        }
+    }
+
+    #[test]
+    fn kv_float_hash() {
+        for float_val in [
+            f64::NAN,
+            f64::INFINITY,
+            f64::NEG_INFINITY,
+            f64::MAX,
+            f64::MIN,
+            f64::MIN_POSITIVE,
+        ]
+        .iter()
+        {
+            let kv1 = KeyValue::new("key", *float_val);
+            let kv2 = KeyValue::new("key", *float_val);
+            assert_eq!(hash_helper(&kv1), hash_helper(&kv2));
+        }
+
+        for _ in 0..100 {
+            let random_value = random::<f64>();
+            let kv1 = KeyValue::new("key", random_value);
+            let kv2 = KeyValue::new("key", random_value);
+            assert_eq!(hash_helper(&kv1), hash_helper(&kv2));
+        }
+    }
+
+    fn hash_helper<T: Hash>(item: &T) -> u64 {
+        let mut hasher = DefaultHasher::new();
+        item.hash(&mut hasher);
+        hasher.finish()
+    }
+
     #[test]
     fn instrumentation_scope_equality() {
         let scope1 = InstrumentationScope::builder("my-crate")

opentelemetry/src/metrics/mod.rs

@@ -1,13 +1,10 @@
 //! # OpenTelemetry Metrics API
 
-use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 
 mod instruments;
 mod meter;
 pub(crate) mod noop;
-
-use crate::{Array, KeyValue, Value};
 pub use instruments::{
     counter::{Counter, ObservableCounter},
     gauge::{Gauge, ObservableGauge},
@@ -18,42 +15,6 @@ pub use instruments::{
 };
 pub use meter::{Meter, MeterProvider};
 
-struct F64Hashable(f64);
-
-impl PartialEq for F64Hashable {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.to_bits() == other.0.to_bits()
-    }
-}
-
-impl Eq for F64Hashable {}
-
-impl Hash for F64Hashable {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.0.to_bits().hash(state);
-    }
-}
-
-impl Hash for KeyValue {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.key.hash(state);
-        match &self.value {
-            Value::F64(f) => F64Hashable(*f).hash(state),
-            Value::Array(a) => match a {
-                Array::Bool(b) => b.hash(state),
-                Array::I64(i) => i.hash(state),
-                Array::F64(f) => f.iter().for_each(|f| F64Hashable(*f).hash(state)),
-                Array::String(s) => s.hash(state),
-            },
-            Value::Bool(b) => b.hash(state),
-            Value::I64(i) => i.hash(state),
-            Value::String(s) => s.hash(state),
-        };
-    }
-}
-
-impl Eq for KeyValue {}
-
 /// SDK implemented trait for creating instruments
 pub trait InstrumentProvider {
     /// creates an instrument for recording increasing values.
@@ -163,80 +124,3 @@ pub trait InstrumentProvider {
         Histogram::new(Arc::new(noop::NoopSyncInstrument::new()))
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use rand::random;
-
-    use crate::KeyValue;
-    use std::collections::hash_map::DefaultHasher;
-    use std::f64;
-    use std::hash::{Hash, Hasher};
-
-    #[test]
-    fn kv_float_equality() {
-        let kv1 = KeyValue::new("key", 1.0);
-        let kv2 = KeyValue::new("key", 1.0);
-        assert_eq!(kv1, kv2);
-
-        let kv1 = KeyValue::new("key", 1.0);
-        let kv2 = KeyValue::new("key", 1.01);
-        assert_ne!(kv1, kv2);
-
-        let kv1 = KeyValue::new("key", f64::NAN);
-        let kv2 = KeyValue::new("key", f64::NAN);
-        assert_ne!(kv1, kv2, "NAN is not equal to itself");
-
-        for float_val in [
-            f64::INFINITY,
-            f64::NEG_INFINITY,
-            f64::MAX,
-            f64::MIN,
-            f64::MIN_POSITIVE,
-        ]
-        .iter()
-        {
-            let kv1 = KeyValue::new("key", *float_val);
-            let kv2 = KeyValue::new("key", *float_val);
-            assert_eq!(kv1, kv2);
-        }
-
-        for _ in 0..100 {
-            let random_value = random::<f64>();
-            let kv1 = KeyValue::new("key", random_value);
-            let kv2 = KeyValue::new("key", random_value);
-            assert_eq!(kv1, kv2);
-        }
-    }
-
-    #[test]
-    fn kv_float_hash() {
-        for float_val in [
-            f64::NAN,
-            f64::INFINITY,
-            f64::NEG_INFINITY,
-            f64::MAX,
-            f64::MIN,
-            f64::MIN_POSITIVE,
-        ]
-        .iter()
-        {
-            let kv1 = KeyValue::new("key", *float_val);
-            let kv2 = KeyValue::new("key", *float_val);
-            assert_eq!(hash_helper(&kv1), hash_helper(&kv2));
-        }
-
-        for _ in 0..100 {
-            let random_value = random::<f64>();
-            let kv1 = KeyValue::new("key", random_value);
-            let kv2 = KeyValue::new("key", random_value);
-            assert_eq!(hash_helper(&kv1), hash_helper(&kv2));
-        }
-    }
-
-    fn hash_helper<T: Hash>(item: &T) -> u64 {
-        let mut hasher = DefaultHasher::new();
-        item.hash(&mut hasher);
-        hasher.finish()
-    }
-}