Preallocate storage for log attributes on stack

opentelemetry-appender-log/src/lib.rs

@@ -621,7 +621,7 @@ mod any_value {
 
         fn end(self) -> Result<Self::Ok, Self::Error> {
             Ok(Some(AnyValue::Map({
-                let mut variant = HashMap::new();
+                let mut variant = HashMap::default();
                 variant.insert(Key::from(self.variant), AnyValue::ListAny(self.value));
                 variant
             })))
@@ -713,7 +713,7 @@ mod any_value {
 
         fn end(self) -> Result<Self::Ok, Self::Error> {
             Ok(Some(AnyValue::Map({
-                let mut variant = HashMap::new();
+                let mut variant = HashMap::default();
                 variant.insert(Key::from(self.variant), AnyValue::Map(self.value));
                 variant
             })))
@@ -938,18 +938,16 @@ mod tests {
         );
 
         let logs = exporter.get_emitted_logs().unwrap();
-        let attributes = &logs[0].record.attributes.as_ref().unwrap();
 
-        let get = |needle: &str| {
-            attributes.iter().find_map(|(k, v)| {
+        let get = |needle: &str| -> Option<AnyValue> {
+            logs[0].record.attributes_iter().find_map(|(k, v)| {
                 if k.as_str() == needle {
                     Some(v.clone())
                 } else {
                     None
                 }
             })
         };
-
         assert_eq!(
             AnyValue::String(StringValue::from("a string")),
             get("str_value").unwrap()
@@ -1032,7 +1030,7 @@ mod tests {
 
             assert_eq!(
                 AnyValue::Map({
-                    let mut map = HashMap::new();
+                    let mut map = HashMap::default();
 
                     map.insert(Key::from("a"), AnyValue::Int(1));
                     map.insert(Key::from("b"), AnyValue::Int(1));
@@ -1045,7 +1043,7 @@ mod tests {
 
             assert_eq!(
                 AnyValue::Map({
-                    let mut map = HashMap::new();
+                    let mut map = HashMap::default();
 
                     map.insert(Key::from("a"), AnyValue::Int(1));
                     map.insert(Key::from("b"), AnyValue::Int(1));
@@ -1068,8 +1066,7 @@ mod tests {
 
             assert_eq!(
                 AnyValue::Map({
-                    let mut map = HashMap::new();
-
+                    let mut map = HashMap::default();
                     map.insert(Key::from("Newtype"), AnyValue::Int(42));
 
                     map
@@ -1079,12 +1076,12 @@ mod tests {
 
             assert_eq!(
                 AnyValue::Map({
-                    let mut map = HashMap::new();
+                    let mut map = HashMap::default();
 
                     map.insert(
                         Key::from("Struct"),
                         AnyValue::Map({
-                            let mut map = HashMap::new();
+                            let mut map = HashMap::default();
 
                             map.insert(Key::from("a"), AnyValue::Int(1));
                             map.insert(Key::from("b"), AnyValue::Int(1));
@@ -1101,7 +1098,7 @@ mod tests {
 
             assert_eq!(
                 AnyValue::Map({
-                    let mut map = HashMap::new();
+                    let mut map = HashMap::default();
 
                     map.insert(
                         Key::from("Tuple"),

opentelemetry-appender-tracing/Cargo.toml

@@ -33,7 +33,6 @@ pprof = { version = "0.13", features = ["flamegraph", "criterion"] }
 experimental_metadata_attributes = ["dep:tracing-log"]
 logs_level_enabled = ["opentelemetry/logs_level_enabled"]
 
-
 [[bench]]
 name = "logs"
 harness = false

opentelemetry-appender-tracing/src/layer.rs

@@ -252,29 +252,40 @@ mod tests {
         assert!(log.record.trace_context.is_none());
 
         // Validate attributes
-        let attributes: Vec<(Key, AnyValue)> = log
-            .record
-            .attributes
-            .clone()
-            .expect("Attributes are expected");
         #[cfg(not(feature = "experimental_metadata_attributes"))]
-        assert_eq!(attributes.len(), 3);
+        assert_eq!(log.record.attributes_len(), 3);
         #[cfg(feature = "experimental_metadata_attributes")]
-        assert_eq!(attributes.len(), 8);
-        assert!(attributes.contains(&(Key::new("event_id"), 20.into())));
-        assert!(attributes.contains(&(Key::new("user_name"), "otel".into())));
-        assert!(attributes.contains(&(Key::new("user_email"), "otel@opentelemetry.io".into())));
+        assert_eq!(log.record.attributes_len(), 8);
+        assert!(log
+            .record
+            .attributes_contains(&Key::new("event_id"), &AnyValue::Int(20)));
+        assert!(log
+            .record
+            .attributes_contains(&Key::new("user_name"), &AnyValue::String("otel".into())));
+        assert!(log.record.attributes_contains(
+            &Key::new("user_email"),
+            &AnyValue::String("otel@opentelemetry.io".into())
+        ));
+
         #[cfg(feature = "experimental_metadata_attributes")]
         {
-            assert!(attributes.contains(&(Key::new("code.filename"), "layer.rs".into())));
-            assert!(attributes.contains(&(
-                Key::new("code.namespace"),
-                "opentelemetry_appender_tracing::layer::tests".into()
-            )));
+            assert!(log.record.attributes_contains(
+                &Key::new("code.filename"),
+                &AnyValue::String("layer.rs".into())
+            ));
+            assert!(log.record.attributes_contains(
+                &Key::new("code.namespace"),
+                &AnyValue::String("opentelemetry_appender_tracing::layer::tests".into())
+            ));
             // The other 3 experimental_metadata_attributes are too unstable to check their value.
             // Ex.: The path will be different on a Windows and Linux machine.
             // Ex.: The line can change easily if someone makes changes in this source file.
-            let attributes_key: Vec<Key> = attributes.iter().map(|(key, _)| key.clone()).collect();
+            let attributes_key: Vec<Key> = log
+                .record
+                .attributes_iter()
+                .map(|(key, _)| key.clone())
+                .collect();
+
             assert!(attributes_key.contains(&Key::new("code.filepath")));
             assert!(attributes_key.contains(&Key::new("code.lineno")));
             assert!(attributes_key.contains(&Key::new("log.target")));
@@ -348,29 +359,39 @@ mod tests {
         );
 
         // validate attributes.
-        let attributes: Vec<(Key, AnyValue)> = log
-            .record
-            .attributes
-            .clone()
-            .expect("Attributes are expected");
         #[cfg(not(feature = "experimental_metadata_attributes"))]
-        assert_eq!(attributes.len(), 3);
+        assert_eq!(log.record.attributes_len(), 3);
         #[cfg(feature = "experimental_metadata_attributes")]
-        assert_eq!(attributes.len(), 8);
-        assert!(attributes.contains(&(Key::new("event_id"), 20.into())));
-        assert!(attributes.contains(&(Key::new("user_name"), "otel".into())));
-        assert!(attributes.contains(&(Key::new("user_email"), "otel@opentelemetry.io".into())));
+        assert_eq!(log.record.attributes_len(), 8);
+        assert!(log
+            .record
+            .attributes_contains(&Key::new("event_id"), &AnyValue::Int(20.into())));
+        assert!(log
+            .record
+            .attributes_contains(&Key::new("user_name"), &AnyValue::String("otel".into())));
+        assert!(log.record.attributes_contains(
+            &Key::new("user_email"),
+            &AnyValue::String("otel@opentelemetry.io".into())
+        ));
         #[cfg(feature = "experimental_metadata_attributes")]
         {
-            assert!(attributes.contains(&(Key::new("code.filename"), "layer.rs".into())));
-            assert!(attributes.contains(&(
-                Key::new("code.namespace"),
-                "opentelemetry_appender_tracing::layer::tests".into()
-            )));
+            assert!(log.record.attributes_contains(
+                &Key::new("code.filename"),
+                &AnyValue::String("layer.rs".into())
+            ));
+            assert!(log.record.attributes_contains(
+                &Key::new("code.namespace"),
+                &AnyValue::String("opentelemetry_appender_tracing::layer::tests".into())
+            ));
             // The other 3 experimental_metadata_attributes are too unstable to check their value.
             // Ex.: The path will be different on a Windows and Linux machine.
             // Ex.: The line can change easily if someone makes changes in this source file.
-            let attributes_key: Vec<Key> = attributes.iter().map(|(key, _)| key.clone()).collect();
+
+            let attributes_key: Vec<Key> = log
+                .record
+                .attributes_iter()
+                .map(|(key, _)| key.clone())
+                .collect();
             assert!(attributes_key.contains(&Key::new("code.filepath")));
             assert!(attributes_key.contains(&Key::new("code.lineno")));
             assert!(attributes_key.contains(&Key::new("log.target")));
@@ -413,29 +434,28 @@ mod tests {
         // Validate trace context is none.
         assert!(log.record.trace_context.is_none());
 
-        // Validate attributes
-        #[cfg(feature = "experimental_metadata_attributes")]
-        let attributes: Vec<(Key, AnyValue)> = log
-            .record
-            .attributes
-            .clone()
-            .expect("Attributes are expected");
-
         // Attributes can be polluted when we don't use this feature.
         #[cfg(feature = "experimental_metadata_attributes")]
-        assert_eq!(attributes.len(), 5);
+        assert_eq!(log.record.attributes_len(), 5);
 
         #[cfg(feature = "experimental_metadata_attributes")]
         {
-            assert!(attributes.contains(&(Key::new("code.filename"), "layer.rs".into())));
-            assert!(attributes.contains(&(
-                Key::new("code.namespace"),
-                "opentelemetry_appender_tracing::layer::tests".into()
-            )));
+            assert!(log.record.attributes_contains(
+                &Key::new("code.filename"),
+                &AnyValue::String("layer.rs".into())
+            ));
+            assert!(log.record.attributes_contains(
+                &Key::new("code.namespace"),
+                &AnyValue::String("opentelemetry_appender_tracing::layer::tests".into())
+            ));
             // The other 3 experimental_metadata_attributes are too unstable to check their value.
             // Ex.: The path will be different on a Windows and Linux machine.
             // Ex.: The line can change easily if someone makes changes in this source file.
-            let attributes_key: Vec<Key> = attributes.iter().map(|(key, _)| key.clone()).collect();
+            let attributes_key: Vec<Key> = log
+                .record
+                .attributes_iter()
+                .map(|(key, _)| key.clone())
+                .collect();
             assert!(attributes_key.contains(&Key::new("code.filepath")));
             assert!(attributes_key.contains(&Key::new("code.lineno")));
             assert!(attributes_key.contains(&Key::new("log.target")));
@@ -510,28 +530,28 @@ mod tests {
         );
 
         // validate attributes.
-        #[cfg(feature = "experimental_metadata_attributes")]
-        let attributes: Vec<(Key, AnyValue)> = log
-            .record
-            .attributes
-            .clone()
-            .expect("Attributes are expected");
-
         // Attributes can be polluted when we don't use this feature.
         #[cfg(feature = "experimental_metadata_attributes")]
-        assert_eq!(attributes.len(), 5);
+        assert_eq!(log.record.attributes_len(), 5);
 
         #[cfg(feature = "experimental_metadata_attributes")]
         {
-            assert!(attributes.contains(&(Key::new("code.filename"), "layer.rs".into())));
-            assert!(attributes.contains(&(
-                Key::new("code.namespace"),
-                "opentelemetry_appender_tracing::layer::tests".into()
-            )));
+            assert!(log.record.attributes_contains(
+                &Key::new("code.filename"),
+                &AnyValue::String("layer.rs".into())
+            ));
+            assert!(log.record.attributes_contains(
+                &Key::new("code.namespace"),
+                &AnyValue::String("opentelemetry_appender_tracing::layer::tests".into())
+            ));
             // The other 3 experimental_metadata_attributes are too unstable to check their value.
             // Ex.: The path will be different on a Windows and Linux machine.
             // Ex.: The line can change easily if someone makes changes in this source file.
-            let attributes_key: Vec<Key> = attributes.iter().map(|(key, _)| key.clone()).collect();
+            let attributes_key: Vec<Key> = log
+                .record
+                .attributes_iter()
+                .map(|(key, _)| key.clone())
+                .collect();
             assert!(attributes_key.contains(&Key::new("code.filepath")));
             assert!(attributes_key.contains(&Key::new("code.lineno")));
             assert!(attributes_key.contains(&Key::new("log.target")));

opentelemetry-proto/src/transform/logs.rs

@@ -8,7 +8,6 @@
             },
             logs::v1::{LogRecord, ResourceLogs, ScopeLogs, SeverityNumber},
             resource::v1::Resource,
-            Attributes,
         },
         transform::common::{to_nanos, tonic::ResourceAttributesWithSchema},
     };
@@ -89,25 +88,30 @@
             LogRecord {
                 time_unix_nano: log_record.timestamp.map(to_nanos).unwrap_or_default(),
                 observed_time_unix_nano: to_nanos(log_record.observed_timestamp.unwrap()),
-                severity_number: severity_number.into(),
-                severity_text: log_record.severity_text.map(Into::into).unwrap_or_default(),
-                body: log_record.body.map(Into::into),
                 attributes: {
-                    let mut attributes = log_record
-                        .attributes
-                        .map(Attributes::from_iter)
-                        .unwrap_or_default()
-                        .0;
+                    let mut attributes: Vec<KeyValue> = log_record
+                        .attributes_iter()
+                        .map(|kv| KeyValue {
+                            key: kv.0.to_string(),
+                            value: Some(AnyValue {
+                                value: Some(kv.1.clone().into()),
+                            }),
+                        })
+                        .collect();
+
                     if let Some(event_name) = log_record.event_name.as_ref() {
                         attributes.push(KeyValue {
                             key: "name".into(),
                             value: Some(AnyValue {
                                 value: Some(Value::StringValue(event_name.to_string())),
                             }),
-                        })
+                        });
                     }
                     attributes
                 },
+                severity_number: severity_number.into(),
+                severity_text: log_record.severity_text.map(Into::into).unwrap_or_default(),
+                body: log_record.body.map(Into::into),
                 dropped_attributes_count: 0,
                 flags: trace_context
                     .map(|ctx| {

opentelemetry-sdk/benches/log.rs

@@ -15,8 +15,7 @@ use opentelemetry::trace::Tracer;
 use opentelemetry::trace::TracerProvider as _;
 use opentelemetry::Key;
 use opentelemetry_sdk::export::logs::LogData;
-use opentelemetry_sdk::logs::LogProcessor;
-use opentelemetry_sdk::logs::{Logger, LoggerProvider};
+use opentelemetry_sdk::logs::{LogProcessor, Logger, LoggerProvider};
 use opentelemetry_sdk::trace;
 use opentelemetry_sdk::trace::{Sampler, TracerProvider};