fmt

Author: lalitb

opentelemetry-otlp/src/exporter/http/logs.rs

@@ -20,8 +20,9 @@ impl LogExporter for OtlpHttpClient {
             })?;
 
         //TBD :avoid cloning and work only on borrowed logdata
-        let owned_batch = batch.into_iter()
-            .map(|cow_log_data| cow_log_data.into_owned())  // Converts Cow to owned LogData
+        let owned_batch = batch
+            .into_iter()
+            .map(|cow_log_data| cow_log_data.into_owned()) // Converts Cow to owned LogData
             .collect::<Vec<LogData>>();
 
         let (body, content_type) = { self.build_logs_export_body(owned_batch, &self.resource)? };

opentelemetry-otlp/src/logs.rs

@@ -98,7 +98,10 @@ impl LogExporter {
 
 #[async_trait]
 impl opentelemetry_sdk::export::logs::LogExporter for LogExporter {
-    async fn export<'a>(&mut self, batch: Vec<std::borrow::Cow<'a, LogData>>) -> opentelemetry::logs::LogResult<()> {
+    async fn export<'a>(
+        &mut self,
+        batch: Vec<std::borrow::Cow<'a, LogData>>,
+    ) -> opentelemetry::logs::LogResult<()> {
         self.client.export(batch).await
     }
 

opentelemetry-sdk/src/export/logs/mod.rs

@@ -8,8 +8,8 @@ use opentelemetry::{
     logs::{LogError, LogResult},
     InstrumentationLibrary,
 };
-use std::fmt::Debug;
 use std::borrow::Cow;
+use std::fmt::Debug;
 
 /// `LogExporter` defines the interface that log exporters should implement.
 #[async_trait]

opentelemetry-sdk/src/logs/log_processor.rs

@@ -14,6 +14,7 @@ use opentelemetry::{
     global,
     logs::{LogError, LogResult},
 };
+use std::borrow::Cow;
 use std::sync::atomic::AtomicBool;
 use std::{cmp::min, env, sync::Mutex};
 use std::{
@@ -22,7 +23,6 @@ use std::{
     sync::Arc,
     time::Duration,
 };
-use std::borrow::Cow;
 
 /// Delay interval between two consecutive exports.
 const OTEL_BLRP_SCHEDULE_DELAY: &str = "OTEL_BLRP_SCHEDULE_DELAY";
@@ -91,7 +91,9 @@ impl LogProcessor for SimpleLogProcessor {
             .exporter
             .lock()
             .map_err(|_| LogError::Other("simple logprocessor mutex poison".into()))
-            .and_then(|mut exporter| futures_executor::block_on(exporter.export(vec![Cow::Borrowed(data)])));
+            .and_then(|mut exporter| {
+                futures_executor::block_on(exporter.export(vec![Cow::Borrowed(data)]))
+            });
         if let Err(err) = result {
             global::handle_error(err);
         }
@@ -142,7 +144,9 @@ impl<R: RuntimeChannel> Debug for BatchLogProcessor<R> {
 
 impl<R: RuntimeChannel> LogProcessor for BatchLogProcessor<R> {
     fn emit(&self, data: &mut LogData) {
-        let result = self.message_sender.try_send(BatchMessage::ExportLog(data.clone()));
+        let result = self
+            .message_sender
+            .try_send(BatchMessage::ExportLog(data.clone()));
 
         if let Err(err) = result {
             global::handle_error(LogError::Other(err.into()));
@@ -497,7 +501,6 @@ mod tests {
         OTEL_BLRP_MAX_QUEUE_SIZE, OTEL_BLRP_SCHEDULE_DELAY,
     };
     use crate::testing::logs::InMemoryLogsExporterBuilder;
-    use std::borrow::Cow;
     use crate::{
         export::logs::{LogData, LogExporter},
         logs::{
@@ -514,6 +517,7 @@ mod tests {
     };
     use async_trait::async_trait;
     use opentelemetry::{logs::LogResult, KeyValue};
+    use std::borrow::Cow;
     use std::sync::Arc;
     use std::time::Duration;
 
@@ -524,7 +528,7 @@ mod tests {
 
     #[async_trait]
     impl LogExporter for MockLogExporter {
-        async fn export<'a>(&mut self,  _batch: Vec<Cow<'a, LogData>>) -> LogResult<()> {
+        async fn export<'a>(&mut self, _batch: Vec<Cow<'a, LogData>>) -> LogResult<()> {
             Ok(())
         }
 
@@ -765,7 +769,7 @@ mod tests {
             .build();
         let processor = SimpleLogProcessor::new(Box::new(exporter.clone()));
 
-        let mut log_data = LogData{
+        let mut log_data = LogData {
             record: Default::default(),
             instrumentation: Default::default(),
         };

opentelemetry-stdout/src/logs/exporter.rs

@@ -6,8 +6,8 @@ use opentelemetry::{
 };
 use opentelemetry_sdk::export::logs::{ExportResult, LogData};
 use opentelemetry_sdk::Resource;
-use std::io::{stdout, Write};
 use std::borrow::Cow;
+use std::io::{stdout, Write};
 
 type Encoder =
     Box<dyn Fn(&mut dyn Write, crate::logs::transform::LogData) -> LogResult<()> + Send + Sync>;
@@ -47,7 +47,10 @@ impl opentelemetry_sdk::export::logs::LogExporter for LogExporter {
     /// Export spans to stdout
     async fn export<'a>(&mut self, batch: Vec<Cow<'a, LogData>>) -> ExportResult {
         if let Some(writer) = &mut self.writer {
-            let log_data = crate::logs::transform::LogData::from((batch.into_iter().map(Cow::into_owned).collect(), &self.resource));
+            let log_data = crate::logs::transform::LogData::from((
+                batch.into_iter().map(Cow::into_owned).collect(),
+                &self.resource,
+            ));
             let result = (self.encoder)(writer, log_data) as LogResult<()>;
             result.and_then(|_| writer.write_all(b"\n").map_err(|e| Error(e).into()))
         } else {