Separate logger and loggerprovider mod (#2633)

opentelemetry-sdk/src/logs/logger.rs

@@ -0,0 +1,67 @@
+use super::{SdkLogRecord, SdkLoggerProvider, TraceContext};
+use opentelemetry::{trace::TraceContextExt, Context, InstrumentationScope};
+
+#[cfg(feature = "spec_unstable_logs_enabled")]
+use opentelemetry::logs::Severity;
+use opentelemetry::time::now;
+
+#[derive(Debug)]
+/// The object for emitting [`LogRecord`]s.
+///
+/// [`LogRecord`]: opentelemetry::logs::LogRecord
+pub struct SdkLogger {
+    scope: InstrumentationScope,
+    provider: SdkLoggerProvider,
+}
+
+impl SdkLogger {
+    pub(crate) fn new(scope: InstrumentationScope, provider: SdkLoggerProvider) -> Self {
+        SdkLogger { scope, provider }
+    }
+
+    #[cfg(test)]
+    pub(crate) fn instrumentation_scope(&self) -> &InstrumentationScope {
+        &self.scope
+    }
+}
+
+impl opentelemetry::logs::Logger for SdkLogger {
+    type LogRecord = SdkLogRecord;
+
+    fn create_log_record(&self) -> Self::LogRecord {
+        SdkLogRecord::new()
+    }
+
+    /// Emit a `LogRecord`.
+    fn emit(&self, mut record: Self::LogRecord) {
+        let provider = &self.provider;
+        let processors = provider.log_processors();
+
+        //let mut log_record = record;
+        if record.trace_context.is_none() {
+            let trace_context = Context::map_current(|cx| {
+                cx.has_active_span()
+                    .then(|| TraceContext::from(cx.span().span_context()))
+            });
+
+            if let Some(ref trace_context) = trace_context {
+                record.trace_context = Some(trace_context.clone());
+            }
+        }
+        if record.observed_timestamp.is_none() {
+            record.observed_timestamp = Some(now());
+        }
+
+        for p in processors {
+            p.emit(&mut record, &self.scope);
+        }
+    }
+
+    #[cfg(feature = "spec_unstable_logs_enabled")]
+    fn event_enabled(&self, level: Severity, target: &str) -> bool {
+        self.provider
+            .log_processors()
+            .iter()
+            .any(|processor| processor.event_enabled(level, target, self.scope.name().as_ref()))
+    }
+}

opentelemetry-sdk/src/logs/logger_provider.rs

@@ -1,13 +1,8 @@
-use super::{BatchLogProcessor, LogProcessor, SdkLogRecord, SimpleLogProcessor, TraceContext};
+use super::{BatchLogProcessor, LogProcessor, SdkLogger, SimpleLogProcessor};
 use crate::error::{OTelSdkError, OTelSdkResult};
 use crate::logs::LogExporter;
 use crate::Resource;
-use opentelemetry::{otel_debug, otel_info, trace::TraceContextExt, Context, InstrumentationScope};
-
-#[cfg(feature = "spec_unstable_logs_enabled")]
-use opentelemetry::logs::Severity;
-
-use opentelemetry::time::now;
+use opentelemetry::{otel_debug, otel_info, InstrumentationScope};
 use std::{
     borrow::Cow,
     sync::{
@@ -271,71 +266,10 @@ impl LoggerProviderBuilder {
     }
 }
 
-#[derive(Debug)]
-/// The object for emitting [`LogRecord`]s.
-///
-/// [`LogRecord`]: opentelemetry::logs::LogRecord
-pub struct SdkLogger {
-    scope: InstrumentationScope,
-    provider: SdkLoggerProvider,
-}
-
-impl SdkLogger {
-    pub(crate) fn new(scope: InstrumentationScope, provider: SdkLoggerProvider) -> Self {
-        SdkLogger { scope, provider }
-    }
-
-    #[cfg(test)]
-    pub(crate) fn instrumentation_scope(&self) -> &InstrumentationScope {
-        &self.scope
-    }
-}
-
-impl opentelemetry::logs::Logger for SdkLogger {
-    type LogRecord = SdkLogRecord;
-
-    fn create_log_record(&self) -> Self::LogRecord {
-        SdkLogRecord::new()
-    }
-
-    /// Emit a `LogRecord`.
-    fn emit(&self, mut record: Self::LogRecord) {
-        let provider = &self.provider;
-        let processors = provider.log_processors();
-
-        //let mut log_record = record;
-        if record.trace_context.is_none() {
-            let trace_context = Context::map_current(|cx| {
-                cx.has_active_span()
-                    .then(|| TraceContext::from(cx.span().span_context()))
-            });
-
-            if let Some(ref trace_context) = trace_context {
-                record.trace_context = Some(trace_context.clone());
-            }
-        }
-        if record.observed_timestamp.is_none() {
-            record.observed_timestamp = Some(now());
-        }
-
-        for p in processors {
-            p.emit(&mut record, &self.scope);
-        }
-    }
-
-    #[cfg(feature = "spec_unstable_logs_enabled")]
-    fn event_enabled(&self, level: Severity, target: &str) -> bool {
-        self.provider
-            .log_processors()
-            .iter()
-            .any(|processor| processor.event_enabled(level, target, self.scope.name().as_ref()))
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use crate::{
-        logs::InMemoryLogExporter,
+        logs::{InMemoryLogExporter, SdkLogRecord, TraceContext},
         resource::{
             SERVICE_NAME, TELEMETRY_SDK_LANGUAGE, TELEMETRY_SDK_NAME, TELEMETRY_SDK_VERSION,
         },
@@ -344,8 +278,11 @@ mod tests {
     };
 
     use super::*;
-    use opentelemetry::logs::{AnyValue, LogRecord as _, Logger, LoggerProvider};
     use opentelemetry::trace::{SpanId, TraceId, Tracer as _, TracerProvider};
+    use opentelemetry::{
+        logs::{AnyValue, LogRecord as _, Logger, LoggerProvider},
+        trace::TraceContextExt,
+    };
     use opentelemetry::{Key, KeyValue, Value};
     use std::fmt::{Debug, Formatter};
     use std::sync::atomic::AtomicU64;
@@ -765,14 +702,14 @@ mod tests {
             emitted_logs[0].clone().record.body,
             Some(AnyValue::String("Testing empty logger name".into()))
         );
-        assert_eq!(logger.scope.name(), "");
+        assert_eq!(logger.instrumentation_scope().name(), "");
 
         // Assert the second log created through the scope
         assert_eq!(
             emitted_logs[1].clone().record.body,
             Some(AnyValue::String("Testing empty logger scope name".into()))
         );
-        assert_eq!(scoped_logger.scope.name(), "");
+        assert_eq!(scoped_logger.instrumentation_scope().name(), "");
     }
 
     #[derive(Debug)]

opentelemetry-sdk/src/logs/mod.rs

@@ -2,6 +2,7 @@
 mod error;
 mod export;
 mod log_processor;
+mod logger;
 mod logger_provider;
 pub(crate) mod record;
 
@@ -19,7 +20,8 @@ pub use log_processor::{
     BatchConfig, BatchConfigBuilder, BatchLogProcessor, BatchLogProcessorBuilder, LogProcessor,
     SimpleLogProcessor,
 };
-pub use logger_provider::{LoggerProviderBuilder, SdkLogger, SdkLoggerProvider};
+pub use logger::SdkLogger;
+pub use logger_provider::{LoggerProviderBuilder, SdkLoggerProvider};
 pub use record::{SdkLogRecord, TraceContext};
 
 #[cfg(feature = "experimental_logs_batch_log_processor_with_async_runtime")]