style: fix clippy warnings

Author: morrisonlevi

datadog-profiling-ffi/src/profile_handle.rs

@@ -58,7 +58,7 @@ pub struct EmptyHandleError;
 /// # Safety
 ///
 /// Uses c-str literal to ensure valid UTF-8 and null termination.
-unsafe impl ddcommon::error::FfiSafeErrorMessage for EmptyHandleError {
+unsafe impl FfiSafeErrorMessage for EmptyHandleError {
     fn as_ffi_str(&self) -> &'static CStr {
         c"handle used with an interior null pointer"
     }

datadog-profiling-ffi/src/profiles/pprof_builder/mod.rs

@@ -57,6 +57,7 @@ pub unsafe extern "C" fn ddog_prof_PprofBuilder_new(
 ///   references to that builder may be active for the duration of the call.
 /// - `profile` must be non-null and point to a valid `Profile` that
 ///   remains alive until the pprof builder is done.
+///
 /// TODO: finish safety
 #[must_use]
 #[no_mangle]
@@ -69,7 +70,7 @@ pub unsafe extern "C" fn ddog_prof_PprofBuilder_add_profile(
         let builder = unsafe {
             handle
                 .as_inner_mut()
-                .map_err(|e| ProfileStatus::from_ffi_safe_error_message(e))?
+                .map_err(ProfileStatus::from_ffi_safe_error_message)?
         };
         let prof_ref = unsafe { &*profile };
         builder
@@ -90,6 +91,7 @@ pub unsafe extern "C" fn ddog_prof_PprofBuilder_add_profile(
 ///   references to that builder may be active for the duration of the call.
 /// - `profile` must be non-null and point to a valid `Profile` that
 ///   remains alive until the pprof builder is done.
+///
 /// TODO: finish safety
 #[must_use]
 #[no_mangle]
@@ -103,7 +105,7 @@ pub unsafe extern "C" fn ddog_prof_PprofBuilder_add_profile_with_poisson_upscali
         let builder = unsafe {
             handle
                 .as_inner_mut()
-                .map_err(|e| ProfileStatus::from_ffi_safe_error_message(e))?
+                .map_err(ProfileStatus::from_ffi_safe_error_message)?
         };
         let prof_ref = unsafe { &*profile };
 
@@ -128,6 +130,7 @@ pub unsafe extern "C" fn ddog_prof_PprofBuilder_add_profile_with_poisson_upscali
 ///   references to that builder may be active for the duration of the call.
 /// - `profile` must be non-null and point to a valid `Profile` that
 ///   remains alive until the pprof builder is done.
+///
 /// TODO: finish safety
 #[must_use]
 #[no_mangle]

datadog-profiling/src/profiles/pprof_builder/mod.rs

@@ -104,14 +104,19 @@ pub struct PprofBuilder<'a> {
     state: PprofBuilderState<'a>,
 }
 
+struct ProfileWithUpscaling<'a> {
+    profile: &'a Profile,
+    upscalings: Vec<UpscalingRule>,
+}
+
 enum PprofBuilderState<'a> {
     Initialized,
     Configured {
         options: PprofOptions,
     },
     AddingProfiles {
         options: PprofOptions,
-        profiles: Vec<(&'a Profile, Vec<UpscalingRule>)>,
+        profiles: Vec<ProfileWithUpscaling<'a>>,
         string_table: StringTable<'a>,
     },
 }
@@ -222,9 +227,11 @@ impl<'a> PprofBuilder<'a> {
             };
             new_rules.push(UpscalingRule::ProportionalUpscalingRule(rule));
         }
-
         profiles
-            .try_push((profile, new_rules))
+            .try_push(ProfileWithUpscaling {
+                profile,
+                upscalings: new_rules,
+            })
             .map_err(|_| TryAddProfileError::OutOfMemoryProportionalUpscaling)
     }
 
@@ -239,34 +246,34 @@ impl<'a> PprofBuilder<'a> {
             return Err(TryAddProfileError::WrongSampleTypeCountForPoisson);
         }
 
-        let mut new_rules = Vec::new();
-        new_rules
+        let mut upscaling_rules = Vec::new();
+        upscaling_rules
             .try_reserve_exact(1)
             .map_err(|_| TryAddProfileError::OutOfMemoryPoissonUpscaling)?;
-        new_rules.push(UpscalingRule::PoissonUpscalingRule(upscaling_rule));
+        upscaling_rules.push(UpscalingRule::PoissonUpscalingRule(upscaling_rule));
 
         profiles
-            .try_push((profile, new_rules))
+            .try_push(ProfileWithUpscaling {
+                profile,
+                upscalings: upscaling_rules,
+            })
             .map_err(|_| TryAddProfileError::OutOfMemoryPoissonUpscaling)
     }
 
     pub fn try_add_profile(&mut self, profile: &'a Profile) -> Result<(), TryAddProfileError> {
         let (profiles, _) = self.transition_to_adding_profiles()?;
-
         profiles
-            .try_push((profile, Vec::new()))
+            .try_push(ProfileWithUpscaling {
+                profile,
+                upscalings: Vec::new(),
+            })
             .map_err(|_| TryAddProfileError::OutOfMemoryWithoutUpscaling)
     }
 
     fn transition_to_adding_profiles(
         &mut self,
-    ) -> Result<
-        (
-            &mut Vec<(&'a Profile, Vec<UpscalingRule>)>,
-            &mut StringTable<'a>,
-        ),
-        TryAddProfileError,
-    > {
+    ) -> Result<(&mut Vec<ProfileWithUpscaling<'a>>, &mut StringTable<'a>), TryAddProfileError>
+    {
         if matches!(self.state, Initialized) {
             let options = PprofOptions::default();
             self.state = Configured { options };
@@ -324,14 +331,17 @@ impl<'a> PprofBuilder<'a> {
         let dict_strings = dict.strings();
 
         // --- unify sample types across profiles and emit ---
-        let n_sample_types = profiles.iter().map(|(p, _)| p.sample_type.len()).sum();
+        let n_sample_types = profiles
+            .iter()
+            .map(|pwu| pwu.profile.sample_type.len())
+            .sum();
         let n_profiles = profiles.len();
 
         let mut remaps: Vec<ArrayVec<usize, MAX_SAMPLE_TYPES>> = Vec::new();
         {
             let mut remapper = Remapper::new(dict_strings, &mut string_table, n_sample_types)?;
             remaps.try_reserve_exact(n_profiles)?;
-            for profile in profiles.iter().map(|(p, _)| p) {
+            for profile in profiles.iter().map(|pwu| pwu.profile) {
                 let mut offsets = ArrayVec::new();
                 for sample_type in profile.sample_type.iter() {
                     if offsets
@@ -378,9 +388,9 @@ impl<'a> PprofBuilder<'a> {
         let mut values_buf: Vec<i64> = Vec::new();
         let mut labels_buf: Vec<pprof::Record<pprof::Label, 3, { pprof::NO_OPT_ZERO }>> =
             Vec::new();
-        for (i, (prof, upscaling_rules)) in profiles.iter().enumerate() {
+        for (i, pwu) in profiles.iter().enumerate() {
             let remap = &remaps[i];
-            for sample in &prof.samples {
+            for sample in &pwu.profile.samples {
                 // location ids from stack
                 let stack = sample.stack_id.as_slice();
                 let mut locs_out: Vec<u64> = Vec::with_capacity(stack.len());
@@ -496,7 +506,7 @@ impl<'a> PprofBuilder<'a> {
                 }
 
                 // Apply upscaling
-                for rule in upscaling_rules {
+                for rule in &pwu.upscalings {
                     rule.scale(&mut values_buf, &labels_buf);
                 }
 

datadog-profiling/src/profiles/pprof_builder/upscaling.rs

@@ -40,14 +40,10 @@ impl ProportionalUpscalingRule {
             if group_by_label.key.is_zero() && group_by_label.value.is_zero() {
                 scale_values(values, scale);
             } else {
-                let matched = labels
-                    .iter()
-                    .find(|label| {
-                        let label = &label.value;
-                        label.key.value == group_by_label.key
-                            && label.str.value == group_by_label.value
-                    })
-                    .is_some();
+                let matched = labels.iter().any(|label| {
+                    let label = &label.value;
+                    label.key.value == group_by_label.key && label.str.value == group_by_label.value
+                });
                 if matched {
                     scale_values(values, scale);
                 }
@@ -65,8 +61,8 @@ pub struct PoissonUpscalingRule {
 
 impl PoissonUpscalingRule {
     pub fn compute_scale(&self, values: &[i64]) -> f64 {
-        let sum_offset = self.sum_offset as usize;
-        let count_offset = self.count_offset as usize;
+        let sum_offset = self.sum_offset;
+        let count_offset = self.count_offset;
         let sum = values[sum_offset];
         let count = values[count_offset];
         let sampling_distance = self.sampling_distance.get() as f64;