fix

Author: lalitb

opentelemetry-appender-tracing/Cargo.toml

@@ -26,6 +26,7 @@ opentelemetry_sdk = { path = "../opentelemetry-sdk", features = ["logs", "testin
 tracing-log = "0.2"
 async-trait = { workspace = true }
 criterion = { workspace = true }
+smallvec = "1.13"
 
 [target.'cfg(not(target_os = "windows"))'.dev-dependencies]
 pprof = { version = "0.13", features = ["flamegraph", "criterion"] }

opentelemetry-appender-tracing/benches/logs.rs

@@ -139,9 +139,9 @@ fn benchmark_with_ot_layer(c: &mut Criterion, enabled: bool, bench_name: &str) {
         c.bench_function(bench_name, |b| {
             b.iter(|| {
                 error!(
-                    name = "CheckoutFailed",
-                    book_id = "12345",
-                    book_title = "Rust Programming Adventures",
+                    // name = "CheckoutFailed",
+                    //book_id =12345,
+                    // book_title = "Rust Programming Adventures",
                     "Unable to process checkout."
                 );
             });

opentelemetry-appender-tracing/src/layer.rs

@@ -3,7 +3,6 @@ use opentelemetry::{
     Key,
 };
 use std::borrow::Cow;
-use std::fmt::Write;
 use tracing_core::{Level, Metadata};
 #[cfg(feature = "experimental_metadata_attributes")]
 use tracing_log::NormalizeEvent;
@@ -40,12 +39,9 @@ impl<'a, LR: LogRecord> EventVisitor<'a, LR> {
     fn new(log_record: &'a mut LR) -> Self {
         EventVisitor { log_record }
     }
-    fn visit_metadata(&mut self, meta: &Metadata) {
-        self.log_record
-            .add_attribute(Key::new("name"), AnyValue::from(meta.name()));
-
+    fn visit_metadata(&mut self, _meta: &Metadata) {
         #[cfg(feature = "experimental_metadata_attributes")]
-        self.visit_experimental_metadata(meta);
+        self.visit_experimental_metadata(_meta);
     }
 
     #[cfg(feature = "experimental_metadata_attributes")]
@@ -87,16 +83,10 @@ impl<'a, LR: LogRecord> tracing::field::Visit for EventVisitor<'a, LR> {
             return;
         }
         if field.name() == "message" {
-            let mut body = String::new();
-            write!(&mut body, "{:?}", value).unwrap();
-            self.log_record.set_body(body.into());
+            self.log_record.set_body(format!("{:?}", value).into());
         } else {
-            let mut value_string = String::new();
-            write!(&mut value_string, "{:?}", value).unwrap();
-            self.log_record.add_attribute(
-                Key::new(field.name()),
-                AnyValue::from(format!("{value_string:?}")),
-            );
+            self.log_record
+                .add_attribute(Key::new(field.name()), AnyValue::from(format!("{value:?}")));
         }
     }
 
@@ -105,10 +95,8 @@ impl<'a, LR: LogRecord> tracing::field::Visit for EventVisitor<'a, LR> {
         if is_duplicated_metadata(field.name()) {
             return;
         }
-        // Create a String with the exact capacity required
-        let owned_string = String::from(value);
         self.log_record
-            .add_attribute(Key::new(field.name()), AnyValue::from(owned_string));
+            .add_attribute(Key::new(field.name()), AnyValue::from(value.to_owned()));
     }
 
     fn record_bool(&mut self, field: &tracing_core::Field, value: bool) {
@@ -177,11 +165,11 @@ where
         #[cfg(not(feature = "experimental_metadata_attributes"))]
         let meta = event.metadata();
 
-        //let mut log_record: LogRecord = LogRecord::default();
         let mut log_record = self.logger.create_log_record();
         log_record.set_severity_number(severity_of_level(meta.level()));
         log_record.set_severity_text(meta.level().to_string().into());
         log_record.set_target(meta.target().to_string());
+        log_record.set_event_name(meta.name());
 
         let mut visitor = EventVisitor::new(&mut log_record);
         visitor.visit_metadata(meta);
@@ -224,9 +212,12 @@ mod tests {
     use opentelemetry_sdk::testing::logs::InMemoryLogsExporter;
     use opentelemetry_sdk::trace;
     use opentelemetry_sdk::trace::{Sampler, TracerProvider};
+    use smallvec::SmallVec;
     use tracing::error;
     use tracing_subscriber::layer::SubscriberExt;
 
+    const PREALLOCATED_ATTRIBUTE_CAPACITY: usize = 8;
+
     // cargo test --features=testing
     #[test]
     fn tracing_appender_standalone() {
@@ -264,7 +255,7 @@ mod tests {
         assert!(log.record.trace_context.is_none());
 
         // Validate attributes
-        let attributes: Vec<(Key, AnyValue)> = log
+        let attributes: SmallVec<[(Key, AnyValue); PREALLOCATED_ATTRIBUTE_CAPACITY]> = log
             .record
             .attributes
             .clone()
@@ -361,7 +352,7 @@ mod tests {
         );
 
         // validate attributes.
-        let attributes: Vec<(Key, AnyValue)> = log
+        let attributes: SmallVec<[(Key, AnyValue); PREALLOCATED_ATTRIBUTE_CAPACITY]> = log
             .record
             .attributes
             .clone()
@@ -428,7 +419,7 @@ mod tests {
         assert!(log.record.trace_context.is_none());
 
         // Validate attributes
-        let attributes: Vec<(Key, AnyValue)> = log
+        let attributes: SmallVec<[(Key, AnyValue); PREALLOCATED_ATTRIBUTE_CAPACITY]> = log
             .record
             .attributes
             .clone()
@@ -525,7 +516,7 @@ mod tests {
         );
 
         // validate attributes.
-        let attributes: Vec<(Key, AnyValue)> = log
+        let attributes: SmallVec<[(Key, AnyValue); PREALLOCATED_ATTRIBUTE_CAPACITY]> = log
             .record
             .attributes
             .clone()

opentelemetry-sdk/Cargo.toml

@@ -28,6 +28,7 @@ url = { workspace = true, optional = true }
 tokio = { workspace = true, features = ["rt", "time"], optional = true }
 tokio-stream = { workspace = true, optional = true }
 http = { workspace = true, optional = true }
+smallvec = "1.12"
 
 [package.metadata.docs.rs]
 all-features = true

opentelemetry-sdk/src/logs/log_emitter.rs

@@ -40,10 +40,6 @@ pub struct LoggerProvider {
 
 /// Default logger name if empty string is provided.
 const DEFAULT_COMPONENT_NAME: &str = "rust.opentelemetry.io/sdk/logger";
-// According to a Go-specific study mentioned on https://go.dev/blog/slog,
-// up to 5 attributes is the most common case. We have chosen 8 as the default
-// capacity for attributes to avoid reallocation in common scenarios.
-const PREALLOCATED_ATTRIBUTE_CAPACITY: usize = 8;
 
 impl opentelemetry::logs::LoggerProvider for LoggerProvider {
     type Logger = Logger;
@@ -251,10 +247,7 @@ impl opentelemetry::logs::Logger for Logger {
 
     fn create_log_record(&self) -> Self::LogRecord {
         // Reserve attributes memory for perf optimization. This may change in future.
-        LogRecord {
-            attributes: Some(Vec::with_capacity(PREALLOCATED_ATTRIBUTE_CAPACITY)),
-            ..Default::default()
-        }
+        LogRecord::default()
     }
 
     /// Emit a `LogRecord`.

opentelemetry-sdk/src/logs/log_processor.rs

@@ -530,6 +530,7 @@ mod tests {
     use opentelemetry::logs::{Logger, LoggerProvider as _};
     use opentelemetry::Key;
     use opentelemetry::{logs::LogResult, KeyValue};
+    use smallvec::smallvec;
     use std::borrow::Cow;
     use std::sync::{Arc, Mutex};
     use std::time::Duration;
@@ -816,7 +817,7 @@ mod tests {
     impl LogProcessor for FirstProcessor {
         fn emit(&self, data: &mut LogData) {
             // add attribute
-            data.record.attributes.get_or_insert(vec![]).push((
+            data.record.attributes.get_or_insert(smallvec![]).push((
                 Key::from_static_str("processed_by"),
                 AnyValue::String("FirstProcessor".into()),
             ));

opentelemetry-sdk/src/logs/mod.rs

@@ -14,11 +14,13 @@ pub use record::{LogRecord, TraceContext};
 #[cfg(all(test, feature = "testing"))]
 mod tests {
     use super::*;
+    use crate::logs::record::PREALLOCATED_ATTRIBUTE_CAPACITY;
     use crate::testing::logs::InMemoryLogsExporter;
     use crate::Resource;
     use opentelemetry::logs::LogRecord;
     use opentelemetry::logs::{Logger, LoggerProvider as _, Severity};
     use opentelemetry::{logs::AnyValue, Key, KeyValue};
+    use smallvec::SmallVec;
     use std::borrow::Borrow;
     use std::collections::HashMap;
 
@@ -80,7 +82,7 @@ mod tests {
             .expect("Atleast one log is expected to be present.");
         assert_eq!(log.instrumentation.name, "test-logger");
         assert_eq!(log.record.severity_number, Some(Severity::Error));
-        let attributes: Vec<(Key, AnyValue)> = log
+        let attributes: SmallVec<[(Key, AnyValue); PREALLOCATED_ATTRIBUTE_CAPACITY]> = log
             .record
             .attributes
             .clone()

opentelemetry-sdk/src/logs/record.rs

@@ -3,8 +3,14 @@ use opentelemetry::{
     trace::{SpanContext, SpanId, TraceFlags, TraceId},
     Key,
 };
+use smallvec::{smallvec, SmallVec};
 use std::{borrow::Cow, time::SystemTime};
 
+// According to a Go-specific study mentioned on https://go.dev/blog/slog,
+// up to 5 attributes is the most common case. We have chosen 8 as the default
+// capacity for attributes to avoid reallocation in common scenarios.
+pub(crate) const PREALLOCATED_ATTRIBUTE_CAPACITY: usize = 8;
+
 #[derive(Debug, Default, Clone)]
 #[non_exhaustive]
 /// LogRecord represents all data carried by a log record, and
@@ -34,7 +40,7 @@ pub struct LogRecord {
     pub body: Option<AnyValue>,
 
     /// Additional attributes associated with this record
-    pub attributes: Option<Vec<(Key, AnyValue)>>,
+    pub attributes: Option<SmallVec<[(Key, AnyValue); PREALLOCATED_ATTRIBUTE_CAPACITY]>>,
 }
 
 impl opentelemetry::logs::LogRecord for LogRecord {
@@ -91,8 +97,6 @@ impl opentelemetry::logs::LogRecord for LogRecord {
     {
         if let Some(ref mut attrs) = self.attributes {
             attrs.push((key.into(), value.into()));
-        } else {
-            self.attributes = Some(vec![(key.into(), value.into())]);
         }
     }
 }
@@ -186,16 +190,17 @@ mod tests {
         let mut log_record = LogRecord::default();
         let attributes = vec![(Key::new("key"), AnyValue::String("value".into()))];
         log_record.add_attributes(attributes.clone());
-        assert_eq!(log_record.attributes, Some(attributes));
+        let expected_attributes: SmallVec<[(Key, AnyValue); PREALLOCATED_ATTRIBUTE_CAPACITY]> =
+            smallvec![(Key::new("key"), AnyValue::String("value".into()))];
+        assert_eq!(log_record.attributes, Some(expected_attributes));
     }
 
     #[test]
     fn test_set_attribute() {
         let mut log_record = LogRecord::default();
         log_record.add_attribute("key", "value");
-        assert_eq!(
-            log_record.attributes,
-            Some(vec![(Key::new("key"), AnyValue::String("value".into()))])
-        );
+        let expected_attributes: SmallVec<[(Key, AnyValue); PREALLOCATED_ATTRIBUTE_CAPACITY]> =
+            smallvec![(Key::new("key"), AnyValue::String("value".into()))];
+        assert_eq!(log_record.attributes, Some(expected_attributes));
     }
 }