fmt

Author: cijothomas

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

@@ -48,7 +48,10 @@ impl MetricsClient for OtlpHttpClient {
         self.client
             .lock()
             .map_err(|e| {
-                ShutdownError::InternalFailure(format!("Internal Error. Failed to acquire lock: {}", e))
+                ShutdownError::InternalFailure(format!(
+                    "Internal Error. Failed to acquire lock: {}",
+                    e
+                ))
             })?
             .take();
 

opentelemetry-otlp/src/exporter/tonic/metrics.rs

@@ -94,7 +94,10 @@ impl MetricsClient for TonicMetricsClient {
         self.inner
             .lock()
             .map_err(|e| {
-                ShutdownError::InternalFailure(format!("Internal Error. Failed to acquire lock: {}", e))
+                ShutdownError::InternalFailure(format!(
+                    "Internal Error. Failed to acquire lock: {}",
+                    e
+                ))
             })?
             .take();
 

opentelemetry-sdk/src/metrics/periodic_reader_with_async_runtime.rs

@@ -297,7 +297,7 @@ impl<RT: Runtime> PeriodicReaderWorker<RT> {
                 let res = self.collect_and_export().await;
                 let _ = self.reader.exporter.shutdown();
                 if let Err(send_error) =
-                    ch.send(res.map_err(|e| ShutdownError::Failed(e.to_string())))
+                    ch.send(res.map_err(|e| ShutdownError::InternalFailure(e.to_string())))
                 {
                     otel_debug!(
                         name: "PeriodicReader.Shutdown.SendResultError",
@@ -379,9 +379,10 @@ impl MetricReader for PeriodicReader {
     }
 
     fn shutdown(&self) -> ShutdownResult {
-        let mut inner = self.inner.lock().map_err(|e| {
-            ShutdownError::Failed(format!("Internal Error. Failed to acquire lock: {}", e))
-        })?;
+        let mut inner = self
+            .inner
+            .lock()
+            .map_err(|e| ShutdownError::InternalFailure(e.to_string()))?;
         if inner.is_shutdown {
             return Err(ShutdownError::AlreadyShutdown);
         }
@@ -390,16 +391,17 @@ impl MetricReader for PeriodicReader {
         inner
             .message_sender
             .try_send(Message::Shutdown(sender))
-            .map_err(|e| ShutdownError::Failed(e.to_string()))?;
+            .map_err(|e| ShutdownError::InternalFailure(e.to_string()))?;
         drop(inner); // don't hold lock when blocking on future
 
         let shutdown_result = futures_executor::block_on(receiver)
-            .map_err(|err| ShutdownError::Failed(err.to_string()))?;
+            .map_err(|err| ShutdownError::InternalFailure(err.to_string()))?;
 
         // Acquire the lock again to set the shutdown flag
-        let mut inner = self.inner.lock().map_err(|e| {
-            ShutdownError::Failed(format!("Internal Error. Failed to acquire lock: {}", e))
-        })?;
+        let mut inner = self
+            .inner
+            .lock()
+            .map_err(|e| ShutdownError::InternalFailure(e.to_string()))?;
         inner.is_shutdown = true;
 
         shutdown_result

opentelemetry-sdk/src/metrics/pipeline.rs

@@ -661,7 +661,9 @@ impl Pipelines {
         if errs.is_empty() {
             Ok(())
         } else {
-            Err(crate::error::ShutdownError::InternalFailure(format!("{errs:?}")))
+            Err(crate::error::ShutdownError::InternalFailure(format!(
+                "{errs:?}"
+            )))
         }
     }
 }

opentelemetry-sdk/src/testing/metrics/metric_reader.rs

@@ -1,6 +1,6 @@
 use std::sync::{Arc, Mutex, Weak};
 
-use crate::error::ShutdownResult;
+use crate::error::{ShutdownError, ShutdownResult};
 use crate::metrics::{
     data::ResourceMetrics, pipeline::Pipeline, reader::MetricReader, InstrumentKind,
 };
@@ -48,7 +48,7 @@ impl MetricReader for TestMetricReader {
             let mut is_shutdown = self.is_shutdown.lock().unwrap();
             *is_shutdown = true;
         }
-        result.map_err(|e| crate::error::ShutdownError::InternalFailure(e.to_string()))
+        result.map_err(|e| ShutdownError::InternalFailure(e.to_string()))
     }
 
     fn temporality(&self, _kind: InstrumentKind) -> Temporality {