revert back to option

Author: lalitb

opentelemetry-sdk/src/logs/log_processor.rs

@@ -822,10 +822,10 @@ mod tests {
             }
 
             // Add attribute
-            data.record.attributes.push((
+            data.record.attributes.push(Some((
                 Key::from_static_str("processed_by"),
                 AnyValue::String("FirstProcessor".into()),
-            ));
+            )));
 
             // Update body
             data.record.body = Some(AnyValue::String("Updated by FirstProcessor".into()));
@@ -854,9 +854,13 @@ mod tests {
 
     impl LogProcessor for SecondProcessor {
         fn emit(&self, data: &mut LogData) {
-            assert!(data.record.attributes.iter().any(|(key, value)| {
-                key.as_str() == "processed_by"
-                    && *value == AnyValue::String("FirstProcessor".into())
+            assert!(data.record.attributes.iter().any(|attr| {
+                if let Some((key, value)) = attr {
+                    key.as_str() == "processed_by"
+                        && *value == AnyValue::String("FirstProcessor".into())
+                } else {
+                    false
+                }
             }));
             assert!(
                 data.record.body.clone().unwrap()
@@ -907,12 +911,22 @@ mod tests {
         let first_log = &first_processor_logs.lock().unwrap()[0];
         let second_log = &second_processor_logs.lock().unwrap()[0];
 
-        assert!(first_log.record.attributes.iter().any(|(key, value)| {
-            key.as_str() == "processed_by" && *value == AnyValue::String("FirstProcessor".into())
+        assert!(first_log.record.attributes.iter().any(|attr| {
+            if let Some((key, value)) = attr {
+                key.as_str() == "processed_by"
+                    && *value == AnyValue::String("FirstProcessor".into())
+            } else {
+                false
+            }
         }));
 
-        assert!(second_log.record.attributes.iter().any(|(key, value)| {
-            key.as_str() == "processed_by" && *value == AnyValue::String("FirstProcessor".into())
+        assert!(second_log.record.attributes.iter().any(|attr| {
+            if let Some((key, value)) = attr {
+                key.as_str() == "processed_by"
+                    && *value == AnyValue::String("FirstProcessor".into())
+            } else {
+                false
+            }
         }));
 
         assert!(

opentelemetry-sdk/src/logs/mod.rs

@@ -85,13 +85,17 @@ mod tests {
             .record
             .attributes
             .iter()
-            .map(|kv| (kv.0.clone(), kv.1.clone()))
+            .filter_map(|kv| kv.as_ref().map(|(k, v)| (k.clone(), v.clone())))
             .collect();
         assert_eq!(attributes.len(), 10);
         for i in 1..=10 {
-            assert!(log.record.attributes.iter().any(|(key, value)| {
-                key.as_str() == format!("key{}", i)
-                    && *value == AnyValue::String(format!("value{}", i).into())
+            assert!(log.record.attributes.iter().any(|kv| {
+                if let Some((key, value)) = kv {
+                    key.as_str() == format!("key{}", i)
+                        && *value == AnyValue::String(format!("value{}", i).into())
+                } else {
+                    false
+                }
             }));
         }
 

opentelemetry-sdk/src/logs/record.rs

@@ -11,9 +11,9 @@ use std::{borrow::Cow, time::SystemTime};
 // capacity for attributes to avoid reallocation in common scenarios.
 const PREALLOCATED_ATTRIBUTE_CAPACITY: usize = 8;
 
-/// A vector of `(Key, AnyValue)` with default capacity.
+/// A vector of `Option<(Key, AnyValue)>` with default capacity.
 pub(crate) type AttributesGrowableArray =
-    GrowableArray<(Key, AnyValue), PREALLOCATED_ATTRIBUTE_CAPACITY>;
+    GrowableArray<Option<(Key, AnyValue)>, PREALLOCATED_ATTRIBUTE_CAPACITY>;
 
 #[derive(Debug, Default, Clone, PartialEq)]
 #[non_exhaustive]
@@ -99,14 +99,14 @@ impl opentelemetry::logs::LogRecord for LogRecord {
         K: Into<Key>,
         V: Into<AnyValue>,
     {
-        self.attributes.push((key.into(), value.into()));
+        self.attributes.push(Some((key.into(), value.into())));
     }
 }
 
 impl LogRecord {
     /// Provides an iterator over the attributes.
     pub fn attributes_iter(&self) -> impl Iterator<Item = &(Key, AnyValue)> {
-        self.attributes.iter()
+        self.attributes.iter().filter_map(|opt| opt.as_ref())
     }
 
     /// Returns the number of attributes in the `LogRecord`.
@@ -116,7 +116,13 @@ impl LogRecord {
 
     /// Checks if the `LogRecord` contains the specified attribute.
     pub fn attributes_contains(&self, key: &Key, value: &AnyValue) -> bool {
-        self.attributes.iter().any(|(k, v)| k == key && v == value)
+        self.attributes.iter().any(|opt| {
+            if let Some((k, v)) = opt {
+                k == key && v == value
+            } else {
+                false
+            }
+        })
     }
 }
 
@@ -212,7 +218,7 @@ mod tests {
 
         let mut expected_attributes = AttributesGrowableArray::new();
         for (key, value) in attributes {
-            expected_attributes.push((key, value));
+            expected_attributes.push(Some((key, value)));
         }
         assert_eq!(log_record.attributes, expected_attributes);
     }
@@ -224,7 +230,7 @@ mod tests {
 
         let expected_attributes = {
             let mut hybrid_vec = AttributesGrowableArray::new();
-            hybrid_vec.push((Key::new("key"), AnyValue::String("value".into())));
+            hybrid_vec.push(Some((Key::new("key"), AnyValue::String("value".into()))));
             hybrid_vec
         };
         assert_eq!(log_record.attributes, expected_attributes);
@@ -263,7 +269,7 @@ mod tests {
             body: Some(AnyValue::String("Test body".into())),
             attributes: {
                 let mut hybrid_vec = AttributesGrowableArray::new();
-                hybrid_vec.push((Key::new("key"), AnyValue::String("value".into())));
+                hybrid_vec.push(Some((Key::new("key"), AnyValue::String("value".into()))));
                 hybrid_vec
             },
             trace_context: Some(TraceContext {

opentelemetry/src/common.rs

@@ -10,12 +10,6 @@ use std::{fmt, hash};
 #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Key(OtelString);
 
-impl Default for Key {
-    fn default() -> Self {
-        Key::from_static_str("")
-    }
-}
-
 impl Key {
     /// Create a new `Key`.
     ///

opentelemetry/src/logs/record.rs

@@ -66,12 +66,6 @@ pub enum AnyValue {
     Map(Box<HashMap<Key, AnyValue>>),
 }
 
-impl Default for AnyValue {
-    fn default() -> Self {
-        AnyValue::Int(0)
-    }
-}
-
 macro_rules! impl_trivial_from {
     ($t:ty, $variant:path) => {
         impl From<$t> for AnyValue {