fix logrecord move leftovers

Author: lalitb

opentelemetry-proto/src/transform/logs.rs

@@ -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.unwrap()),
+                observed_time_unix_nano: to_nanos(log_record.observed_timestamp),
                 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/src/logs/record.rs

@@ -5,16 +5,19 @@ use opentelemetry::{
 };
 use std::{borrow::Cow, time::SystemTime};
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 #[non_exhaustive]
 /// LogRecord represents all data carried by a log record, and
 /// is provided to `LogExporter`s as input.
 pub struct LogRecord {
+    /// Event name. Optional as not all the logging API support it.
+    pub event_name: Option<Cow<'static, str>>,
+
     /// Record timestamp
     pub timestamp: Option<SystemTime>,
 
     /// Timestamp for when the record was observed by OpenTelemetry
-    pub observed_timestamp: Option<SystemTime>,
+    pub observed_timestamp: SystemTime,
 
     /// Trace context for logs associated with spans
     pub trace_context: Option<TraceContext>,
@@ -31,13 +34,35 @@ pub struct LogRecord {
     pub attributes: Option<Vec<(Key, AnyValue)>>,
 }
 
+impl Default for LogRecord {
+    fn default() -> Self {
+        LogRecord {
+            event_name: None,
+            timestamp: None,
+            observed_timestamp: SystemTime::now(),
+            trace_context: None,
+            severity_text: None,
+            severity_number: None,
+            body: None,
+            attributes: None,
+        }
+    }
+}
+
 impl opentelemetry::logs::LogRecord for LogRecord {
+    fn set_event_name<T>(&mut self, name: T)
+    where
+        T: Into<Cow<'static, str>>,
+    {
+        self.event_name = Some(name.into());
+    }
+
     fn set_timestamp(&mut self, timestamp: SystemTime) {
         self.timestamp = Some(timestamp);
     }
 
     fn set_observed_timestamp(&mut self, timestamp: SystemTime) {
-        self.observed_timestamp = Some(timestamp);
+        self.observed_timestamp = timestamp;
     }
 
     fn set_severity_text(&mut self, severity_text: Cow<'static, str>) {
@@ -112,7 +137,7 @@ mod tests {
         let mut log_record = LogRecord::default();
         let now = SystemTime::now();
         log_record.set_observed_timestamp(now);
-        assert_eq!(log_record.observed_timestamp, Some(now));
+        assert_eq!(log_record.observed_timestamp, now);
     }
 
     #[test]

opentelemetry-stdout/src/logs/transform.rs

@@ -125,8 +125,8 @@ impl From<opentelemetry_sdk::export::logs::LogData> for LogRecord {
                 .unwrap_or_default(),
             time_unix_nano: value.record.timestamp,
             time: value.record.timestamp,
-            observed_time_unix_nano: value.record.observed_timestamp.unwrap(),
-            observed_time: value.record.observed_timestamp.unwrap(),
+            observed_time_unix_nano: value.record.observed_timestamp,
+            observed_time: value.record.observed_timestamp,
             severity_number: value
                 .record
                 .severity_number

opentelemetry/src/logs/noop.rs

@@ -41,6 +41,12 @@ pub struct NoopLogRecord;
 impl LogRecord for NoopLogRecord {
     // Implement the LogRecord trait methods with empty bodies.
     #[inline]
+    fn set_event_name<T>(&mut self, _name: T)
+    where
+        T: Into<Cow<'static, str>>,
+    {
+    }
+    #[inline]
     fn set_timestamp(&mut self, _timestamp: SystemTime) {}
     #[inline]
     fn set_observed_timestamp(&mut self, _timestamp: SystemTime) {}

opentelemetry/src/logs/record.rs

@@ -3,6 +3,11 @@ use std::{borrow::Cow, collections::HashMap, time::SystemTime};
 
 /// SDK implemented trait for managing log records
 pub trait LogRecord {
+    /// Sets the `event_name` of a record
+    fn set_event_name<T>(&mut self, name: T)
+    where
+        T: Into<Cow<'static, str>>;
+
     /// Sets the time when the event occurred measured by the origin clock, i.e. the time at the source.
     fn set_timestamp(&mut self, timestamp: SystemTime);