refactor: consolidate similar code

Author: morrisonlevi

libdd-profiling-ffi/src/profile_error.rs

@@ -22,6 +22,48 @@ pub enum ProfileError {
     Other(Cow<'static, CStr>),
 }
 
+impl ProfileError {
+    /// Creates a ProfileError by formatting a Display-able error.
+    pub fn from_display<E: fmt::Display>(err: E) -> Self {
+        use core::fmt::Write;
+
+        let mut writer = FallibleStringWriter::new();
+        if write!(writer, "{err}").is_err() {
+            return ProfileError::AllocError;
+        }
+
+        let mut string = String::from(writer);
+
+        // Check for interior null bytes using memchr
+        let pos = unsafe { libc::memchr(string.as_ptr().cast(), 0, string.len()) };
+        if !pos.is_null() {
+            return ProfileError::from(
+                c"encountered an interior null byte while formatting an error message",
+            );
+        }
+
+        // Reserve memory for the null terminator. We have to shrink later in
+        // order to turn it into a CString, so we don't want any excess capacity.
+        if string.try_reserve_exact(1).is_err() {
+            return ProfileError::AllocError;
+        }
+        string.push('\0');
+
+        // Shrink to avoid potential panic in CString::from_vec_unchecked
+        if string_try_shrink_to_fit(&mut string).is_err() {
+            return ProfileError::AllocError;
+        }
+
+        // Pop the null off because CString::from_vec_unchecked adds one.
+        _ = string.pop();
+
+        // SAFETY: We checked for interior null bytes with memchr above,
+        // and the string is valid UTF-8 because it came from formatting.
+        let cstring = unsafe { CString::from_vec_unchecked(string.into_bytes()) };
+        ProfileError::Other(Cow::Owned(cstring))
+    }
+}
+
 /// Represents an error that means the handle is empty, meaning it doesn't
 /// point to a resource.
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
@@ -132,26 +174,7 @@ impl From<std::io::Error> for ProfileError {
         match err.kind() {
             ErrorKind::StorageFull => ProfileError::CapacityOverflow,
             ErrorKind::WriteZero | ErrorKind::OutOfMemory => ProfileError::AllocError,
-            e => {
-                let mut writer = FallibleStringWriter::new();
-                use core::fmt::Write;
-                // Add null terminator that from_vec_with_nul expects.
-                if write!(&mut writer, "{e}\0").is_err() {
-                    return ProfileError::from(
-                        c"memory allocation failed while trying to create an error message",
-                    );
-                }
-                let mut string = String::from(writer);
-                // We do this to avoid the potential panic case of failed
-                // allocation in CString::from_vec_with_nul.
-                if string_try_shrink_to_fit(&mut string).is_err() {
-                    return ProfileError::from(c"memory allocation failed while trying to shrink a vec to create an error message");
-                }
-                match CString::from_vec_with_nul(string.into_bytes()) {
-                    Ok(cstring) => ProfileError::Other(Cow::Owned(cstring)),
-                    Err(_) => ProfileError::from(c"encountered an interior null byte while converting a std::io::Error into a ProfileError")
-                }
-            }
+            e => ProfileError::from_display(e),
         }
     }
 }

libdd-profiling-ffi/src/profile_status.rs

@@ -1,8 +1,8 @@
 // Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
+use crate::ProfileError;
 use allocator_api2::alloc::{AllocError, Allocator, Global, Layout};
-use libdd_profiling::profiles::FallibleStringWriter;
 use std::borrow::Cow;
 use std::ffi::{c_char, CStr, CString};
 use std::fmt::Display;
@@ -259,58 +259,14 @@ impl ProfileStatus {
         err: null(),
     };
 
-    const OUT_OF_MEMORY: ProfileStatus = ProfileStatus {
-        flags: FLAG_STATIC,
-        err: c"out of memory while trying to display error".as_ptr(),
-    };
-    const NULL_BYTE_IN_ERROR_MESSAGE: ProfileStatus = ProfileStatus {
-        flags: FLAG_STATIC,
-        err: c"another error occured, but cannot be displayed because it has interior null bytes"
-            .as_ptr(),
-    };
-
     pub fn from_ffi_safe_error_message<E: libdd_common::error::FfiSafeErrorMessage>(
         err: E,
     ) -> Self {
         ProfileStatus::from(err.as_ffi_str())
     }
 
     pub fn from_error<E: Display>(err: E) -> Self {
-        use core::fmt::Write;
-        let mut writer = FallibleStringWriter::new();
-        if write!(writer, "{err}").is_err() {
-            return ProfileStatus::OUT_OF_MEMORY;
-        }
-
-        let mut str = String::from(writer);
-
-        // std doesn't expose memchr even though it has it, but fortunately
-        // libc has it, and we use the libc crate already in FFI.
-        let pos = unsafe { libc::memchr(str.as_ptr().cast(), 0, str.len()) };
-        if !pos.is_null() {
-            return ProfileStatus::NULL_BYTE_IN_ERROR_MESSAGE;
-        }
-
-        // Reserve memory exactly. We have to shrink later in order to turn
-        // it into a box, so we don't want any excess capacity.
-        if str.try_reserve_exact(1).is_err() {
-            return ProfileStatus::OUT_OF_MEMORY;
-        }
-        str.push('\0');
-
-        if string_try_shrink_to_fit(&mut str).is_err() {
-            return ProfileStatus::OUT_OF_MEMORY;
-        }
-
-        // Pop the null off because CString::from_vec_unchecked adds one.
-        _ = str.pop();
-
-        // And finally, this is why we went through the pain of
-        // string_try_shrink_to_fit: this method will call shrink_to_fit, so
-        // to avoid an allocation failure here, we had to make a String with
-        // no excess capacity.
-        let cstring = unsafe { CString::from_vec_unchecked(str.into_bytes()) };
-        ProfileStatus::from(cstring)
+        ProfileStatus::from(ProfileError::from_display(err))
     }
 }