Preallocate storage for log attributes on stack

opentelemetry-appender-log/src/lib.rs

@@ -938,12 +938,16 @@ mod tests {
         );
 
         let logs = exporter.get_emitted_logs().unwrap();
-        let attributes = &logs[0].record.attributes.as_ref().unwrap();
+        let attributes = &logs[0].record.attributes;
 
         let get = |needle: &str| {
-            attributes.iter().find_map(|(k, v)| {
-                if k.as_str() == needle {
-                    Some(v.clone())
+            attributes.iter().find_map(|attr| {
+                if let Some((k, v)) = attr {
+                    if k.as_str() == needle {
+                        Some(v.clone())
+                    } else {
+                        None
+                    }
                 } else {
                     None
                 }

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,35 @@ mod tests {
         assert!(log.record.trace_context.is_none());
 
         // Validate attributes
-        let attributes: Vec<(Key, AnyValue)> = log
-            .record
-            .attributes
-            .clone()
-            .expect("Attributes are expected");
+        let attributes = log.record.attributes.clone();
         #[cfg(not(feature = "experimental_metadata_attributes"))]
         assert_eq!(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"), "[email protected]".into())));
+        assert!(attributes.contains(&Some((Key::new("event_id"), 20.into()))));
+        assert!(attributes.contains(&Some((Key::new("user_name"), "otel".into()))));
+        assert!(attributes.contains(&Some((
+            Key::new("user_email"),
+            "[email protected]".into()
+        ))));
         #[cfg(feature = "experimental_metadata_attributes")]
         {
-            assert!(attributes.contains(&(Key::new("code.filename"), "layer.rs".into())));
-            assert!(attributes.contains(&(
+            assert!(attributes.contains(&Some((Key::new("code.filename"), "layer.rs".into()))));
+            assert!(attributes.contains(&Some((
                 Key::new("code.namespace"),
                 "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> = attributes
+                .iter()
+                .filter_map(|attr| match attr {
+                    Some((key, _)) => Some(key.clone()),
+                    None => None,
+                })
+                .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 +354,36 @@ mod tests {
         );
 
         // validate attributes.
-        let attributes: Vec<(Key, AnyValue)> = log
-            .record
-            .attributes
-            .clone()
-            .expect("Attributes are expected");
+        let attributes = log.record.attributes.clone();
         #[cfg(not(feature = "experimental_metadata_attributes"))]
         assert_eq!(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"), "[email protected]".into())));
+        assert!(attributes.contains(&Some((Key::new("event_id"), 20.into()))));
+        assert!(attributes.contains(&Some((Key::new("user_name"), "otel".into()))));
+        assert!(attributes.contains(&Some((
+            Key::new("user_email"),
+            "[email protected]".into()
+        ))));
         #[cfg(feature = "experimental_metadata_attributes")]
         {
-            assert!(attributes.contains(&(Key::new("code.filename"), "layer.rs".into())));
-            assert!(attributes.contains(&(
+            assert!(attributes.contains(&Some((Key::new("code.filename"), "layer.rs".into()))));
+            assert!(attributes.contains(&Some((
                 Key::new("code.namespace"),
                 "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> = attributes.iter().map(|(key, _)| key.clone()).collect();
+            let attributes_key: Vec<Key> = attributes
+                .iter()
+                .filter_map(|attr| match attr {
+                    Some((key, _)) => Some(key.clone()),
+                    None => None,
+                })
+                .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")));
@@ -415,27 +428,29 @@ mod tests {
 
         // Validate attributes
         #[cfg(feature = "experimental_metadata_attributes")]
-        let attributes: Vec<(Key, AnyValue)> = log
-            .record
-            .attributes
-            .clone()
-            .expect("Attributes are expected");
+        let attributes = log.record.attributes.clone();
 
         // Attributes can be polluted when we don't use this feature.
         #[cfg(feature = "experimental_metadata_attributes")]
         assert_eq!(attributes.len(), 5);
 
         #[cfg(feature = "experimental_metadata_attributes")]
         {
-            assert!(attributes.contains(&(Key::new("code.filename"), "layer.rs".into())));
-            assert!(attributes.contains(&(
+            assert!(attributes.contains(&(Some((Key::new("code.filename"), "layer.rs".into())))));
+            assert!(attributes.contains(&Some((
                 Key::new("code.namespace"),
                 "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> = attributes
+                .iter()
+                .filter_map(|attr| match attr {
+                    Some((key, _)) => Some(key.clone()),
+                    None => None,
+                })
+                .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")));
@@ -511,27 +526,29 @@ mod tests {
 
         // validate attributes.
         #[cfg(feature = "experimental_metadata_attributes")]
-        let attributes: Vec<(Key, AnyValue)> = log
-            .record
-            .attributes
-            .clone()
-            .expect("Attributes are expected");
+        let attributes = log.record.attributes.clone();
 
         // Attributes can be polluted when we don't use this feature.
         #[cfg(feature = "experimental_metadata_attributes")]
         assert_eq!(attributes.len(), 5);
 
         #[cfg(feature = "experimental_metadata_attributes")]
         {
-            assert!(attributes.contains(&(Key::new("code.filename"), "layer.rs".into())));
-            assert!(attributes.contains(&(
+            assert!(attributes.contains(&Some((Key::new("code.filename"), "layer.rs".into()))));
+            assert!(attributes.contains(&Some((
                 Key::new("code.namespace"),
                 "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> = attributes
+                .iter()
+                .filter_map(|attr| match attr {
+                    Some((key, _)) => Some(key.clone()),
+                    None => None,
+                })
+                .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

@@ -93,18 +93,26 @@ pub mod tonic {
                 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
+                    let mut attributes: Vec<KeyValue> = log_record
                         .attributes
-                        .map(Attributes::from_iter)
-                        .unwrap_or_default()
-                        .0;
+                        .iter()
+                        .filter_map(|kv| {
+                            kv.as_ref().map(|(k, v)| KeyValue {
+                                key: k.to_string(),
+                                value: Some(AnyValue {
+                                    value: Some(v.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
                 },

opentelemetry-sdk/Cargo.toml

@@ -36,6 +36,9 @@ rustdoc-args = ["--cfg", "docsrs"]
 [dev-dependencies]
 criterion = { workspace = true, features = ["html_reports"] }
 temp-env = { workspace = true }
+jemallocator = { version = "0.5"}
+jemalloc-ctl = { version = "0.5"}
+
 
 [target.'cfg(not(target_os = "windows"))'.dev-dependencies]
 pprof = { version = "0.13", features = ["flamegraph", "criterion"] }
@@ -51,6 +54,9 @@ testing = ["opentelemetry/testing", "trace", "metrics", "logs", "rt-async-std",
 rt-tokio = ["tokio", "tokio-stream"]
 rt-tokio-current-thread = ["tokio", "tokio-stream"]
 rt-async-std = ["async-std"]
+memory-profiling = []
+
+
 
 [[bench]]
 name = "context"
@@ -91,3 +97,8 @@ required-features = ["metrics"]
 name = "log"
 harness = false
 required-features = ["logs"]
+
+[[bench]]
+name = "growable_array"
+harness = false
+required-features = ["logs"]

opentelemetry-sdk/benches/growable_array.rs

@@ -0,0 +1,97 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use opentelemetry::logs::AnyValue;
+use opentelemetry::Key;
+use opentelemetry_sdk::logs::GrowableArray;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct KeyValuePair(Key, AnyValue);
+
+impl Default for KeyValuePair {
+    fn default() -> Self {
+        KeyValuePair(Key::from_static_str(""), AnyValue::Int(0))
+    }
+}
+
+fn growable_array_insertion_benchmark(c: &mut Criterion) {
+    c.bench_function("GrowableArray Insertion", |b| {
+        b.iter(|| {
+            let mut collection = GrowableArray::<KeyValuePair>::new();
+            for i in 0..8 {
+                let key = Key::from(format!("key{}", i));
+                let value = AnyValue::Int(i as i64);
+                collection.push(KeyValuePair(key, value));
+            }
+        })
+    });
+}
+
+fn vec_insertion_benchmark(c: &mut Criterion) {
+    c.bench_function("Vec Insertion", |b| {
+        b.iter(|| {
+            let mut collection = Vec::with_capacity(10);
+            for i in 0..8 {
+                let key = Key::from(format!("key{}", i));
+                let value = AnyValue::Int(i as i64);
+                collection.push(KeyValuePair(key, value));
+            }
+        })
+    });
+}
+
+fn growable_array_iteration_benchmark(c: &mut Criterion) {
+    c.bench_function("GrowableArray Iteration", |b| {
+        let mut collection = GrowableArray::<KeyValuePair>::new();
+        for i in 0..8 {
+            let key = Key::from(format!("key{}", i));
+            let value = AnyValue::Int(i as i64);
+            collection.push(KeyValuePair(key, value));
+        }
+        b.iter(|| {
+            for item in &collection {
+                criterion::black_box(item);
+            }
+        })
+    });
+}
+
+fn growable_array_get_benchmark(c: &mut Criterion) {
+    c.bench_function("GrowableArray Get Loop", |b| {
+        let mut collection = GrowableArray::<KeyValuePair>::new();
+        for i in 0..8 {
+            let key = Key::from(format!("key{}", i));
+            let value = AnyValue::Int(i as i64);
+            collection.push(KeyValuePair(key, value));
+        }
+        b.iter(|| {
+            for i in 0..collection.len() {
+                criterion::black_box(collection.get(i));
+            }
+        })
+    });
+}
+
+fn vec_iteration_benchmark(c: &mut Criterion) {
+    c.bench_function("Vec Iteration", |b| {
+        let mut collection = Vec::with_capacity(10);
+        for i in 0..8 {
+            let key = Key::from(format!("key{}", i));
+            let value = AnyValue::Int(i as i64);
+            collection.push(KeyValuePair(key, value));
+        }
+        b.iter(|| {
+            for item in &collection {
+                criterion::black_box(item);
+            }
+        })
+    });
+}
+
+criterion_group!(
+    benches,
+    growable_array_insertion_benchmark,
+    vec_insertion_benchmark,
+    growable_array_iteration_benchmark,
+    growable_array_get_benchmark,
+    vec_iteration_benchmark
+);
+criterion_main!(benches);