make logrecord fields private

Author: lalitb

opentelemetry-proto/src/transform/logs.rs

@@ -58,8 +58,8 @@ pub mod tonic {
 
     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 {
+            let trace_context = log_record.trace_context();
+            let severity_number = match log_record.severity_number() {
                 Some(Severity::Trace) => SeverityNumber::Trace,
                 Some(Severity::Trace2) => SeverityNumber::Trace2,
                 Some(Severity::Trace3) => SeverityNumber::Trace3,
@@ -88,8 +88,8 @@ 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()),
+                time_unix_nano: log_record.timestamp().map(to_nanos).unwrap_or_default(),
+                observed_time_unix_nano: to_nanos(log_record.observed_timestamp().unwrap()),
                 attributes: {
                     let attributes: Vec<KeyValue> = log_record
                         .attributes_iter()
@@ -119,8 +119,11 @@ pub mod tonic {
                     attributes
                 },
                 severity_number: severity_number.into(),
-                severity_text: log_record.severity_text.map(Into::into).unwrap_or_default(),
-                body: log_record.body.clone().map(Into::into),
+                severity_text: log_record
+                    .severity_text()
+                    .map(Into::into)
+                    .unwrap_or_default(),
+                body: log_record.body().cloned().map(Into::into),
                 dropped_attributes_count: 0,
                 flags: trace_context
                     .map(|ctx| {
@@ -170,7 +173,7 @@ pub mod tonic {
                         .schema_url()
                         .map(ToOwned::to_owned)
                         .unwrap_or_default(),
-                    scope: Some((instrumentation, log_record.target.clone()).into()),
+                    scope: Some((instrumentation, log_record.target().cloned()).into()),
                     log_records: vec![log_record.into()],
                 }],
             }
@@ -193,8 +196,8 @@ pub mod tonic {
             >,
              (log_record, instrumentation)| {
                 let key = log_record
-                    .target
-                    .clone()
+                    .target()
+                    .cloned()
                     .unwrap_or_else(|| Cow::Owned(instrumentation.name().to_owned()));
                 scope_map
                     .entry(key)

opentelemetry-sdk/src/logs/record.rs

@@ -24,28 +24,28 @@ pub(crate) type LogRecordAttributes =
 /// 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<&'static str>,
+    pub(crate) event_name: Option<&'static str>,
 
     /// Target of the log record
-    pub target: Option<Cow<'static, str>>,
+    pub(crate) target: Option<Cow<'static, str>>,
 
     /// Record timestamp
-    pub timestamp: Option<SystemTime>,
+    pub(crate) timestamp: Option<SystemTime>,
 
     /// Timestamp for when the record was observed by OpenTelemetry
-    pub observed_timestamp: Option<SystemTime>,
+    pub(crate) observed_timestamp: Option<SystemTime>,
 
     /// Trace context for logs associated with spans
-    pub trace_context: Option<TraceContext>,
+    pub(crate) trace_context: Option<TraceContext>,
 
     /// The original severity string from the source
-    pub severity_text: Option<&'static str>,
+    pub(crate) severity_text: Option<&'static str>,
 
     /// The corresponding severity value, normalized
-    pub severity_number: Option<Severity>,
+    pub(crate) severity_number: Option<Severity>,
 
     /// Record body
-    pub body: Option<AnyValue>,
+    pub(crate) body: Option<AnyValue>,
 
     /// Additional attributes associated with this record
     pub(crate) attributes: LogRecordAttributes,
@@ -118,7 +118,56 @@ impl opentelemetry::logs::LogRecord for LogRecord {
 }
 
 impl LogRecord {
+    /// Returns the event name
+    #[inline]
+    pub fn event_name(&self) -> Option<&'static str> {
+        self.event_name
+    }
+
+    /// Returns the target
+    #[inline]
+    pub fn target(&self) -> Option<&Cow<'static, str>> {
+        self.target.as_ref()
+    }
+
+    /// Returns the timestamp
+    #[inline]
+    pub fn timestamp(&self) -> Option<SystemTime> {
+        self.timestamp
+    }
+
+    /// Returns the observed timestamp
+    #[inline]
+    pub fn observed_timestamp(&self) -> Option<SystemTime> {
+        self.observed_timestamp
+    }
+
+    /// Returns the trace context
+    #[inline]
+    pub fn trace_context(&self) -> Option<&TraceContext> {
+        self.trace_context.as_ref()
+    }
+
+    /// Returns the severity text
+    #[inline]
+    pub fn severity_text(&self) -> Option<&'static str> {
+        self.severity_text
+    }
+
+    /// Returns the severity number
+    #[inline]
+    pub fn severity_number(&self) -> Option<Severity> {
+        self.severity_number
+    }
+
+    /// Returns the body
+    #[inline]
+    pub fn body(&self) -> Option<&AnyValue> {
+        self.body.as_ref()
+    }
+
     /// Provides an iterator over the attributes.
+    #[inline]
     pub fn attributes_iter(&self) -> impl Iterator<Item = &(Key, AnyValue)> {
         self.attributes.iter().filter_map(|opt| opt.as_ref())
     }

opentelemetry-stdout/src/logs/exporter.rs

@@ -69,34 +69,34 @@ fn print_logs(batch: LogBatch<'_>) {
     for (i, log) in batch.iter().enumerate() {
         println!("Log #{}", i);
         let (record, _library) = log;
-        if let Some(event_name) = record.event_name {
+        if let Some(event_name) = record.event_name() {
             println!("\t EventName: {:?}", event_name);
         }
-        if let Some(target) = &record.target {
+        if let Some(target) = record.target() {
             println!("\t Target (Scope): {:?}", target);
         }
-        if let Some(trace_context) = &record.trace_context {
+        if let Some(trace_context) = record.trace_context() {
             println!("\t TraceId: {:?}", trace_context.trace_id);
             println!("\t SpanId: {:?}", trace_context.span_id);
         }
-        if let Some(timestamp) = record.timestamp {
+        if let Some(timestamp) = record.timestamp() {
             let datetime: DateTime<Utc> = timestamp.into();
             println!("\t Timestamp: {}", datetime.format("%Y-%m-%d %H:%M:%S%.6f"));
         }
-        if let Some(timestamp) = record.observed_timestamp {
+        if let Some(timestamp) = record.observed_timestamp() {
             let datetime: DateTime<Utc> = timestamp.into();
             println!(
                 "\t Observed Timestamp: {}",
                 datetime.format("%Y-%m-%d %H:%M:%S%.6f")
             );
         }
-        if let Some(severity) = record.severity_text {
+        if let Some(severity) = record.severity_text() {
             println!("\t SeverityText: {:?}", severity);
         }
-        if let Some(severity) = record.severity_number {
+        if let Some(severity) = record.severity_number() {
             println!("\t SeverityNumber: {:?}", severity);
         }
-        if let Some(body) = &record.body {
+        if let Some(body) = record.body() {
             println!("\t Body: {:?}", body);
         }