Moving LogRecord implementation to SDK (#1702)

Co-authored-by: Zhongyang Wu <zhongyang.wu@outlook.com>
Co-authored-by: Cijo Thomas <cithomas@microsoft.com>
Co-authored-by: Cijo Thomas <cijo.thomas@gmail.com>

Author: 3 people

opentelemetry-appender-log/src/lib.rs

@@ -96,7 +96,7 @@
 
 use log::{Level, Metadata, Record};
 use opentelemetry::{
-    logs::{AnyValue, LogRecordBuilder, Logger, LoggerProvider, Severity},
+    logs::{AnyValue, LogRecord, Logger, LoggerProvider, Severity},
     Key,
 };
 use std::borrow::Cow;
@@ -126,16 +126,13 @@ where
 
     fn log(&self, record: &Record) {
         if self.enabled(record.metadata()) {
-            self.logger.emit(
-                LogRecordBuilder::new()
-                    .with_severity_number(severity_of_level(record.level()))
-                    .with_severity_text(record.level().as_str())
-                    // Not populating ObservedTimestamp, instead relying on OpenTelemetry
-                    // API to populate it with current time.
-                    .with_body(AnyValue::from(record.args().to_string()))
-                    .with_attributes(log_attributes(record.key_values()))
-                    .build(),
-            );
+            let mut log_record = self.logger.create_log_record();
+            log_record.set_severity_number(severity_of_level(record.level()));
+            log_record.set_severity_text(record.level().as_str().into());
+            log_record.set_body(AnyValue::from(record.args().to_string()));
+            log_record.add_attributes(log_attributes(record.key_values()));
+
+            self.logger.emit(log_record);
         }
     }
 

opentelemetry-appender-tracing/src/layer.rs

@@ -71,9 +71,11 @@ impl EventVisitor {
         }
     }
 
-    fn push_to_otel_log_record(self, log_record: &mut LogRecord) {
-        log_record.body = self.log_record_body;
-        log_record.attributes = Some(self.log_record_attributes);
+    fn push_to_otel_log_record<LR: LogRecord>(self, log_record: &mut LR) {
+        if let Some(body) = self.log_record_body {
+            log_record.set_body(body);
+        }
+        log_record.add_attributes(self.log_record_attributes);
     }
 }
 
@@ -166,12 +168,10 @@ where
         #[cfg(not(feature = "experimental_metadata_attributes"))]
         let meta = event.metadata();
 
-        let mut log_record: LogRecord = LogRecord::default();
-        log_record.severity_number = Some(severity_of_level(meta.level()));
-        log_record.severity_text = Some(meta.level().to_string().into());
-
-        // Not populating ObservedTimestamp, instead relying on OpenTelemetry
-        // API to populate it with current time.
+        //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());
 
         let mut visitor = EventVisitor::default();
         visitor.visit_metadata(meta);

opentelemetry-proto/src/transform/logs.rs

@@ -50,8 +50,8 @@ pub mod tonic {
         }
     }
 
-    impl From<opentelemetry::logs::LogRecord> for LogRecord {
-        fn from(log_record: opentelemetry::logs::LogRecord) -> Self {
+    impl From<opentelemetry_sdk::logs::LogRecord> for LogRecord {
+        fn from(log_record: opentelemetry_sdk::logs::LogRecord) -> Self {
             let trace_context = log_record.trace_context.as_ref();
             let severity_number = match log_record.severity_number {
                 Some(Severity::Trace) => SeverityNumber::Trace,
@@ -83,7 +83,7 @@ pub mod tonic {
 
             LogRecord {
                 time_unix_nano: log_record.timestamp.map(to_nanos).unwrap_or_default(),
-                observed_time_unix_nano: to_nanos(log_record.observed_timestamp),
+                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),

opentelemetry-sdk/CHANGELOG.md

@@ -26,6 +26,8 @@
   - `shutdown` methods in `LoggerProvider` and `LogProcessor` now takes a immutable reference
   - After `shutdown`, `LoggerProvider` will return noop `Logger`
   - After `shutdown`, `LogProcessor` will not process any new logs
+- Moving LogRecord implementation to the SDK. [1702](https://github.com/open-telemetry/opentelemetry-rust/pull/1702).
+    - Relocated `LogRecord` struct to SDK, as an implementation for the trait in the API.
 
 ## v0.22.1
 

opentelemetry-sdk/benches/log.rs

@@ -4,12 +4,14 @@ use std::time::SystemTime;
 use async_trait::async_trait;
 use criterion::{criterion_group, criterion_main, Criterion};
 
-use opentelemetry::logs::{AnyValue, LogRecord, LogResult, Logger, LoggerProvider as _, Severity};
+use opentelemetry::logs::{
+    AnyValue, LogRecord as _, LogResult, Logger as _, LoggerProvider as _, Severity,
+};
 use opentelemetry::trace::Tracer;
 use opentelemetry::trace::TracerProvider as _;
 use opentelemetry::Key;
 use opentelemetry_sdk::export::logs::{LogData, LogExporter};
-use opentelemetry_sdk::logs::LoggerProvider;
+use opentelemetry_sdk::logs::{Logger, LoggerProvider};
 use opentelemetry_sdk::trace::{config, Sampler, TracerProvider};
 
 #[derive(Debug)]
@@ -22,7 +24,7 @@ impl LogExporter for VoidExporter {
     }
 }
 
-fn log_benchmark_group<F: Fn(&dyn Logger)>(c: &mut Criterion, name: &str, f: F) {
+fn log_benchmark_group<F: Fn(&Logger)>(c: &mut Criterion, name: &str, f: F) {
     let mut group = c.benchmark_group(name);
 
     group.bench_function("no-context", |b| {
@@ -59,53 +61,45 @@ fn log_benchmark_group<F: Fn(&dyn Logger)>(c: &mut Criterion, name: &str, f: F)
 
 fn criterion_benchmark(c: &mut Criterion) {
     log_benchmark_group(c, "simple-log", |logger| {
-        logger.emit(LogRecord::builder().with_body("simple log").build())
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("simple log".into());
+        logger.emit(log_record);
     });
 
     log_benchmark_group(c, "simple-log-with-int", |logger| {
-        logger.emit(
-            LogRecord::builder()
-                .with_body("simple log")
-                .with_attribute("testint", 2)
-                .build(),
-        )
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("simple log".into());
+        log_record.add_attribute("testint", 2);
+        logger.emit(log_record);
     });
 
     log_benchmark_group(c, "simple-log-with-double", |logger| {
-        logger.emit(
-            LogRecord::builder()
-                .with_body("simple log")
-                .with_attribute("testdouble", 2.2)
-                .build(),
-        )
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("simple log".into());
+        log_record.add_attribute("testdouble", 2.2);
+        logger.emit(log_record);
     });
 
     log_benchmark_group(c, "simple-log-with-string", |logger| {
-        logger.emit(
-            LogRecord::builder()
-                .with_body("simple log")
-                .with_attribute("teststring", "test")
-                .build(),
-        )
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("simple log".into());
+        log_record.add_attribute("teststring", "test");
+        logger.emit(log_record);
     });
 
     log_benchmark_group(c, "simple-log-with-bool", |logger| {
-        logger.emit(
-            LogRecord::builder()
-                .with_body("simple log")
-                .with_attribute("testbool", AnyValue::Boolean(true))
-                .build(),
-        )
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("simple log".into());
+        log_record.add_attribute("testbool", AnyValue::Boolean(true));
+        logger.emit(log_record);
     });
 
     let bytes = AnyValue::Bytes(vec![25u8, 30u8, 40u8]);
     log_benchmark_group(c, "simple-log-with-bytes", |logger| {
-        logger.emit(
-            LogRecord::builder()
-                .with_body("simple log")
-                .with_attribute("testbytes", bytes.clone())
-                .build(),
-        )
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("simple log".into());
+        log_record.add_attribute("testbytes", bytes.clone());
+        logger.emit(log_record);
     });
 
     let bytes = AnyValue::Bytes(vec![
@@ -117,22 +111,18 @@ fn criterion_benchmark(c: &mut Criterion) {
         30u8, 40u8, 30u8, 40u8, 30u8, 40u8, 30u8, 40u8, 30u8, 40u8,
     ]);
     log_benchmark_group(c, "simple-log-with-a-lot-of-bytes", |logger| {
-        logger.emit(
-            LogRecord::builder()
-                .with_body("simple log")
-                .with_attribute("testbytes", bytes.clone())
-                .build(),
-        )
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("simple log".into());
+        log_record.add_attribute("testbytes", bytes.clone());
+        logger.emit(log_record);
     });
 
     let vec_any_values = AnyValue::ListAny(vec![AnyValue::Int(25), "test".into(), true.into()]);
     log_benchmark_group(c, "simple-log-with-vec-any-value", |logger| {
-        logger.emit(
-            LogRecord::builder()
-                .with_body("simple log")
-                .with_attribute("testvec", vec_any_values.clone())
-                .build(),
-        )
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("simple log".into());
+        log_record.add_attribute("testvec", vec_any_values.clone());
+        logger.emit(log_record);
     });
 
     let vec_any_values = AnyValue::ListAny(vec![AnyValue::Int(25), "test".into(), true.into()]);
@@ -143,12 +133,10 @@ fn criterion_benchmark(c: &mut Criterion) {
         vec_any_values,
     ]);
     log_benchmark_group(c, "simple-log-with-inner-vec-any-value", |logger| {
-        logger.emit(
-            LogRecord::builder()
-                .with_body("simple log")
-                .with_attribute("testvec", vec_any_values.clone())
-                .build(),
-        )
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("simple log".into());
+        log_record.add_attribute("testvec", vec_any_values.clone());
+        logger.emit(log_record);
     });
 
     let map_any_values = AnyValue::Map(HashMap::from([
@@ -157,12 +145,10 @@ fn criterion_benchmark(c: &mut Criterion) {
         ("teststring".into(), "test".into()),
     ]));
     log_benchmark_group(c, "simple-log-with-map-any-value", |logger| {
-        logger.emit(
-            LogRecord::builder()
-                .with_body("simple log")
-                .with_attribute("testmap", map_any_values.clone())
-                .build(),
-        )
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("simple log".into());
+        log_record.add_attribute("testmap", map_any_values.clone());
+        logger.emit(log_record);
     });
 
     let map_any_values = AnyValue::Map(HashMap::from([
@@ -177,66 +163,60 @@ fn criterion_benchmark(c: &mut Criterion) {
         ("testmap".into(), map_any_values),
     ]));
     log_benchmark_group(c, "simple-log-with-inner-map-any-value", |logger| {
-        logger.emit(
-            LogRecord::builder()
-                .with_body("simple log")
-                .with_attribute("testmap", map_any_values.clone())
-                .build(),
-        )
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("simple log".into());
+        log_record.add_attribute("testmap", map_any_values.clone());
+        logger.emit(log_record);
     });
 
     log_benchmark_group(c, "long-log", |logger| {
-        logger.emit(LogRecord::builder().with_body("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Gravida in fermentum et sollicitudin ac orci phasellus. Ullamcorper dignissim cras tincidunt lobortis feugiat vivamus at augue. Magna etiam tempor orci eu. Sed tempus urna et pharetra pharetra massa.").build())
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Gravida in fermentum et sollicitudin ac orci phasellus. Ullamcorper dignissim cras tincidunt lobortis feugiat vivamus at augue. Magna etiam tempor orci eu. Sed tempus urna et pharetra pharetra massa.".into());
+        logger.emit(log_record);
     });
 
     let now = SystemTime::now();
     log_benchmark_group(c, "full-log", |logger| {
-        logger.emit(
-            LogRecord::builder()
-                .with_body("full log")
-                .with_timestamp(now)
-                .with_observed_timestamp(now)
-                .with_severity_number(Severity::Warn)
-                .with_severity_text(Severity::Warn.name())
-                .build(),
-        )
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("full log".into());
+        log_record.set_timestamp(now);
+        log_record.set_observed_timestamp(now);
+        log_record.set_severity_number(Severity::Warn);
+        log_record.set_severity_text(Severity::Warn.name().into());
+        logger.emit(log_record);
     });
 
     log_benchmark_group(c, "full-log-with-4-attributes", |logger| {
-        logger.emit(
-            LogRecord::builder()
-                .with_body("full log")
-                .with_timestamp(now)
-                .with_observed_timestamp(now)
-                .with_severity_number(Severity::Warn)
-                .with_severity_text(Severity::Warn.name())
-                .with_attribute("name", "my-event-name")
-                .with_attribute("event.id", 20)
-                .with_attribute("user.name", "otel")
-                .with_attribute("user.email", "otel@opentelemetry.io")
-                .build(),
-        )
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("full log".into());
+        log_record.set_timestamp(now);
+        log_record.set_observed_timestamp(now);
+        log_record.set_severity_number(Severity::Warn);
+        log_record.set_severity_text(Severity::Warn.name().into());
+        log_record.add_attribute("name", "my-event-name");
+        log_record.add_attribute("event.id", 20);
+        log_record.add_attribute("user.name", "otel");
+        log_record.add_attribute("user.email", "otel@opentelemetry.io");
+        logger.emit(log_record);
     });
 
     log_benchmark_group(c, "full-log-with-9-attributes", |logger| {
-        logger.emit(
-            LogRecord::builder()
-                .with_body("full log")
-                .with_timestamp(now)
-                .with_observed_timestamp(now)
-                .with_severity_number(Severity::Warn)
-                .with_severity_text(Severity::Warn.name())
-                .with_attribute("name", "my-event-name")
-                .with_attribute("event.id", 20)
-                .with_attribute("user.name", "otel")
-                .with_attribute("user.email", "otel@opentelemetry.io")
-                .with_attribute("code.filename", "log.rs")
-                .with_attribute("code.filepath", "opentelemetry_sdk/benches/log.rs")
-                .with_attribute("code.lineno", 96)
-                .with_attribute("code.namespace", "opentelemetry_sdk::benches::log")
-                .with_attribute("log.target", "opentelemetry_sdk::benches::log")
-                .build(),
-        )
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("full log".into());
+        log_record.set_timestamp(now);
+        log_record.set_observed_timestamp(now);
+        log_record.set_severity_number(Severity::Warn);
+        log_record.set_severity_text(Severity::Warn.name().into());
+        log_record.add_attribute("name", "my-event-name");
+        log_record.add_attribute("event.id", 20);
+        log_record.add_attribute("user.name", "otel");
+        log_record.add_attribute("user.email", "otel@opentelemetry.io");
+        log_record.add_attribute("code.filename", "log.rs");
+        log_record.add_attribute("code.filepath", "opentelemetry_sdk/benches/log.rs");
+        log_record.add_attribute("code.lineno", 96);
+        log_record.add_attribute("code.namespace", "opentelemetry_sdk::benches::log");
+        log_record.add_attribute("log.target", "opentelemetry_sdk::benches::log");
+        logger.emit(log_record);
     });
 
     let attributes: Vec<(Key, AnyValue)> = vec![
@@ -260,16 +240,14 @@ fn criterion_benchmark(c: &mut Criterion) {
         ),
     ];
     log_benchmark_group(c, "full-log-with-attributes", |logger| {
-        logger.emit(
-            LogRecord::builder()
-                .with_body("full log")
-                .with_timestamp(now)
-                .with_observed_timestamp(now)
-                .with_severity_number(Severity::Warn)
-                .with_severity_text(Severity::Warn.name())
-                .with_attributes(attributes.clone())
-                .build(),
-        )
+        let mut log_record = logger.create_log_record();
+        log_record.set_body("full log".into());
+        log_record.set_timestamp(now);
+        log_record.set_observed_timestamp(now);
+        log_record.set_severity_number(Severity::Warn);
+        log_record.set_severity_text(Severity::Warn.name().into());
+        log_record.add_attributes(attributes.clone());
+        logger.emit(log_record);
     });
 }