Rename LogRecord to SdkLogRecord (#2617)

Author: cijothomas

opentelemetry-appender-tracing/benches/logs.rs

@@ -18,7 +18,7 @@ use opentelemetry::InstrumentationScope;
 use opentelemetry_appender_tracing::layer as tracing_layer;
 use opentelemetry_sdk::logs::LogResult;
 use opentelemetry_sdk::logs::{LogBatch, LogExporter};
-use opentelemetry_sdk::logs::{LogProcessor, LogRecord, SdkLoggerProvider};
+use opentelemetry_sdk::logs::{LogProcessor, SdkLogRecord, SdkLoggerProvider};
 use opentelemetry_sdk::Resource;
 use pprof::criterion::{Output, PProfProfiler};
 use tracing::error;
@@ -57,7 +57,7 @@ impl<E: LogExporter> NoopProcessor<E> {
 }
 
 impl<E: LogExporter> LogProcessor for NoopProcessor<E> {
-    fn emit(&self, _: &mut LogRecord, _: &InstrumentationScope) {
+    fn emit(&self, _: &mut SdkLogRecord, _: &InstrumentationScope) {
         // no-op
     }
 

opentelemetry-appender-tracing/src/layer.rs

@@ -235,14 +235,14 @@ mod tests {
     use opentelemetry::{logs::AnyValue, Key};
     use opentelemetry_sdk::logs::InMemoryLogExporter;
     use opentelemetry_sdk::logs::{LogBatch, LogExporter};
-    use opentelemetry_sdk::logs::{LogRecord, LogResult, SdkLoggerProvider};
+    use opentelemetry_sdk::logs::{LogResult, SdkLogRecord, SdkLoggerProvider};
     use opentelemetry_sdk::trace::{Sampler, SdkTracerProvider};
     use tracing::{error, warn};
     use tracing_subscriber::prelude::__tracing_subscriber_SubscriberExt;
     use tracing_subscriber::util::SubscriberInitExt;
     use tracing_subscriber::{EnvFilter, Layer};
 
-    pub fn attributes_contains(log_record: &LogRecord, key: &Key, value: &AnyValue) -> bool {
+    pub fn attributes_contains(log_record: &SdkLogRecord, key: &Key, value: &AnyValue) -> bool {
         log_record
             .attributes_iter()
             .any(|(k, v)| k == key && v == value)

opentelemetry-proto/src/transform/logs.rs

@@ -56,8 +56,8 @@ pub mod tonic {
         }
     }
 
-    impl From<&opentelemetry_sdk::logs::LogRecord> for LogRecord {
-        fn from(log_record: &opentelemetry_sdk::logs::LogRecord) -> Self {
+    impl From<&opentelemetry_sdk::logs::SdkLogRecord> for LogRecord {
+        fn from(log_record: &opentelemetry_sdk::logs::SdkLogRecord) -> Self {
             let trace_context = log_record.trace_context();
             let severity_number = match log_record.severity_number() {
                 Some(Severity::Trace) => SeverityNumber::Trace,
@@ -129,7 +129,7 @@ pub mod tonic {
     impl
         From<(
             (
-                &opentelemetry_sdk::logs::LogRecord,
+                &opentelemetry_sdk::logs::SdkLogRecord,
                 &opentelemetry::InstrumentationScope,
             ),
             &ResourceAttributesWithSchema,
@@ -138,7 +138,7 @@ pub mod tonic {
         fn from(
             data: (
                 (
-                    &opentelemetry_sdk::logs::LogRecord,
+                    &opentelemetry_sdk::logs::SdkLogRecord,
                     &opentelemetry::InstrumentationScope,
                 ),
                 &ResourceAttributesWithSchema,
@@ -174,7 +174,7 @@ pub mod tonic {
             |mut scope_map: HashMap<
                 Cow<'static, str>,
                 Vec<(
-                    &opentelemetry_sdk::logs::LogRecord,
+                    &opentelemetry_sdk::logs::SdkLogRecord,
                     &opentelemetry::InstrumentationScope,
                 )>,
             >,
@@ -227,13 +227,13 @@ mod tests {
     use opentelemetry::InstrumentationScope;
     use opentelemetry_sdk::logs::LogProcessor;
     use opentelemetry_sdk::logs::{LogResult, SdkLoggerProvider};
-    use opentelemetry_sdk::{logs::LogBatch, logs::LogRecord, Resource};
+    use opentelemetry_sdk::{logs::LogBatch, logs::SdkLogRecord, Resource};
 
     #[derive(Debug)]
     struct MockProcessor;
 
     impl LogProcessor for MockProcessor {
-        fn emit(&self, _record: &mut LogRecord, _instrumentation: &InstrumentationScope) {}
+        fn emit(&self, _record: &mut SdkLogRecord, _instrumentation: &InstrumentationScope) {}
 
         fn force_flush(&self) -> LogResult<()> {
             Ok(())
@@ -247,7 +247,7 @@ mod tests {
     fn create_test_log_data(
         instrumentation_name: &str,
         _message: &str,
-    ) -> (LogRecord, InstrumentationScope) {
+    ) -> (SdkLogRecord, InstrumentationScope) {
         let processor = MockProcessor {};
         let logger = SdkLoggerProvider::builder()
             .with_log_processor(processor)

opentelemetry-sdk/CHANGELOG.md

@@ -401,8 +401,9 @@ let processor = BatchSpanProcessor::builder(exporter)
         fn TraerProvider::shutdown(&self) -> OTelSdkResult;
         fn TracerProvider::force_flush(&self) -> OTelSdkResult;
       ```
-- **Breaking** Renamed `LoggerProvider` and `Logger` to `SdkLoggerProvider` and
-  `SdkLogger` respectively to avoid name collision with public API types.
+- **Breaking** Renamed `LoggerProvider`, `Logger` and `LogRecord' to
+  `SdkLoggerProvider`, `SdkLogger` and `SdkLogRecord` respectively to avoid name
+  collision with public API types.
   [#2612](https://github.com/open-telemetry/opentelemetry-rust/pull/2612)
 
 - **Breaking** Renamed `TracerProvider` and `Tracer` to `SdkTracerProvider` and

opentelemetry-sdk/benches/log.rs

@@ -24,14 +24,16 @@ use opentelemetry::logs::{AnyValue, LogRecord as _, Logger, LoggerProvider, Seve
 use opentelemetry::trace::Tracer;
 use opentelemetry::trace::TracerProvider;
 use opentelemetry::{InstrumentationScope, Key};
-use opentelemetry_sdk::logs::{LogProcessor, LogRecord, LogResult, SdkLogger, SdkLoggerProvider};
+use opentelemetry_sdk::logs::{
+    LogProcessor, LogResult, SdkLogRecord, SdkLogger, SdkLoggerProvider,
+};
 use opentelemetry_sdk::trace::{Sampler, SdkTracerProvider};
 
 #[derive(Debug)]
 struct NoopProcessor;
 
 impl LogProcessor for NoopProcessor {
-    fn emit(&self, _data: &mut LogRecord, _scope: &InstrumentationScope) {}
+    fn emit(&self, _data: &mut SdkLogRecord, _scope: &InstrumentationScope) {}
 
     fn force_flush(&self) -> LogResult<()> {
         Ok(())

opentelemetry-sdk/benches/log_exporter.rs

@@ -22,7 +22,7 @@ use opentelemetry_sdk::logs::LogResult;
 use opentelemetry::InstrumentationScope;
 use opentelemetry_sdk::logs::LogBatch;
 use opentelemetry_sdk::logs::LogProcessor;
-use opentelemetry_sdk::logs::LogRecord;
+use opentelemetry_sdk::logs::SdkLogRecord;
 use opentelemetry_sdk::logs::SdkLoggerProvider;
 use pprof::criterion::{Output, PProfProfiler};
 use std::fmt::Debug;
@@ -66,9 +66,9 @@ impl ExportingProcessorWithFuture {
 }
 
 impl LogProcessor for ExportingProcessorWithFuture {
-    fn emit(&self, record: &mut LogRecord, scope: &InstrumentationScope) {
+    fn emit(&self, record: &mut SdkLogRecord, scope: &InstrumentationScope) {
         let mut exporter = self.exporter.lock().expect("lock error");
-        let logs = [(record as &LogRecord, scope)];
+        let logs = [(record as &SdkLogRecord, scope)];
         futures_executor::block_on(exporter.export(LogBatch::new(&logs)));
     }
 
@@ -95,8 +95,8 @@ impl ExportingProcessorWithoutFuture {
 }
 
 impl LogProcessor for ExportingProcessorWithoutFuture {
-    fn emit(&self, record: &mut LogRecord, scope: &InstrumentationScope) {
-        let logs = [(record as &LogRecord, scope)];
+    fn emit(&self, record: &mut SdkLogRecord, scope: &InstrumentationScope) {
+        let logs = [(record as &SdkLogRecord, scope)];
         self.exporter
             .lock()
             .expect("lock error")

opentelemetry-sdk/benches/log_processor.rs

@@ -22,12 +22,14 @@ use opentelemetry::{
     logs::{LogRecord as _, Logger, LoggerProvider, Severity},
     InstrumentationScope,
 };
-use opentelemetry_sdk::logs::{LogProcessor, LogRecord, LogResult, SdkLogger, SdkLoggerProvider};
+use opentelemetry_sdk::logs::{
+    LogProcessor, LogResult, SdkLogRecord, SdkLogger, SdkLoggerProvider,
+};
 
 // Run this benchmark with:
 // cargo bench --bench log_processor
 
-fn create_log_record(logger: &SdkLogger) -> LogRecord {
+fn create_log_record(logger: &SdkLogger) -> SdkLogRecord {
     let mut log_record = logger.create_log_record();
     let now = now();
     log_record.set_observed_timestamp(now);
@@ -45,7 +47,7 @@ fn create_log_record(logger: &SdkLogger) -> LogRecord {
 struct NoopProcessor;
 
 impl LogProcessor for NoopProcessor {
-    fn emit(&self, _data: &mut LogRecord, _scope: &InstrumentationScope) {}
+    fn emit(&self, _data: &mut SdkLogRecord, _scope: &InstrumentationScope) {}
 
     fn force_flush(&self) -> LogResult<()> {
         Ok(())
@@ -60,7 +62,7 @@ impl LogProcessor for NoopProcessor {
 struct CloningProcessor;
 
 impl LogProcessor for CloningProcessor {
-    fn emit(&self, data: &mut LogRecord, _scope: &InstrumentationScope) {
+    fn emit(&self, data: &mut SdkLogRecord, _scope: &InstrumentationScope) {
         let _data_cloned = data.clone();
     }
 
@@ -75,8 +77,8 @@ impl LogProcessor for CloningProcessor {
 
 #[derive(Debug)]
 struct SendToChannelProcessor {
-    sender: std::sync::mpsc::Sender<(LogRecord, InstrumentationScope)>,
-    receiver: Arc<Mutex<std::sync::mpsc::Receiver<(LogRecord, InstrumentationScope)>>>,
+    sender: std::sync::mpsc::Sender<(SdkLogRecord, InstrumentationScope)>,
+    receiver: Arc<Mutex<std::sync::mpsc::Receiver<(SdkLogRecord, InstrumentationScope)>>>,
 }
 
 impl SendToChannelProcessor {
@@ -103,7 +105,7 @@ impl SendToChannelProcessor {
 }
 
 impl LogProcessor for SendToChannelProcessor {
-    fn emit(&self, record: &mut LogRecord, scope: &InstrumentationScope) {
+    fn emit(&self, record: &mut SdkLogRecord, scope: &InstrumentationScope) {
         let res = self.sender.send((record.clone(), scope.clone()));
         if res.is_err() {
             println!("Error sending log data to channel {0}", res.err().unwrap());

opentelemetry-sdk/src/logs/export.rs

@@ -1,5 +1,5 @@
 //! Log exporters
-use crate::logs::LogRecord;
+use crate::logs::SdkLogRecord;
 use crate::logs::{LogError, LogResult};
 use crate::Resource;
 #[cfg(feature = "spec_unstable_logs_enabled")]
@@ -27,8 +27,8 @@ pub struct LogBatch<'a> {
 /// - Or it can be a shared reference to a slice of tuples, where each tuple consists of a reference to a `LogRecord` and a reference to an `InstrumentationScope`.
 #[derive(Debug)]
 enum LogBatchData<'a> {
-    SliceOfOwnedData(&'a [Box<(LogRecord, InstrumentationScope)>]), // Used by BatchProcessor which clones the LogRecords for its own use.
-    SliceOfBorrowedData(&'a [(&'a LogRecord, &'a InstrumentationScope)]),
+    SliceOfOwnedData(&'a [Box<(SdkLogRecord, InstrumentationScope)>]), // Used by BatchProcessor which clones the LogRecords for its own use.
+    SliceOfBorrowedData(&'a [(&'a SdkLogRecord, &'a InstrumentationScope)]),
 }
 
 impl<'a> LogBatch<'a> {
@@ -46,14 +46,14 @@ impl<'a> LogBatch<'a> {
     ///
     /// Note - this is not a public function, and should not be used directly. This would be
     /// made private in the future.
-    pub fn new(data: &'a [(&'a LogRecord, &'a InstrumentationScope)]) -> LogBatch<'a> {
+    pub fn new(data: &'a [(&'a SdkLogRecord, &'a InstrumentationScope)]) -> LogBatch<'a> {
         LogBatch {
             data: LogBatchData::SliceOfBorrowedData(data),
         }
     }
 
     pub(crate) fn new_with_owned_data(
-        data: &'a [Box<(LogRecord, InstrumentationScope)>],
+        data: &'a [Box<(SdkLogRecord, InstrumentationScope)>],
     ) -> LogBatch<'a> {
         LogBatch {
             data: LogBatchData::SliceOfOwnedData(data),
@@ -71,7 +71,7 @@ impl LogBatch<'_> {
     ///
     /// An iterator that yields references to the `LogRecord` and `InstrumentationScope` in the batch.
     ///
-    pub fn iter(&self) -> impl Iterator<Item = (&LogRecord, &InstrumentationScope)> {
+    pub fn iter(&self) -> impl Iterator<Item = (&SdkLogRecord, &InstrumentationScope)> {
         LogBatchDataIter {
             data: &self.data,
             index: 0,
@@ -85,7 +85,7 @@ struct LogBatchDataIter<'a> {
 }
 
 impl<'a> Iterator for LogBatchDataIter<'a> {
-    type Item = (&'a LogRecord, &'a InstrumentationScope);
+    type Item = (&'a SdkLogRecord, &'a InstrumentationScope);
 
     fn next(&mut self) -> Option<Self::Item> {
         match self.data {

opentelemetry-sdk/src/logs/in_memory_exporter.rs

@@ -1,4 +1,4 @@
-use crate::logs::LogRecord;
+use crate::logs::SdkLogRecord;
 use crate::logs::{LogBatch, LogError, LogExporter, LogResult};
 use crate::Resource;
 use opentelemetry::InstrumentationScope;
@@ -51,17 +51,17 @@ impl Default for InMemoryLogExporter {
 #[derive(Debug, Clone)]
 pub struct OwnedLogData {
     /// Log record, which can be borrowed or owned.
-    pub record: LogRecord,
+    pub record: SdkLogRecord,
     /// Instrumentation details for the emitter who produced this `LogEvent`.
     pub instrumentation: InstrumentationScope,
 }
 
-/// `LogDataWithResource` associates a [`LogRecord`] with a [`Resource`] and
+/// `LogDataWithResource` associates a [`SdkLogRecord`] with a [`Resource`] and
 /// [`InstrumentationScope`].
 #[derive(Clone, Debug)]
 pub struct LogDataWithResource {
     /// Log record
-    pub record: LogRecord,
+    pub record: SdkLogRecord,
     /// Instrumentation details for the emitter who produced this `LogRecord`.
     pub instrumentation: InstrumentationScope,
     /// Resource for the emitter who produced this `LogRecord`.