chore(linting): fix linting (#41)

ZStriker19 · web-flow · commit 3df1b9da7087 · 2025-06-30T10:02:29.000+02:00
diff --git a/datadog-opentelemetry-mappings/src/transform/mod.rs b/datadog-opentelemetry-mappings/src/transform/mod.rs
@@ -349,9 +349,9 @@ fn dd_value_to_string(value: &AttributeAnyValue<BytesString>) -> BytesString {
     fn write_scalar(value: &AttributeArrayValue<BytesString>, w: &mut String) {
         let _ = match value {
             AttributeArrayValue::String(s) => write!(w, "{}", s.as_str()),
-            AttributeArrayValue::Integer(i) => write!(w, "{}", i),
-            AttributeArrayValue::Double(d) => write!(w, "{}", d),
-            AttributeArrayValue::Boolean(b) => write!(w, "{}", b),
+            AttributeArrayValue::Integer(i) => write!(w, "{i}"),
+            AttributeArrayValue::Double(d) => write!(w, "{d}"),
+            AttributeArrayValue::Boolean(b) => write!(w, "{b}"),
         };
     }
     fn write_vec(value: &[AttributeArrayValue<BytesString>], w: &mut String) {
diff --git a/datadog-opentelemetry-mappings/src/transform/otel_util.rs b/datadog-opentelemetry-mappings/src/transform/otel_util.rs
@@ -65,7 +65,7 @@ pub fn get_otel_operation_name_v2(span: &impl OtelSpan) -> Cow<'static, str> {
             SpanKind::Client | SpanKind::Server | SpanKind::Consumer | SpanKind::Producer
         )
     {
-        return Cow::Owned(format!("{}.{}", messaging_system, messaging_operation).to_lowercase());
+        return Cow::Owned(format!("{messaging_system}.{messaging_operation}").to_lowercase());
     }
 
     // RPC & AWS
@@ -91,7 +91,7 @@ pub fn get_otel_operation_name_v2(span: &impl OtelSpan) -> Cow<'static, str> {
     let faas_invoked_name = span.get_attr_str(FAAS_INVOKED_NAME);
     if is_client && !faas_invoked_provider.is_empty() && !faas_invoked_name.is_empty() {
         return Cow::Owned(
-            format!("{}.{}.invoke", faas_invoked_provider, faas_invoked_name).to_lowercase(),
+            format!("{faas_invoked_provider}.{faas_invoked_name}.invoke").to_lowercase(),
         );
     }
 
@@ -147,7 +147,7 @@ pub fn get_otel_resource_v2(span: &impl OtelSpan) -> Cow<'static, str> {
         if matches!(span.span_kind(), SpanKind::Server) {
             let route = get_res_span_attributes(span, &[HTTP_ROUTE]);
             if !route.is_empty() {
-                return Cow::Owned(format!("{} {}", m, route));
+                return Cow::Owned(format!("{m} {route}"));
             }
         }
         return m;
@@ -159,7 +159,7 @@ pub fn get_otel_resource_v2(span: &impl OtelSpan) -> Cow<'static, str> {
         let messaging_destination =
             get_res_span_attributes(span, &[MESSAGING_DESTINATION, MESSAGING_DESTINATION_NAME]);
         if !messaging_destination.is_empty() {
-            res_name = Cow::Owned(format!("{} {}", res_name, messaging_destination));
+            res_name = Cow::Owned(format!("{res_name} {messaging_destination}"));
         }
         return res_name;
     }
@@ -169,7 +169,7 @@ pub fn get_otel_resource_v2(span: &impl OtelSpan) -> Cow<'static, str> {
         let mut res_name = rpc_method;
         let rpc_service = get_res_span_attributes(span, &[RPC_SERVICE]);
         if !rpc_service.is_empty() {
-            res_name = Cow::Owned(format!("{} {}", res_name, rpc_service));
+            res_name = Cow::Owned(format!("{res_name} {rpc_service}"));
         }
         return res_name;
     }
@@ -179,7 +179,7 @@ pub fn get_otel_resource_v2(span: &impl OtelSpan) -> Cow<'static, str> {
         let mut res_name = graphql_operation_type;
         let graphql_operation_name = get_res_span_attributes(span, &[GRAPHQL_OPERATION_NAME]);
         if !graphql_operation_name.is_empty() {
-            res_name = Cow::Owned(format!("{} {}", res_name, graphql_operation_name));
+            res_name = Cow::Owned(format!("{res_name} {graphql_operation_name}"));
         }
         return res_name;
     }
@@ -399,7 +399,7 @@ pub fn get_dd_key_for_otlp_attribute(k: &str) -> BorrowedString {
         return BorrowedString::Static(mapped_key);
     }
     if let Some(suffix) = k.strip_prefix("http.request.header.") {
-        return BorrowedString::Owned(format!("http.request.headers.{}", suffix));
+        return BorrowedString::Owned(format!("http.request.headers.{suffix}"));
     }
     if is_datadog_convention_key(k) {
         return BorrowedString::Static("");
diff --git a/datadog-opentelemetry-mappings/src/transform/transform_tests.rs b/datadog-opentelemetry-mappings/src/transform/transform_tests.rs
@@ -719,35 +719,35 @@ fn hashmap_diff<V: PartialEq + Debug>(
         match (a.peek(), b.peek()) {
             (Some(a_v), Some(b_v)) => match a_v.0.as_str().cmp(b_v.0.as_str()) {
                 std::cmp::Ordering::Less => {
-                    writeln!(&mut message, "a  :+{:?}", a_v).unwrap();
+                    writeln!(&mut message, "a  :+{a_v:?}").unwrap();
                     a.next();
                 }
                 std::cmp::Ordering::Equal => {
                     if a_v.1 != b_v.1 {
-                        writeln!(&mut message, "a!b: {:?} != {:?}", a_v, b_v).unwrap();
+                        writeln!(&mut message, "a!b: {a_v:?} != {b_v:?}").unwrap();
                     } else {
-                        writeln!(&mut message, "a b: {:?}", b_v).unwrap();
+                        writeln!(&mut message, "a b: {b_v:?}").unwrap();
                     }
                     a.next();
                     b.next();
                 }
                 std::cmp::Ordering::Greater => {
-                    writeln!(&mut message, "  b:+{:?}", b_v).unwrap();
+                    writeln!(&mut message, "  b:+{b_v:?}").unwrap();
                     b.next();
                 }
             },
             (None, None) => break,
             (Some(a_v), None) => {
-                writeln!(&mut message, "a  :+{:?}", a_v).unwrap();
+                writeln!(&mut message, "a  :+{a_v:?}").unwrap();
                 a.next();
             }
             (None, Some(b_v)) => {
-                writeln!(&mut message, "  b:+{:?}", b_v).unwrap();
+                writeln!(&mut message, "  b:+{b_v:?}").unwrap();
                 b.next();
             }
         }
     }
     if output != expected {
-        eprintln!("Hashmaps are not equal :\n{}", message);
+        eprintln!("Hashmaps are not equal :\n{message}");
     }
 }
diff --git a/datadog-opentelemetry/src/sampler.rs b/datadog-opentelemetry/src/sampler.rs
@@ -186,9 +186,11 @@ mod tests {
             let span_context = SpanContext::new(
                 trace_id,
                 span_id,
-                is_sampled
-                    .then_some(TraceFlags::SAMPLED)
-                    .unwrap_or_default(),
+                if is_sampled {
+                    TraceFlags::SAMPLED
+                } else {
+                    Default::default()
+                },
                 true,
                 trace_state.clone(),
             );
diff --git a/datadog-opentelemetry/src/span_exporter.rs b/datadog-opentelemetry/src/span_exporter.rs
@@ -167,8 +167,7 @@ impl DatadogExporter {
                 ))
             }
             Err(e) => Err(OTelSdkError::InternalFailure(format!(
-                "DatadogExporter: failed to add trace chunk: {:?}",
-                e
+                "DatadogExporter: failed to add trace chunk: {e:?}",
             ))),
             Ok(()) => Ok(()),
         }
@@ -183,8 +182,7 @@ impl DatadogExporter {
                 ))
             }
             Err(e) => Err(OTelSdkError::InternalFailure(format!(
-                "DatadogExporter: failed to set resource: {:?}",
-                e
+                "DatadogExporter: failed to set resource: {e:?}",
             ))),
             Ok(()) => Ok(()),
         }
@@ -199,8 +197,7 @@ impl DatadogExporter {
                 ))
             }
             Err(e) => Err(OTelSdkError::InternalFailure(format!(
-                "DatadogExporter: failed to trigger flush: {:?}",
-                e
+                "DatadogExporter: failed to trigger flush: {e:?}",
             ))),
             Ok(()) => Ok(()),
         }
@@ -221,8 +218,7 @@ impl DatadogExporter {
             }
             Err(e) => {
                 return Err(OTelSdkError::InternalFailure(format!(
-                    "DatadogExporter: trace exporter shutdown failed {:?}",
-                    e,
+                    "DatadogExporter: trace exporter shutdown failed {e:?}",
                 )));
             }
         };
@@ -249,7 +245,7 @@ impl DatadogExporter {
                 OTelSdkError::InternalFailure("Trace exporter thread panicked".to_string())
             })?
             .map_err(|e| {
-                OTelSdkError::InternalFailure(format!("Trace exporter exited with error: {}", e))
+                OTelSdkError::InternalFailure(format!("Trace exporter exited with error: {e}"))
             })
     }
 }
diff --git a/datadog-opentelemetry/src/text_map_propagator.rs b/datadog-opentelemetry/src/text_map_propagator.rs
@@ -365,9 +365,7 @@ pub mod tests {
             assert_eq!(
                 propagator.extract(&extractor).span().span_context(),
                 &expected_context,
-                "Error with traceparent: {}, tracestate: {}",
-                trace_parent,
-                trace_state
+                "Error with traceparent: {trace_parent}, tracestate: {trace_state}",
             )
         }
     }
@@ -404,8 +402,7 @@ pub mod tests {
             assert_eq!(
                 propagator.extract(&extractor).span().span_context(),
                 &opentelemetry::trace::SpanContext::empty_context(),
-                "{}",
-                reason
+                "{reason}",
             )
         }
     }
diff --git a/datadog-opentelemetry/tests/mod.rs b/datadog-opentelemetry/tests/mod.rs
@@ -218,15 +218,15 @@ mod datadog_test_agent {
             [
                 "s:2".to_string(),
                 "t.dm:-3".to_string(),
-                format!("p:{:016x}", span_id),
+                format!("p:{span_id:016x}"),
             ],
         );
 
         assert_subset(
             injected.into_iter(),
             [(
                 "traceparent".to_string(),
-                format!("00-{:032x}-{:016x}-01", trace_id, span_id),
+                format!("00-{trace_id:032x}-{span_id:016x}-01"),
             )],
         );
     }
@@ -239,7 +239,7 @@ mod datadog_test_agent {
         let set: HashSet<_, RandomState> = HashSet::from_iter(set);
         for item in subset {
             if !set.contains(&item) {
-                panic!("Set {:?} does not contain subset item {:?}", set, item);
+                panic!("Set {set:?} does not contain subset item {item:?}");
             }
         }
     }
diff --git a/dd-trace-propagation/src/datadog.rs b/dd-trace-propagation/src/datadog.rs
@@ -73,7 +73,7 @@ fn inject_trace_id(trace_id: u128, carrier: &mut dyn Injector, tags: &mut HashMa
     if let Some(higher) = higher {
         tags.insert(
             DATADOG_HIGHER_ORDER_TRACE_ID_BITS_KEY.to_string(),
-            format!("{:016x}", higher),
+            format!("{higher:016x}"),
         );
     } else {
         tags.remove(DATADOG_HIGHER_ORDER_TRACE_ID_BITS_KEY);
@@ -589,7 +589,7 @@ mod test {
         assert_eq!(carrier[DATADOG_ORIGIN_KEY], "synthetics");
         assert_eq!(
             carrier[DATADOG_TAGS_KEY],
-            format!("_dd.p.tid={:016x}", higher)
+            format!("_dd.p.tid={higher:016x}")
         );
     }
 
diff --git a/dd-trace-propagation/src/tracecontext.rs b/dd-trace-propagation/src/tracecontext.rs
@@ -86,7 +86,7 @@ fn inject_tracestate(context: &SpanContext, carrier: &mut dyn Injector) {
         .and_then(|sampling| sampling.priority)
         .unwrap_or(priority::USER_KEEP);
 
-    tracestate_parts.push(format!("{TRACESTATE_SAMPLING_PRIORITY_KEY}:{}", priority));
+    tracestate_parts.push(format!("{TRACESTATE_SAMPLING_PRIORITY_KEY}:{priority}"));
 
     if let Some(origin) = context.origin.as_ref().map(|origin| {
         encode_tag_value(
diff --git a/dd-trace-sampling/src/datadog_sampler.rs b/dd-trace-sampling/src/datadog_sampler.rs
@@ -284,7 +284,7 @@ impl DatadogSampler {
         // Get env from attributes
         let env = get_otel_env(span);
 
-        format!("service:{},env:{}", service, env)
+        format!("service:{service},env:{env}")
     }
 
     /// Updates the service-based sample rates from the Agent
@@ -678,7 +678,7 @@ mod tests {
         assert_eq!(
             sampler.service_key(&span),
             // Expect the service name from the sampler's resource
-            format!("service:{},env:production", test_service_name)
+            format!("service:{test_service_name},env:production")
         );
 
         // Test with missing env
@@ -693,7 +693,7 @@ mod tests {
         assert_eq!(
             sampler.service_key(&span),
             // Expect the service name from the sampler's resource and an empty env
-            format!("service:{},env:", test_service_name)
+            format!("service:{test_service_name},env:")
         );
     }
 
diff --git a/dd-trace-sampling/src/rate_limiter.rs b/dd-trace-sampling/src/rate_limiter.rs
@@ -284,8 +284,7 @@ mod tests {
         let rate = limiter.effective_rate();
         assert!(
             (0.45..=0.55).contains(&rate),
-            "Expected rate around 0.5, got {}",
-            rate
+            "Expected rate around 0.5, got {rate}",
         );
     }
 
@@ -320,8 +319,7 @@ mod tests {
         let total_allowed = main_allowed_count + thread_allowed_count;
         assert!(
             (95..=105).contains(&total_allowed),
-            "Expected around 100 allowed requests, got {}",
-            total_allowed
+            "Expected around 100 allowed requests, got {total_allowed}",
         );
     }
 }
diff --git a/dd-trace-sampling/src/rate_sampler.rs b/dd-trace-sampling/src/rate_sampler.rs
@@ -78,7 +78,7 @@ mod tests {
     #[test]
     fn check_debug_impl() {
         let sampler = RateSampler::new(0.5);
-        let debug_output = format!("{:?}", sampler);
+        let debug_output = format!("{sampler:?}");
         assert!(debug_output.contains("RateSampler"));
         assert!(debug_output.contains("sample_rate: 0.5"));
     }
@@ -162,9 +162,7 @@ mod tests {
         // For rate 0.5, threshold is MAX/2. Hashing MAX should result in something > MAX/2
         assert!(
             drop_hash > threshold,
-            "Drop hash {} should be > threshold {}",
-            drop_hash,
-            threshold
+            "Drop hash {drop_hash} should be > threshold {threshold}",
         );
         assert!(
             !sampler_half.sample(trace_id_drop),
diff --git a/dd-trace/src/configuration/sources.rs b/dd-trace/src/configuration/sources.rs
@@ -238,7 +238,7 @@ mod tests {
             ),
         ] {
             let result = source.get(key);
-            assert_eq!(result, expected, "Failed for key: {}", key);
+            assert_eq!(result, expected, "Failed for key: {key}");
         }
     }
 
@@ -289,7 +289,7 @@ mod tests {
             ),
         ] {
             let result = source.get(key);
-            assert_eq!(result, expected, "Failed for key: {}", key);
+            assert_eq!(result, expected, "Failed for key: {key}");
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ pub fn get_otel_operation_name_v2(span: &impl OtelSpan) -> Cow<'static, str> {`
`65`	`65`	`SpanKind::Client \| SpanKind::Server \| SpanKind::Consumer \| SpanKind::Producer`
`66`	`66`	`)`
`67`	`67`	`{`
`68`		`- return Cow::Owned(format!("{}.{}", messaging_system, messaging_operation).to_lowercase());`
	`68`	`+ return Cow::Owned(format!("{messaging_system}.{messaging_operation}").to_lowercase());`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`// RPC & AWS`
`@@ -91,7 +91,7 @@ pub fn get_otel_operation_name_v2(span: &impl OtelSpan) -> Cow<'static, str> {`
`91`	`91`	`let faas_invoked_name = span.get_attr_str(FAAS_INVOKED_NAME);`
`92`	`92`	`if is_client && !faas_invoked_provider.is_empty() && !faas_invoked_name.is_empty() {`
`93`	`93`	`return Cow::Owned(`
`94`		`- format!("{}.{}.invoke", faas_invoked_provider, faas_invoked_name).to_lowercase(),`
	`94`	`+ format!("{faas_invoked_provider}.{faas_invoked_name}.invoke").to_lowercase(),`
`95`	`95`	`);`
`96`	`96`	`}`
`97`	`97`
`@@ -147,7 +147,7 @@ pub fn get_otel_resource_v2(span: &impl OtelSpan) -> Cow<'static, str> {`
`147`	`147`	`if matches!(span.span_kind(), SpanKind::Server) {`
`148`	`148`	`let route = get_res_span_attributes(span, &[HTTP_ROUTE]);`
`149`	`149`	`if !route.is_empty() {`
`150`		`- return Cow::Owned(format!("{} {}", m, route));`
	`150`	`+ return Cow::Owned(format!("{m} {route}"));`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`	`return m;`
`@@ -159,7 +159,7 @@ pub fn get_otel_resource_v2(span: &impl OtelSpan) -> Cow<'static, str> {`
`159`	`159`	`let messaging_destination =`
`160`	`160`	`get_res_span_attributes(span, &[MESSAGING_DESTINATION, MESSAGING_DESTINATION_NAME]);`
`161`	`161`	`if !messaging_destination.is_empty() {`
`162`		`- res_name = Cow::Owned(format!("{} {}", res_name, messaging_destination));`
	`162`	`+ res_name = Cow::Owned(format!("{res_name} {messaging_destination}"));`
`163`	`163`	`}`
`164`	`164`	`return res_name;`
`165`	`165`	`}`
`@@ -169,7 +169,7 @@ pub fn get_otel_resource_v2(span: &impl OtelSpan) -> Cow<'static, str> {`
`169`	`169`	`let mut res_name = rpc_method;`
`170`	`170`	`let rpc_service = get_res_span_attributes(span, &[RPC_SERVICE]);`
`171`	`171`	`if !rpc_service.is_empty() {`
`172`		`- res_name = Cow::Owned(format!("{} {}", res_name, rpc_service));`
	`172`	`+ res_name = Cow::Owned(format!("{res_name} {rpc_service}"));`
`173`	`173`	`}`
`174`	`174`	`return res_name;`
`175`	`175`	`}`
`@@ -179,7 +179,7 @@ pub fn get_otel_resource_v2(span: &impl OtelSpan) -> Cow<'static, str> {`
`179`	`179`	`let mut res_name = graphql_operation_type;`
`180`	`180`	`let graphql_operation_name = get_res_span_attributes(span, &[GRAPHQL_OPERATION_NAME]);`
`181`	`181`	`if !graphql_operation_name.is_empty() {`
`182`		`- res_name = Cow::Owned(format!("{} {}", res_name, graphql_operation_name));`
	`182`	`+ res_name = Cow::Owned(format!("{res_name} {graphql_operation_name}"));`
`183`	`183`	`}`
`184`	`184`	`return res_name;`
`185`	`185`	`}`
`@@ -399,7 +399,7 @@ pub fn get_dd_key_for_otlp_attribute(k: &str) -> BorrowedString {`
`399`	`399`	`return BorrowedString::Static(mapped_key);`
`400`	`400`	`}`
`401`	`401`	`if let Some(suffix) = k.strip_prefix("http.request.header.") {`
`402`		`- return BorrowedString::Owned(format!("http.request.headers.{}", suffix));`
	`402`	`+ return BorrowedString::Owned(format!("http.request.headers.{suffix}"));`
`403`	`403`	`}`
`404`	`404`	`if is_datadog_convention_key(k) {`
`405`	`405`	`return BorrowedString::Static("");`
Original file line number	Diff line number	Diff line change
`@@ -719,35 +719,35 @@ fn hashmap_diff<V: PartialEq + Debug>(`
`719`	`719`	`match (a.peek(), b.peek()) {`
`720`	`720`	`(Some(a_v), Some(b_v)) => match a_v.0.as_str().cmp(b_v.0.as_str()) {`
`721`	`721`	`std::cmp::Ordering::Less => {`
`722`		`- writeln!(&mut message, "a :+{:?}", a_v).unwrap();`
	`722`	`+ writeln!(&mut message, "a :+{a_v:?}").unwrap();`
`723`	`723`	`a.next();`
`724`	`724`	`}`
`725`	`725`	`std::cmp::Ordering::Equal => {`
`726`	`726`	`if a_v.1 != b_v.1 {`
`727`		`- writeln!(&mut message, "a!b: {:?} != {:?}", a_v, b_v).unwrap();`
	`727`	`+ writeln!(&mut message, "a!b: {a_v:?} != {b_v:?}").unwrap();`
`728`	`728`	`} else {`
`729`		`- writeln!(&mut message, "a b: {:?}", b_v).unwrap();`
	`729`	`+ writeln!(&mut message, "a b: {b_v:?}").unwrap();`
`730`	`730`	`}`
`731`	`731`	`a.next();`
`732`	`732`	`b.next();`
`733`	`733`	`}`
`734`	`734`	`std::cmp::Ordering::Greater => {`
`735`		`- writeln!(&mut message, " b:+{:?}", b_v).unwrap();`
	`735`	`+ writeln!(&mut message, " b:+{b_v:?}").unwrap();`
`736`	`736`	`b.next();`
`737`	`737`	`}`
`738`	`738`	`},`
`739`	`739`	`(None, None) => break,`
`740`	`740`	`(Some(a_v), None) => {`
`741`		`- writeln!(&mut message, "a :+{:?}", a_v).unwrap();`
	`741`	`+ writeln!(&mut message, "a :+{a_v:?}").unwrap();`
`742`	`742`	`a.next();`
`743`	`743`	`}`
`744`	`744`	`(None, Some(b_v)) => {`
`745`		`- writeln!(&mut message, " b:+{:?}", b_v).unwrap();`
	`745`	`+ writeln!(&mut message, " b:+{b_v:?}").unwrap();`
`746`	`746`	`b.next();`
`747`	`747`	`}`
`748`	`748`	`}`
`749`	`749`	`}`
`750`	`750`	`if output != expected {`
`751`		`- eprintln!("Hashmaps are not equal :\n{}", message);`
	`751`	`+ eprintln!("Hashmaps are not equal :\n{message}");`
`752`	`752`	`}`
`753`	`753`	`}`
Original file line number	Diff line number	Diff line change
`@@ -167,8 +167,7 @@ impl DatadogExporter {`
`167`	`167`	`))`
`168`	`168`	`}`
`169`	`169`	`Err(e) => Err(OTelSdkError::InternalFailure(format!(`
`170`		`- "DatadogExporter: failed to add trace chunk: {:?}",`
`171`		`- e`
	`170`	`+ "DatadogExporter: failed to add trace chunk: {e:?}",`
`172`	`171`	`))),`
`173`	`172`	`Ok(()) => Ok(()),`
`174`	`173`	`}`
`@@ -183,8 +182,7 @@ impl DatadogExporter {`
`183`	`182`	`))`
`184`	`183`	`}`
`185`	`184`	`Err(e) => Err(OTelSdkError::InternalFailure(format!(`
`186`		`- "DatadogExporter: failed to set resource: {:?}",`
`187`		`- e`
	`185`	`+ "DatadogExporter: failed to set resource: {e:?}",`
`188`	`186`	`))),`
`189`	`187`	`Ok(()) => Ok(()),`
`190`	`188`	`}`
`@@ -199,8 +197,7 @@ impl DatadogExporter {`
`199`	`197`	`))`
`200`	`198`	`}`
`201`	`199`	`Err(e) => Err(OTelSdkError::InternalFailure(format!(`
`202`		`- "DatadogExporter: failed to trigger flush: {:?}",`
`203`		`- e`
	`200`	`+ "DatadogExporter: failed to trigger flush: {e:?}",`
`204`	`201`	`))),`
`205`	`202`	`Ok(()) => Ok(()),`
`206`	`203`	`}`
`@@ -221,8 +218,7 @@ impl DatadogExporter {`
`221`	`218`	`}`
`222`	`219`	`Err(e) => {`
`223`	`220`	`return Err(OTelSdkError::InternalFailure(format!(`
`224`		`- "DatadogExporter: trace exporter shutdown failed {:?}",`
`225`		`- e,`
	`221`	`+ "DatadogExporter: trace exporter shutdown failed {e:?}",`
`226`	`222`	`)));`
`227`	`223`	`}`
`228`	`224`	`};`
`@@ -249,7 +245,7 @@ impl DatadogExporter {`
`249`	`245`	`OTelSdkError::InternalFailure("Trace exporter thread panicked".to_string())`
`250`	`246`	`})?`
`251`	`247`	`.map_err(\|e\| {`
`252`		`- OTelSdkError::InternalFailure(format!("Trace exporter exited with error: {}", e))`
	`248`	`+ OTelSdkError::InternalFailure(format!("Trace exporter exited with error: {e}"))`
`253`	`249`	`})`
`254`	`250`	`}`
`255`	`251`	`}`
Original file line number	Diff line number	Diff line change
`@@ -365,9 +365,7 @@ pub mod tests {`
`365`	`365`	`assert_eq!(`
`366`	`366`	`propagator.extract(&extractor).span().span_context(),`
`367`	`367`	`&expected_context,`
`368`		`- "Error with traceparent: {}, tracestate: {}",`
`369`		`- trace_parent,`
`370`		`- trace_state`
	`368`	`+ "Error with traceparent: {trace_parent}, tracestate: {trace_state}",`
`371`	`369`	`)`
`372`	`370`	`}`
`373`	`371`	`}`
`@@ -404,8 +402,7 @@ pub mod tests {`
`404`	`402`	`assert_eq!(`
`405`	`403`	`propagator.extract(&extractor).span().span_context(),`
`406`	`404`	`&opentelemetry::trace::SpanContext::empty_context(),`
`407`		`- "{}",`
`408`		`- reason`
	`405`	`+ "{reason}",`
`409`	`406`	`)`
`410`	`407`	`}`
`411`	`408`	`}`
Original file line number	Diff line number	Diff line change
`@@ -218,15 +218,15 @@ mod datadog_test_agent {`
`218`	`218`	`[`
`219`	`219`	`"s:2".to_string(),`
`220`	`220`	`"t.dm:-3".to_string(),`
`221`		`- format!("p:{:016x}", span_id),`
	`221`	`+ format!("p:{span_id:016x}"),`
`222`	`222`	`],`
`223`	`223`	`);`
`224`	`224`
`225`	`225`	`assert_subset(`
`226`	`226`	`injected.into_iter(),`
`227`	`227`	`[(`
`228`	`228`	`"traceparent".to_string(),`
`229`		`- format!("00-{:032x}-{:016x}-01", trace_id, span_id),`
	`229`	`+ format!("00-{trace_id:032x}-{span_id:016x}-01"),`
`230`	`230`	`)],`
`231`	`231`	`);`
`232`	`232`	`}`
`@@ -239,7 +239,7 @@ mod datadog_test_agent {`
`239`	`239`	`let set: HashSet<_, RandomState> = HashSet::from_iter(set);`
`240`	`240`	`for item in subset {`
`241`	`241`	`if !set.contains(&item) {`
`242`		`- panic!("Set {:?} does not contain subset item {:?}", set, item);`
	`242`	`+ panic!("Set {set:?} does not contain subset item {item:?}");`
`243`	`243`	`}`
`244`	`244`	`}`
`245`	`245`	`}`