style: fix clippy lints on Rust 1.90 (#1229)

* style: fix clippy lints on Rust 1.90

* fix: crasht test

* fix: telemetry test and add timeout

Author: morrisonlevi

bin_tests/tests/crashtracker_bin_test.rs

@@ -200,18 +200,17 @@ fn test_crash_tracking_callstack() {
 
     // Note: in Release, we do not have the crate and module name prepended to the function name
     // Here we compile the crashing app in Debug.
-    let mut expected_functions = vec![
+    let mut expected_functions = Vec::new();
+    // It seems that on arm/arm64, fn3 is inlined in fn2, so not present.
+    // Add fn3 only for x86_64 arch
+    #[cfg(target_arch = "x86_64")]
+    expected_functions.push("crashing_test_app::unix::fn3");
+    expected_functions.extend_from_slice(&[
         "crashing_test_app::unix::fn2",
         "crashing_test_app::unix::fn1",
         "crashing_test_app::unix::main",
         "crashing_test_app::main",
-    ];
-    // It seems that on arm/arm64, fn3 is inlined in fn2, so not present.
-    // Add fn3 only for x86_64 arch
-    #[cfg(target_arch = "x86_64")]
-    {
-        expected_functions.insert(0, "crashing_test_app::unix::fn3");
-    }
+    ]);
 
     let crashing_callstack = &crash_payload["error"]["stack"]["frames"];
     assert!(

data-pipeline/src/span_concentrator/aggregation.rs

@@ -90,16 +90,16 @@ where
     }
 }
 
-impl Eq for (dyn BorrowableAggregationKey + '_) {}
+impl Eq for dyn BorrowableAggregationKey + '_ {}
 
-impl PartialEq for (dyn BorrowableAggregationKey + '_) {
+impl PartialEq for dyn BorrowableAggregationKey + '_ {
     fn eq(&self, other: &dyn BorrowableAggregationKey) -> bool {
         self.borrowed_aggregation_key()
             .eq(&other.borrowed_aggregation_key())
     }
 }
 
-impl std::hash::Hash for (dyn BorrowableAggregationKey + '_) {
+impl std::hash::Hash for dyn BorrowableAggregationKey + '_ {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         self.borrowed_aggregation_key().hash(state)
     }

data-pipeline/src/telemetry/mod.rs

@@ -724,11 +724,11 @@ mod tests {
             })
             .unwrap();
         client.shutdown().await;
-        while telemetry_srv.hits_async().await == 0 {
+        while telemetry_srv.calls_async().await == 0 {
             sleep(Duration::from_millis(10)).await;
         }
         // One payload generate-metrics
-        telemetry_srv.assert_hits_async(1).await;
+        telemetry_srv.assert_calls_async(1).await;
     }
 
     #[cfg_attr(miri, ignore)]
@@ -739,7 +739,7 @@ mod tests {
         let telemetry_srv = server
             .mock_async(|when, then| {
                 when.method(POST)
-                    .body_contains(r#""application":{"service_name":"test_service","service_version":"test_version","env":"test_env","language_name":"test_language","language_version":"test_language_version","tracer_version":"test_tracer_version"}"#);
+                    .body_includes(r#""application":{"service_name":"test_service","service_version":"test_version","env":"test_env","language_name":"test_language","language_version":"test_language_version","tracer_version":"test_tracer_version"}"#);
                 then.status(200).body("");
             })
             .await;
@@ -765,7 +765,12 @@ mod tests {
             })
             .unwrap();
         client.shutdown().await;
+        // Wait for the server to receive at least one call, but don't hang forever.
+        let start = std::time::Instant::now();
         while telemetry_srv.calls_async().await == 0 {
+            if start.elapsed() > Duration::from_secs(180) {
+                panic!("telemetry server did not receive calls within timeout");
+            }
             sleep(Duration::from_millis(10)).await;
         }
         // One payload generate-metrics

datadog-ipc/tarpc/examples/compression.rs

@@ -25,12 +25,6 @@ pub enum CompressedMessage<T> {
     },
 }
 
-#[derive(Deserialize, Serialize)]
-enum CompressionType {
-    Uncompressed,
-    Compressed,
-}
-
 async fn compress<T>(message: T) -> io::Result<CompressedMessage<T>>
 where
     T: Serialize,

datadog-live-debugger-ffi/src/evaluator.rs

@@ -33,6 +33,7 @@ impl<'a> From<&'a datadog_live_debugger::IntermediateValue<'a, c_void>> for Inte
     }
 }
 
+#[allow(clippy::zero_ptr)] // written this way for cbindgen's sake
 pub const EVALUATOR_RESULT_UNDEFINED: *const c_void = 0isize as *const c_void;
 pub const EVALUATOR_RESULT_INVALID: *const c_void = -1isize as *const c_void;
 pub const EVALUATOR_RESULT_REDACTED: *const c_void = -2isize as *const c_void;

datadog-sidecar-ffi/src/lib.rs

@@ -35,15 +35,14 @@ use datadog_sidecar::shm_remote_config::{path_for_remote_config, RemoteConfigRea
 use datadog_trace_utils::msgpack_encoder;
 use ddcommon::tag::Tag;
 use ddcommon::Endpoint;
-use ddcommon_ffi as ffi;
-use ddcommon_ffi::{CharSlice, MaybeError};
+use ddcommon_ffi::slice::{AsBytes, CharSlice};
+use ddcommon_ffi::{self as ffi, MaybeError};
 use ddtelemetry::{
     data::{self, Dependency, Integration},
     worker::{LifecycleAction, LogIdentifier, TelemetryActions},
 };
 use ddtelemetry_ffi::try_c;
 use dogstatsd_client::DogStatsDActionOwned;
-use ffi::slice::AsBytes;
 use libc::c_char;
 use std::ffi::{c_void, CStr, CString};
 use std::fs::File;
@@ -686,11 +685,9 @@ pub unsafe extern "C" fn ddog_sidecar_enqueue_telemetry_log(
 }
 
 fn char_slice_to_string(slice: CharSlice) -> Result<String, String> {
-    let cast_slice =
-        unsafe { slice::from_raw_parts(slice.as_slice().as_ptr() as *const u8, slice.len()) };
-    let slice = std::str::from_utf8(cast_slice)
-        .map_err(|e| format!("Failed to convert CharSlice to String: {e}"))?;
-    Ok(slice.to_string())
+    slice
+        .try_to_string()
+        .map_err(|e| format!("Failed to convert CharSlice to String: {e}"))
 }
 
 #[allow(clippy::too_many_arguments)]