Merge branch 'main' into update-tracing-version

Author: lalitb

opentelemetry-appender-log/src/lib.rs

@@ -846,11 +846,11 @@ mod tests {
 
         assert_eq!(logs.len(), 5);
         for log in logs {
-            let body: String = match log.record.body.as_ref().unwrap() {
+            let body: String = match log.record.body().unwrap() {
                 super::AnyValue::String(s) => s.to_string(),
                 _ => panic!("AnyValue::String expected"),
             };
-            assert_eq!(body, log.record.severity_text.unwrap());
+            assert_eq!(body, log.record.severity_text().unwrap());
         }
     }
 

opentelemetry-appender-tracing/src/layer.rs

@@ -334,10 +334,10 @@ mod tests {
 
         // Validate common fields
         assert_eq!(log.instrumentation.name(), "opentelemetry-appender-tracing");
-        assert_eq!(log.record.severity_number, Some(Severity::Error));
+        assert_eq!(log.record.severity_number(), Some(Severity::Error));
 
         // Validate trace context is none.
-        assert!(log.record.trace_context.is_none());
+        assert!(log.record.trace_context().is_none());
 
         // Validate attributes
         #[cfg(not(feature = "experimental_metadata_attributes"))]
@@ -428,25 +428,20 @@ mod tests {
 
         // validate common fields.
         assert_eq!(log.instrumentation.name(), "opentelemetry-appender-tracing");
-        assert_eq!(log.record.severity_number, Some(Severity::Error));
+        assert_eq!(log.record.severity_number(), Some(Severity::Error));
 
         // validate trace context.
-        assert!(log.record.trace_context.is_some());
+        assert!(log.record.trace_context().is_some());
         assert_eq!(
-            log.record.trace_context.as_ref().unwrap().trace_id,
+            log.record.trace_context().unwrap().trace_id,
             trace_id_expected
         );
         assert_eq!(
-            log.record.trace_context.as_ref().unwrap().span_id,
+            log.record.trace_context().unwrap().span_id,
             span_id_expected
         );
         assert_eq!(
-            log.record
-                .trace_context
-                .as_ref()
-                .unwrap()
-                .trace_flags
-                .unwrap(),
+            log.record.trace_context().unwrap().trace_flags.unwrap(),
             TraceFlags::SAMPLED
         );
 
@@ -526,10 +521,10 @@ mod tests {
 
         // Validate common fields
         assert_eq!(log.instrumentation.name(), "opentelemetry-appender-tracing");
-        assert_eq!(log.record.severity_number, Some(Severity::Error));
+        assert_eq!(log.record.severity_number(), Some(Severity::Error));
 
         // Validate trace context is none.
-        assert!(log.record.trace_context.is_none());
+        assert!(log.record.trace_context().is_none());
 
         // Attributes can be polluted when we don't use this feature.
         #[cfg(feature = "experimental_metadata_attributes")]
@@ -605,25 +600,20 @@ mod tests {
 
         // validate common fields.
         assert_eq!(log.instrumentation.name(), "opentelemetry-appender-tracing");
-        assert_eq!(log.record.severity_number, Some(Severity::Error));
+        assert_eq!(log.record.severity_number(), Some(Severity::Error));
 
         // validate trace context.
-        assert!(log.record.trace_context.is_some());
+        assert!(log.record.trace_context().is_some());
         assert_eq!(
-            log.record.trace_context.as_ref().unwrap().trace_id,
+            log.record.trace_context().unwrap().trace_id,
             trace_id_expected
         );
         assert_eq!(
-            log.record.trace_context.as_ref().unwrap().span_id,
+            log.record.trace_context().unwrap().span_id,
             span_id_expected
         );
         assert_eq!(
-            log.record
-                .trace_context
-                .as_ref()
-                .unwrap()
-                .trace_flags
-                .unwrap(),
+            log.record.trace_context().unwrap().trace_flags.unwrap(),
             TraceFlags::SAMPLED
         );
 

opentelemetry-otlp/src/lib.rs

@@ -162,7 +162,7 @@
 //!                 .with_max_events_per_span(64)
 //!                 .with_max_attributes_per_span(16)
 //!                 .with_max_events_per_span(16)
-//!                 .with_resource(Resource::builder_empty().with_attributes(vec![KeyValue::new("service.name", "example")]).build()),
+//!                 .with_resource(Resource::builder_empty().with_attributes([KeyValue::new("service.name", "example")]).build()),
 //!         ).build();
 //!     global::set_tracer_provider(tracer_provider);
 //!     let tracer = global::tracer("tracer-name");
@@ -186,7 +186,7 @@
 //!
 //!    let provider = opentelemetry_sdk::metrics::SdkMeterProvider::builder()
 //!        .with_reader(reader)
-//!         .with_resource(Resource::builder_empty().with_attributes(vec![KeyValue::new("service.name", "example")]).build())
+//!         .with_resource(Resource::builder_empty().with_attributes([KeyValue::new("service.name", "example")]).build())
 //!         .build();
 //!     # }
 //!

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()
@@ -102,7 +102,7 @@ pub mod tonic {
                         .collect();
                     #[cfg(feature = "populate-logs-event-name")]
                     {
-                        if let Some(event_name) = &log_record.event_name {
+                        if let Some(event_name) = &log_record.event_name() {
                             let mut attributes_with_name = attributes;
                             attributes_with_name.push(KeyValue {
                                 key: "event.name".into(),
@@ -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/CHANGELOG.md

@@ -96,6 +96,12 @@
   - Bump msrv to 1.75.0.
 
 
+- *Breaking* : [#2314](https://github.com/open-telemetry/opentelemetry-rust/pull/2314)
+  - The LogRecord struct has been updated:
+    - All fields are now pub(crate) instead of pub.
+    - Getter methods have been introduced to access field values.
+    This change impacts custom exporter and processor developers by requiring updates to code that directly accessed LogRecord fields. They must now use the provided getter methods (e.g., `log_record.event_name()` instead of `log_record.event_name`).
+
 ## 0.27.1
 
 Released 2024-Nov-27

opentelemetry-sdk/src/logs/log_emitter.rs

@@ -448,7 +448,7 @@ mod tests {
                 let user_provided_resource_config_provider = super::LoggerProvider::builder()
                     .with_resource(
                         Resource::builder()
-                            .with_attributes(vec![
+                            .with_attributes([
                                 KeyValue::new("my-custom-key", "my-custom-value"),
                                 KeyValue::new("my-custom-key2", "my-custom-value2"),
                             ])

opentelemetry-sdk/src/logs/log_processor.rs

@@ -769,7 +769,7 @@ mod tests {
             .with_log_processor(processor)
             .with_resource(
                 Resource::builder_empty()
-                    .with_attributes(vec![
+                    .with_attributes([
                         KeyValue::new("k1", "v1"),
                         KeyValue::new("k2", "v3"),
                         KeyValue::new("k3", "v3"),
@@ -796,7 +796,7 @@ mod tests {
             .with_log_processor(processor)
             .with_resource(
                 Resource::builder_empty()
-                    .with_attributes(vec![
+                    .with_attributes([
                         KeyValue::new("k1", "v1"),
                         KeyValue::new("k2", "v3"),
                         KeyValue::new("k3", "v3"),

opentelemetry-sdk/src/logs/mod.rs

@@ -28,7 +28,7 @@ mod tests {
     fn logging_sdk_test() {
         // Arrange
         let resource = Resource::builder_empty()
-            .with_attributes(vec![
+            .with_attributes([
                 KeyValue::new("k1", "v1"),
                 KeyValue::new("k2", "v2"),
                 KeyValue::new("k3", "v3"),

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-sdk/src/metrics/internal/aggregate.rs

@@ -1,4 +1,10 @@
-use std::{marker, sync::Arc};
+use std::{
+    marker,
+    mem::replace,
+    ops::DerefMut,
+    sync::{Arc, Mutex},
+    time::SystemTime,
+};
 
 use opentelemetry::KeyValue;
 
@@ -53,6 +59,44 @@ where
     }
 }
 
+pub(crate) struct AggregateTime {
+    pub start: SystemTime,
+    pub current: SystemTime,
+}
+
+/// Initialized [`AggregateTime`] for specific [`Temporality`]
+pub(crate) struct AggregateTimeInitiator(Mutex<SystemTime>);
+
+impl AggregateTimeInitiator {
+    pub(crate) fn delta(&self) -> AggregateTime {
+        let current_time = SystemTime::now();
+        let start_time = self
+            .0
+            .lock()
+            .map(|mut start| replace(start.deref_mut(), current_time))
+            .unwrap_or(current_time);
+        AggregateTime {
+            start: start_time,
+            current: current_time,
+        }
+    }
+
+    pub(crate) fn cumulative(&self) -> AggregateTime {
+        let current_time = SystemTime::now();
+        let start_time = self.0.lock().map(|start| *start).unwrap_or(current_time);
+        AggregateTime {
+            start: start_time,
+            current: current_time,
+        }
+    }
+}
+
+impl Default for AggregateTimeInitiator {
+    fn default() -> Self {
+        Self(Mutex::new(SystemTime::now()))
+    }
+}
+
 /// Builds aggregate functions
 pub(crate) struct AggregateBuilder<T> {
     /// The temporality used for the returned aggregate functions.