chore: fix format lint

opentelemetry-appender-log/src/lib.rs

@@ -687,7 +687,7 @@
         ) -> Result<(), Self::Error> {
             let key = match key.serialize(ValueSerializer)? {
                 Some(AnyValue::String(key)) => Key::from(String::from(key)),
-                key => Key::from(format!("{:?}", key)),
+                key => Key::from(format!("{key:?}")),
             };
 
             self.key = Some(key);

opentelemetry-appender-tracing/benches/log-attributes.rs

@@ -60,7 +60,7 @@ fn create_benchmark(c: &mut Criterion, num_attributes: usize) {
     let subscriber = Registry::default().with(ot_layer);
 
     tracing::subscriber::with_default(subscriber, || {
-        c.bench_function(&format!("otel_{}_attributes", num_attributes), |b| {
+        c.bench_function(&format!("otel_{num_attributes}_attributes"), |b| {
             b.iter(|| {
                 // Dynamically generate the error! macro call based on the number of attributes
                 match num_attributes {

opentelemetry-appender-tracing/src/layer.rs

@@ -73,7 +73,7 @@ impl<LR: LogRecord> tracing::field::Visit for EventVisitor<'_, LR> {
             return;
         }
         if field.name() == "message" {
-            self.log_record.set_body(format!("{:?}", value).into());
+            self.log_record.set_body(format!("{value:?}").into());
         } else {
             self.log_record
                 .add_attribute(Key::new(field.name()), AnyValue::from(format!("{value:?}")));

opentelemetry-jaeger-propagator/src/propagator.rs

@@ -325,7 +325,7 @@ mod tests {
                     true,
                     TraceState::default(),
                 ),
-                format!("{}:{}:0:1", LONG_TRACE_ID_STR, SPAN_ID_STR),
+                format!("{LONG_TRACE_ID_STR}:{SPAN_ID_STR}:0:1"),
             ),
             (
                 SpanContext::new(
@@ -335,7 +335,7 @@ mod tests {
                     true,
                     TraceState::default(),
                 ),
-                format!("{}:{}:0:0", LONG_TRACE_ID_STR, SPAN_ID_STR),
+                format!("{LONG_TRACE_ID_STR}:{SPAN_ID_STR}:0:0"),
             ),
             (
                 SpanContext::new(
@@ -345,7 +345,7 @@ mod tests {
                     true,
                     TraceState::default(),
                 ),
-                format!("{}:{}:0:3", LONG_TRACE_ID_STR, SPAN_ID_STR),
+                format!("{LONG_TRACE_ID_STR}:{SPAN_ID_STR}:0:3"),
             ),
         ]
     }
@@ -356,7 +356,7 @@ mod tests {
         let propagator = Propagator::with_custom_header(construct_header);
         for (trace_id, span_id, flag, expected) in get_extract_data() {
             let mut map: HashMap<String, String> = HashMap::new();
-            map.set(context_key, format!("{}:{}:0:{}", trace_id, span_id, flag));
+            map.set(context_key, format!("{trace_id}:{span_id}:0:{flag}"));
             let context = propagator.extract(&map);
             assert_eq!(context.span().span_context(), &expected);
         }
@@ -392,7 +392,7 @@ mod tests {
 
         // Propagators implement debug
         assert_eq!(
-            format!("{:?}", default_propagator),
+            format!("{default_propagator:?}"),
             format!(
                 "Propagator {{ baggage_prefix: \"{}\", header_name: \"{}\", fields: [\"{}\"] }}",
                 JAEGER_BAGGAGE_PREFIX, JAEGER_HEADER, JAEGER_HEADER
@@ -641,10 +641,7 @@ mod tests {
         }
         for (trace_id, span_id, flag, expected) in get_extract_data() {
             let mut map: HashMap<String, String> = HashMap::new();
-            map.set(
-                JAEGER_HEADER,
-                format!("{}:{}:0:{}", trace_id, span_id, flag),
-            );
+            map.set(JAEGER_HEADER, format!("{trace_id}:{span_id}:0:{flag}"));
             let context = propagator.extract(&map);
             assert_eq!(context.span().span_context(), &expected);
         }
@@ -655,7 +652,7 @@ mod tests {
         let mut map: HashMap<String, String> = HashMap::new();
         map.set(
             JAEGER_HEADER,
-            format!("{}:{}:0:1:aa", LONG_TRACE_ID_STR, SPAN_ID_STR),
+            format!("{LONG_TRACE_ID_STR}:{SPAN_ID_STR}:0:1:aa"),
         );
         let propagator = Propagator::new();
         let context = propagator.extract(&map);
@@ -667,7 +664,7 @@ mod tests {
         let mut map: HashMap<String, String> = HashMap::new();
         map.set(
             JAEGER_HEADER,
-            format!("{}:{}:0:aa", LONG_TRACE_ID_STR, SPAN_ID_STR),
+            format!("{LONG_TRACE_ID_STR}:{SPAN_ID_STR}:0:aa"),
         );
         let propagator = Propagator::new();
         let context = propagator.extract(&map);
@@ -679,7 +676,7 @@ mod tests {
         let mut map: HashMap<String, String> = HashMap::new();
         map.set(
             JAEGER_HEADER,
-            format!("{}%3A{}%3A0%3A1", LONG_TRACE_ID_STR, SPAN_ID_STR),
+            format!("{LONG_TRACE_ID_STR}%3A{SPAN_ID_STR}%3A0%3A1"),
         );
         let propagator = Propagator::new();
         let context = propagator.extract(&map);

opentelemetry-otlp/examples/basic-otlp-http/src/main.rs

@@ -169,15 +169,15 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     // Collect all shutdown errors
     let mut shutdown_errors = Vec::new();
     if let Err(e) = tracer_provider.shutdown() {
-        shutdown_errors.push(format!("tracer provider: {}", e));
+        shutdown_errors.push(format!("tracer provider: {e}"));
     }
 
     if let Err(e) = meter_provider.shutdown() {
-        shutdown_errors.push(format!("meter provider: {}", e));
+        shutdown_errors.push(format!("meter provider: {e}"));
     }
 
     if let Err(e) = logger_provider.shutdown() {
-        shutdown_errors.push(format!("logger provider: {}", e));
+        shutdown_errors.push(format!("logger provider: {e}"));
     }
 
     // Return an error if any shutdown failed

opentelemetry-otlp/examples/basic-otlp/src/main.rs

@@ -162,15 +162,15 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     // Collect all shutdown errors
     let mut shutdown_errors = Vec::new();
     if let Err(e) = tracer_provider.shutdown() {
-        shutdown_errors.push(format!("tracer provider: {}", e));
+        shutdown_errors.push(format!("tracer provider: {e}"));
     }
 
     if let Err(e) = meter_provider.shutdown() {
-        shutdown_errors.push(format!("meter provider: {}", e));
+        shutdown_errors.push(format!("meter provider: {e}"));
     }
 
     if let Err(e) = logger_provider.shutdown() {
-        shutdown_errors.push(format!("logger provider: {}", e));
+        shutdown_errors.push(format!("logger provider: {e}"));
     }
 
     // Return an error if any shutdown failed

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

@@ -10,7 +10,7 @@
         let client = self
             .client
             .lock()
-            .map_err(|e| OTelSdkError::InternalFailure(format!("Mutex lock failed: {}", e)))?
+            .map_err(|e| OTelSdkError::InternalFailure(format!("Mutex lock failed: {e}")))?
             .clone()
             .ok_or(OTelSdkError::AlreadyShutdown)?;
 
@@ -53,7 +53,7 @@
 
     fn shutdown_with_timeout(&self, _timeout: time::Duration) -> OTelSdkResult {
         let mut client_guard = self.client.lock().map_err(|e| {
-            OTelSdkError::InternalFailure(format!("Failed to acquire client lock: {}", e))
+            OTelSdkError::InternalFailure(format!("Failed to acquire client lock: {e}"))
         })?;
 
         if client_guard.take().is_none() {

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

@@ -62,7 +62,7 @@
     fn shutdown(&self) -> OTelSdkResult {
         self.client
             .lock()
-            .map_err(|e| OTelSdkError::InternalFailure(format!("Failed to acquire lock: {}", e)))?
+            .map_err(|e| OTelSdkError::InternalFailure(format!("Failed to acquire lock: {e}")))?
             .take();
 
         Ok(())

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

@@ -615,17 +615,14 @@
             assert_eq!(
                 headers.len(),
                 expected_headers.len(),
-                "Failed on input: {}",
-                input_str
+                "Failed on input: {input_str}"
             );
 
             for (expected_key, expected_value) in expected_headers {
                 assert_eq!(
                     headers.get(&HeaderName::from_static(expected_key)),
                     Some(&HeaderValue::from_static(expected_value)),
-                    "Failed on key: {} with input: {}",
-                    expected_key,
-                    input_str
+                    "Failed on key: {expected_key} with input: {input_str}"
                 );
             }
         }
@@ -665,17 +662,14 @@
             assert_eq!(
                 headers.len(),
                 expected_headers.len(),
-                "Failed on input: {}",
-                input_str
+                "Failed on input: {input_str}"
             );
 
             for (expected_key, expected_value) in expected_headers {
                 assert_eq!(
                     headers.get(&HeaderName::from_static(expected_key)),
                     Some(&HeaderValue::from_static(expected_value)),
-                    "Failed on key: {} with input: {}",
-                    expected_key,
-                    input_str
+                    "Failed on key: {expected_key} with input: {input_str}"
                 );
             }
         }

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

@@ -13,7 +13,7 @@
         let client = match self
             .client
             .lock()
-            .map_err(|e| OTelSdkError::InternalFailure(format!("Mutex lock failed: {}", e)))
+            .map_err(|e| OTelSdkError::InternalFailure(format!("Mutex lock failed: {e}")))
             .and_then(|g| match &*g {
                 Some(client) => Ok(Arc::clone(client)),
                 _ => Err(OTelSdkError::AlreadyShutdown),
@@ -65,7 +65,7 @@
 
     fn shutdown(&mut self) -> OTelSdkResult {
         let mut client_guard = self.client.lock().map_err(|e| {
-            OTelSdkError::InternalFailure(format!("Failed to acquire client lock: {}", e))
+            OTelSdkError::InternalFailure(format!("Failed to acquire client lock: {e}"))
         })?;
 
         if client_guard.take().is_none() {

opentelemetry-otlp/src/exporter/mod.rs

@@ -396,8 +396,7 @@
                 exporter_result,
                 Err(crate::exporter::ExporterBuildError::InvalidUri(_, _))
             ),
-            "Expected InvalidUri error, but got {:?}",
-            exporter_result
+            "Expected InvalidUri error, but got {exporter_result:?}"
         );
     }
 

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

@@ -63,7 +63,7 @@
                 let (m, e, _) = inner
                     .interceptor
                     .call(Request::new(()))
-                    .map_err(|e| OTelSdkError::InternalFailure(format!("error: {:?}", e)))?
+                    .map_err(|e| OTelSdkError::InternalFailure(format!("error: {e:?}")))?
                     .into_parts();
                 (inner.client.clone(), m, e)
             }
@@ -88,7 +88,7 @@
                 Ok(())
             }
             Err(e) => {
-                let error = format!("export error: {:?}", e);
+                let error = format!("export error: {e:?}");
                 otel_debug!(name: "TonicLogsClient.ExportFailed", error = &error);
                 Err(OTelSdkError::InternalFailure(error))
             }

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

@@ -101,7 +101,7 @@
     fn shutdown(&self) -> OTelSdkResult {
         self.inner
             .lock()
-            .map_err(|e| OTelSdkError::InternalFailure(format!("Failed to acquire lock: {}", e)))?
+            .map_err(|e| OTelSdkError::InternalFailure(format!("Failed to acquire lock: {e}")))?
             .take();
 
         Ok(())

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

@@ -67,7 +67,7 @@
                     .lock()
                     .await // tokio::sync::Mutex doesn't return a poisoned error, so we can safely use the interceptor here
                     .call(Request::new(()))
-                    .map_err(|e| OTelSdkError::InternalFailure(format!("error: {:?}", e)))?
+                    .map_err(|e| OTelSdkError::InternalFailure(format!("error: {e:?}")))?
                     .into_parts();
                 (inner.client.clone(), m, e)
             }

opentelemetry-otlp/tests/integration_test/src/metric_helpers.rs

@@ -101,9 +101,7 @@ pub fn assert_metrics_results_contains(expected_content: &str) -> Result<()> {
     reader.read_to_string(&mut contents)?;
     assert!(
         contents.contains(expected_content),
-        "Expected content {} not found in actual content {}",
-        expected_content,
-        contents
+        "Expected content {expected_content} not found in actual content {contents}"
     );
     Ok(())
 }
@@ -162,12 +160,7 @@ pub fn fetch_latest_metrics_for_scope(scope_name: &str) -> Result<Value> {
                     None
                 })
         })
-        .with_context(|| {
-            format!(
-                "No valid JSON line containing scope `{}` found.",
-                scope_name
-            )
-        })?;
+        .with_context(|| format!("No valid JSON line containing scope `{scope_name}` found."))?;
 
     Ok(json_line)
 }
@@ -178,18 +171,16 @@ pub fn fetch_latest_metrics_for_scope(scope_name: &str) -> Result<Value> {
 ///
 pub fn validate_metrics_against_results(scope_name: &str) -> Result<()> {
     // Define the results file path
-    let results_file_path = format!("./expected/metrics/{}.json", scope_name);
+    let results_file_path = format!("./expected/metrics/{scope_name}.json");
 
     // Fetch the actual metrics for the given scope
     let actual_metrics = fetch_latest_metrics_for_scope(scope_name)
-        .context(format!("Failed to fetch metrics for scope: {}", scope_name))?;
+        .context(format!("Failed to fetch metrics for scope: {scope_name}"))?;
 
     // Read the expected metrics from the results file
     let expected_metrics = {
-        let file = File::open(&results_file_path).context(format!(
-            "Failed to open results file: {}",
-            results_file_path
-        ))?;
+        let file = File::open(&results_file_path)
+            .context(format!("Failed to open results file: {results_file_path}"))?;
         read_metrics_from_json(file)
     }?;
 

opentelemetry-otlp/tests/integration_test/src/trace_asserter.rs

@@ -119,7 +119,7 @@ impl SpanForest {
         }
 
         if !spans.is_empty() {
-            panic!("found spans with invalid parent: {:?}", spans);
+            panic!("found spans with invalid parent: {spans:?}");
         }
 
         forest

opentelemetry-otlp/tests/integration_test/tests/metrics_roundtrip.rs

@@ -38,7 +38,7 @@ mod metrictests_roundtrip {
         let metrics: MetricsData = serde_json::from_str(metrics_in)?;
         let metrics_out = serde_json::to_string(&metrics)?;
 
-        println!("{:}", metrics_out);
+        println!("{metrics_out:}");
 
         let metrics_in_json: Value = serde_json::from_str(metrics_in)?;
         let metrics_out_json: Value = serde_json::from_str(&metrics_out)?;

opentelemetry-otlp/tests/smoke.rs

@@ -89,7 +89,7 @@ async fn smoke_tracer() {
                 opentelemetry_otlp::SpanExporter::builder()
                     .with_tonic()
                     .with_compression(opentelemetry_otlp::Compression::Gzip)
-                    .with_endpoint(format!("http://{}", addr))
+                    .with_endpoint(format!("http://{addr}"))
                     .with_metadata(metadata)
                     .build()
                     .expect("gzip-tonic SpanExporter failed to build"),

opentelemetry-prometheus/src/utils.rs

@@ -26,10 +26,10 @@ pub(crate) fn get_unit_suffixes(unit: &str) -> Option<Cow<'static, str>> {
             get_prom_per_unit(second),
         ) {
             (true, _, Some(second_part)) | (false, None, Some(second_part)) => {
-                Some(Cow::Owned(format!("per_{}", second_part)))
+                Some(Cow::Owned(format!("per_{second_part}")))
             }
             (false, Some(first_part), Some(second_part)) => {
-                Some(Cow::Owned(format!("{}_per_{}", first_part, second_part)))
+                Some(Cow::Owned(format!("{first_part}_per_{second_part}")))
             }
             _ => None,
         };

opentelemetry-sdk/benches/batch_span_processor.rs

@@ -42,7 +42,7 @@ fn criterion_benchmark(c: &mut Criterion) {
 
     for task_num in [1, 2, 4, 8, 16, 32].iter() {
         group.bench_with_input(
-            BenchmarkId::from_parameter(format!("with {} concurrent task", task_num)),
+            BenchmarkId::from_parameter(format!("with {task_num} concurrent task")),
             task_num,
             |b, &task_num| {
                 b.iter(|| {