Keep shared mock in log_processor

Author: drewrelmas

opentelemetry-sdk/src/logs/batch_log_processor.rs

@@ -715,6 +715,7 @@ impl BatchConfigBuilder {
 
 #[cfg(all(test, feature = "testing", feature = "logs"))]
 mod tests {
+    use crate::logs::log_processor::tests::MockLogExporter;
     use super::{
         BatchConfig, BatchConfigBuilder, BatchLogProcessor, OTEL_BLRP_MAX_EXPORT_BATCH_SIZE,
         OTEL_BLRP_MAX_EXPORT_BATCH_SIZE_DEFAULT, OTEL_BLRP_MAX_QUEUE_SIZE,
@@ -723,9 +724,8 @@ mod tests {
     };
     #[cfg(feature = "experimental_logs_batch_log_processor_with_async_runtime")]
     use super::{OTEL_BLRP_EXPORT_TIMEOUT, OTEL_BLRP_EXPORT_TIMEOUT_DEFAULT};
-    use crate::logs::{LogBatch, LogExporter, SdkLogRecord};
+    use crate::logs::SdkLogRecord;
     use crate::{
-        error::OTelSdkResult,
         logs::{InMemoryLogExporter, InMemoryLogExporterBuilder, LogProcessor, SdkLoggerProvider},
         Resource,
     };
@@ -734,41 +734,6 @@ mod tests {
     use std::sync::{Arc, Mutex};
     use std::time::Duration;
 
-    #[derive(Debug, Clone)]
-    struct MockLogExporter {
-        resource: Arc<Mutex<Option<Resource>>>,
-    }
-
-    impl LogExporter for MockLogExporter {
-        #[allow(clippy::manual_async_fn)]
-        fn export(
-            &self,
-            _batch: LogBatch<'_>,
-        ) -> impl std::future::Future<Output = OTelSdkResult> + Send {
-            async { Ok(()) }
-        }
-
-        fn shutdown(&mut self) -> OTelSdkResult {
-            Ok(())
-        }
-
-        fn set_resource(&mut self, resource: &Resource) {
-            self.resource
-                .lock()
-                .map(|mut res_opt| {
-                    res_opt.replace(resource.clone());
-                })
-                .expect("mock log exporter shouldn't error when setting resource");
-        }
-    }
-
-    // Implementation specific to the MockLogExporter, not part of the LogExporter trait
-    impl MockLogExporter {
-        fn get_resource(&self) -> Option<Resource> {
-            (*self.resource).lock().unwrap().clone()
-        }
-    }
-
     #[test]
     fn test_default_const_values() {
         assert_eq!(OTEL_BLRP_SCHEDULE_DELAY, "OTEL_BLRP_SCHEDULE_DELAY");

opentelemetry-sdk/src/logs/log_processor.rs

@@ -69,8 +69,9 @@ pub trait LogProcessor: Send + Sync + Debug {
 }
 
 #[cfg(all(test, feature = "testing", feature = "logs"))]
-mod tests {
-    use crate::logs::SdkLogRecord;
+pub(crate) mod tests {
+    use crate::logs::{LogBatch, LogExporter, SdkLogRecord};
+    use crate::Resource;
     use crate::{
         error::OTelSdkResult,
         logs::{LogProcessor, SdkLoggerProvider},
@@ -81,6 +82,41 @@ mod tests {
     use opentelemetry::{InstrumentationScope, Key};
     use std::sync::{Arc, Mutex};
 
+    #[derive(Debug, Clone)]
+    pub(crate) struct MockLogExporter {
+        pub resource: Arc<Mutex<Option<Resource>>>,
+    }
+
+    impl LogExporter for MockLogExporter {
+        #[allow(clippy::manual_async_fn)]
+        fn export(
+            &self,
+            _batch: LogBatch<'_>,
+        ) -> impl std::future::Future<Output = OTelSdkResult> + Send {
+            async { Ok(()) }
+        }
+
+        fn shutdown(&mut self) -> OTelSdkResult {
+            Ok(())
+        }
+
+        fn set_resource(&mut self, resource: &Resource) {
+            self.resource
+                .lock()
+                .map(|mut res_opt| {
+                    res_opt.replace(resource.clone());
+                })
+                .expect("mock log exporter shouldn't error when setting resource");
+        }
+    }
+
+    // Implementation specific to the MockLogExporter, not part of the LogExporter trait
+    impl MockLogExporter {
+        pub(crate) fn get_resource(&self) -> Option<Resource> {
+            (*self.resource).lock().unwrap().clone()
+        }
+    }
+
     #[derive(Debug)]
     struct FirstProcessor {
         pub(crate) logs: Arc<Mutex<Vec<(SdkLogRecord, InstrumentationScope)>>>,

opentelemetry-sdk/src/logs/simple_log_processor.rs

@@ -135,6 +135,7 @@ impl<T: LogExporter> LogProcessor for SimpleLogProcessor<T> {
 
 #[cfg(all(test, feature = "testing", feature = "logs"))]
 mod tests {
+    use crate::logs::log_processor::tests::MockLogExporter;
     use crate::logs::{LogBatch, LogExporter, SdkLogRecord};
     use crate::{
         error::OTelSdkResult,
@@ -147,41 +148,6 @@ mod tests {
     use std::sync::{Arc, Mutex};
     use std::time::Duration;
 
-    #[derive(Debug, Clone)]
-    struct MockLogExporter {
-        resource: Arc<Mutex<Option<Resource>>>,
-    }
-
-    impl LogExporter for MockLogExporter {
-        #[allow(clippy::manual_async_fn)]
-        fn export(
-            &self,
-            _batch: LogBatch<'_>,
-        ) -> impl std::future::Future<Output = OTelSdkResult> + Send {
-            async { Ok(()) }
-        }
-
-        fn shutdown(&mut self) -> OTelSdkResult {
-            Ok(())
-        }
-
-        fn set_resource(&mut self, resource: &Resource) {
-            self.resource
-                .lock()
-                .map(|mut res_opt| {
-                    res_opt.replace(resource.clone());
-                })
-                .expect("mock log exporter shouldn't error when setting resource");
-        }
-    }
-
-    // Implementation specific to the MockLogExporter, not part of the LogExporter trait
-    impl MockLogExporter {
-        fn get_resource(&self) -> Option<Resource> {
-            (*self.resource).lock().unwrap().clone()
-        }
-    }
-
     #[derive(Debug, Clone)]
     struct LogExporterThatRequiresTokio {
         export_count: Arc<AtomicUsize>,