[mq] working branch - merge 0618837 on top of main at 3757554

{"baseBranch":"main","baseCommit":"375755474367e7e7612e580922316dc3d66e4aff","createdAt":"2025-12-17T20:39:06.704256Z","headSha":"06188379a776165dea0921c93bb3b1311f434e32","id":"3bd6fa32-6aa7-4255-8428-5bd70d7b014c","priority":"200","pullRequestNumber":"1406","queuedAt":"2025-12-17T20:39:06.703085Z","status":"STATUS_QUEUED"}

Author: dd-mergequeue[bot]

examples/ffi/profiles.c

@@ -6,6 +6,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+// Number of samples to add with each API
+#define NUM_SAMPLES 5000000
+
 int main(void) {
   const ddog_prof_ValueType wall_time = {
       .type_ = DDOG_CHARSLICE_C("wall-time"),
@@ -14,16 +17,27 @@ int main(void) {
   const ddog_prof_Slice_ValueType sample_types = {&wall_time, 1};
   const ddog_prof_Period period = {wall_time, 60};
 
-  ddog_prof_Profile_NewResult new_result = ddog_prof_Profile_new(sample_types, &period);
-  if (new_result.tag != DDOG_PROF_PROFILE_NEW_RESULT_OK) {
-    ddog_CharSlice message = ddog_Error_message(&new_result.err);
-    fprintf(stderr, "%.*s", (int)message.len, message.ptr);
-    ddog_Error_drop(&new_result.err);
+  // Create a ProfilesDictionary for the new API
+  ddog_prof_ProfilesDictionaryHandle dict = {0};
+  ddog_prof_Status dict_status = ddog_prof_ProfilesDictionary_new(&dict);
+  if (dict_status.flags != 0) {
+    fprintf(stderr, "Failed to create dictionary: %s\n", dict_status.err);
+    ddog_prof_Status_drop(&dict_status);
     exit(EXIT_FAILURE);
   }
 
-  ddog_prof_Profile *profile = &new_result.ok;
+  // Create profile using the dictionary
+  ddog_prof_Profile profile = {0};
+  ddog_prof_Status profile_status =
+      ddog_prof_Profile_with_dictionary(&profile, &dict, sample_types, &period);
+  if (profile_status.flags != 0) {
+    fprintf(stderr, "Failed to create profile: %s\n", profile_status.err);
+    ddog_prof_Status_drop(&profile_status);
+    ddog_prof_ProfilesDictionary_drop(&dict);
+    exit(EXIT_FAILURE);
+  }
 
+  // Original API sample
   ddog_prof_Location root_location = {
       // yes, a zero-initialized mapping is valid
       .mapping = (ddog_prof_Mapping){0},
@@ -44,28 +58,107 @@ int main(void) {
       .labels = {&label, 1},
   };
 
-  for (int i = 0; i < 10000000; i++) {
+  for (int i = 0; i < NUM_SAMPLES; i++) {
     label.num = i;
 
-    ddog_prof_Profile_Result add_result = ddog_prof_Profile_add(profile, sample, 0);
+    ddog_prof_Profile_Result add_result = ddog_prof_Profile_add(&profile, sample, 0);
     if (add_result.tag != DDOG_PROF_PROFILE_RESULT_OK) {
       ddog_CharSlice message = ddog_Error_message(&add_result.err);
       fprintf(stderr, "%.*s", (int)message.len, message.ptr);
       ddog_Error_drop(&add_result.err);
     }
   }
 
+  // New API sample using the dictionary
+  // Insert strings into the dictionary
+  ddog_prof_StringId2 function_name_id, filename_id, label_key_id;
+
+  dict_status = ddog_prof_ProfilesDictionary_insert_str(
+      &function_name_id, dict, DDOG_CHARSLICE_C("{main}"), DDOG_PROF_UTF8_OPTION_ASSUME);
+  if (dict_status.flags != 0) {
+    fprintf(stderr, "Failed to insert function name: %s\n", dict_status.err);
+    ddog_prof_Status_drop(&dict_status);
+    goto cleanup;
+  }
+
+  dict_status = ddog_prof_ProfilesDictionary_insert_str(&filename_id, dict,
+                                                        DDOG_CHARSLICE_C("/srv/example/index.php"),
+                                                        DDOG_PROF_UTF8_OPTION_ASSUME);
+  if (dict_status.flags != 0) {
+    fprintf(stderr, "Failed to insert filename: %s\n", dict_status.err);
+    ddog_prof_Status_drop(&dict_status);
+    goto cleanup;
+  }
+
+  dict_status = ddog_prof_ProfilesDictionary_insert_str(
+      &label_key_id, dict, DDOG_CHARSLICE_C("unique_counter"), DDOG_PROF_UTF8_OPTION_ASSUME);
+  if (dict_status.flags != 0) {
+    fprintf(stderr, "Failed to insert label key: %s\n", dict_status.err);
+    ddog_prof_Status_drop(&dict_status);
+    goto cleanup;
+  }
+
+  // Create a function using the dictionary IDs
+  ddog_prof_FunctionId2 function_id;
+  ddog_prof_Function2 function2 = {
+      .name = function_name_id,
+      .system_name = DDOG_PROF_STRINGID2_EMPTY,
+      .file_name = filename_id,
+  };
+
+  dict_status = ddog_prof_ProfilesDictionary_insert_function(&function_id, dict, &function2);
+  if (dict_status.flags != 0) {
+    fprintf(stderr, "Failed to insert function: %s\n", dict_status.err);
+    ddog_prof_Status_drop(&dict_status);
+    goto cleanup;
+  }
+
+  // Create a location using the dictionary IDs
+  ddog_prof_Location2 location2 = {
+      .mapping = (ddog_prof_MappingId2){0}, // null mapping is valid
+      .function = function_id,
+      .address = 0,
+      .line = 0,
+  };
+
+  // New API sample using dictionary IDs
+  ddog_prof_Label2 label2 = {
+      .key = label_key_id,
+      .str = DDOG_CHARSLICE_C(""),
+      .num = 0,
+      .num_unit = DDOG_CHARSLICE_C(""),
+  };
+  const ddog_prof_Sample2 sample2 = {
+      .locations = {&location2, 1},
+      .values = {&value, 1},
+      .labels = {&label2, 1},
+  };
+
+  for (int i = 0; i < NUM_SAMPLES; i++) {
+    label2.num = i;
+
+    ddog_prof_Status add2_status = ddog_prof_Profile_add2(&profile, sample2, 0);
+    if (add2_status.flags != 0) {
+      fprintf(stderr, "add2 error: %s\n", add2_status.err);
+      ddog_prof_Status_drop(&add2_status);
+    }
+  }
+
   //   printf("Press any key to reset and drop...");
   //   getchar();
 
-  ddog_prof_Profile_Result reset_result = ddog_prof_Profile_reset(profile);
+cleanup:
+  ; // Can't have a declaration after a label pre-C23, so use an empty statement.
+  ddog_prof_Profile_Result reset_result = ddog_prof_Profile_reset(&profile);
   if (reset_result.tag != DDOG_PROF_PROFILE_RESULT_OK) {
     ddog_CharSlice message = ddog_Error_message(&reset_result.err);
     fprintf(stderr, "%.*s", (int)message.len, message.ptr);
     ddog_Error_drop(&reset_result.err);
   }
-  ddog_prof_Profile_drop(profile);
+  ddog_prof_Profile_drop(&profile);
 
+  // Drop the dictionary
+  ddog_prof_ProfilesDictionary_drop(&dict);
 
   return 0;
-}
+}

libdd-profiling-ffi/src/profiles/datatypes.rs

@@ -2,12 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::string_storage::{get_inner_string_storage, ManagedStringStorage};
+use crate::{ensure_non_null_out_parameter, ArcHandle, ProfileError, ProfileStatus};
 use anyhow::Context;
 use function_name::named;
 use libdd_common_ffi::slice::{AsBytes, ByteSlice, CharSlice, Slice};
 use libdd_common_ffi::{wrap_with_ffi_result, Error, Handle, Timespec, ToInner};
 use libdd_profiling::api::{self, ManagedStringId};
-use libdd_profiling::internal;
+use libdd_profiling::profiles::datatypes::{ProfilesDictionary, StringId2};
+use libdd_profiling::{api2, internal};
 use std::num::NonZeroI64;
 use std::str::Utf8Error;
 use std::time::SystemTime;
@@ -215,6 +217,44 @@ pub struct Sample<'a> {
     pub labels: Slice<'a, Label<'a>>,
 }
 
+#[derive(Copy, Clone, Debug, Default)]
+#[repr(C)]
+pub struct Label2<'a> {
+    pub key: StringId2,
+
+    /// At most one of `.str` and `.num` should not be empty.
+    pub str: CharSlice<'a>,
+    pub num: i64,
+
+    /// Should only be present when num is present.
+    /// Specifies the units of num.
+    /// Use arbitrary string (for example, "requests") as a custom count unit.
+    /// If no unit is specified, consumer may apply heuristic to deduce the unit.
+    /// Consumers may also  interpret units like "bytes" and "kilobytes" as memory
+    /// units and units like "seconds" and "nanoseconds" as time units,
+    /// and apply appropriate unit conversions to these.
+    pub num_unit: CharSlice<'a>,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Sample2<'a> {
+    /// The leaf is at locations[0].
+    pub locations: Slice<'a, api2::Location2>,
+
+    /// The type and unit of each value is defined by the corresponding
+    /// entry in Profile.sample_type. All samples must have the same
+    /// number of values, the same as the length of Profile.sample_type.
+    /// When aggregating multiple samples into a single sample, the
+    /// result has a list of values that is the element-wise sum of the
+    /// lists of the originals.
+    pub values: Slice<'a, i64>,
+
+    /// label includes additional context for this sample. It can include
+    /// things like a thread id, allocation size, etc
+    pub labels: Slice<'a, Label2<'a>>,
+}
+
 impl<'a> TryFrom<&'a Mapping<'a>> for api::Mapping<'a> {
     type Error = Utf8Error;
 
@@ -400,6 +440,64 @@ pub unsafe extern "C" fn ddog_prof_Profile_new(
     profile_new(sample_types, period, None)
 }
 
+/// Create a new profile with the given sample types. Must call
+/// `ddog_prof_Profile_drop` when you are done with the profile.
+///
+/// # Arguments
+/// * `out` - a non-null pointer to an uninitialized Profile.
+/// * `dict`: a valid reference to a ProfilesDictionary handle.
+/// * `sample_types`
+/// * `period` - Optional period of the profile. Passing None/null translates to zero values.
+///
+/// # Safety
+/// All slices must have pointers that are suitably aligned for their type
+/// and must have the correct number of elements for the slice.
+///
+/// The `dict` reference must be to a valid ProfilesDictionary handle. It may
+/// be an empty handle, but it must be a valid handle.
+///
+/// The `out` pointer must be non-null and suitable for pointer writes,
+/// including that it has the correct size and alignment.
+#[no_mangle]
+#[must_use]
+pub unsafe extern "C" fn ddog_prof_Profile_with_dictionary(
+    out: *mut Profile,
+    dict: &ArcHandle<ProfilesDictionary>,
+    sample_types: Slice<ValueType>,
+    period: Option<&Period>,
+) -> ProfileStatus {
+    ensure_non_null_out_parameter!(out);
+    match profile_with_dictionary(dict, sample_types, period) {
+        // SAFETY: checked that it isn't null above, the rest comes from this
+        // function's own safety conditions. Technically, our safety conditions
+        // don't require a null check, but we're being safe there.
+        Ok(profile) => unsafe {
+            out.write(profile);
+            ProfileStatus::OK
+        },
+        Err(e) => ProfileStatus::from(e),
+    }
+}
+
+unsafe fn profile_with_dictionary(
+    dict: &ArcHandle<ProfilesDictionary>,
+    sample_types: Slice<ValueType>,
+    period: Option<&Period>,
+) -> Result<Profile, ProfileError> {
+    let sample_types = sample_types.try_as_slice()?;
+    let dict = dict.try_clone_into_arc()?;
+
+    let mut types = Vec::new();
+    types.try_reserve_exact(sample_types.len())?;
+    types.extend(sample_types.iter().map(api::ValueType::from));
+    let period = period.map(Into::into);
+
+    match internal::Profile::try_new_with_dictionary(&types, period, dict) {
+        Ok(ok) => Ok(Profile::new(ok)),
+        Err(err) => Err(ProfileError::from(err)),
+    }
+}
+
 /// Same as `ddog_profile_new` but also configures a `string_storage` for the profile.
 #[no_mangle]
 #[must_use]
@@ -508,6 +606,42 @@ pub unsafe extern "C" fn ddog_prof_Profile_add(
     .context("ddog_prof_Profile_add failed")
     .into()
 }
+/// # Safety
+/// The `profile` ptr must point to a valid Profile object created by this
+/// module. All pointers inside the `sample` need to be valid for the duration
+/// of this call.
+///
+/// If successful, it returns the Ok variant.
+/// On error, it holds an error message in the error variant.
+///
+/// This call is _NOT_ thread-safe.
+#[must_use]
+#[no_mangle]
+pub unsafe extern "C" fn ddog_prof_Profile_add2(
+    profile: *mut Profile,
+    sample: Sample2,
+    timestamp: Option<NonZeroI64>,
+) -> ProfileStatus {
+    ProfileStatus::from((|| {
+        let profile = profile_ptr_to_inner(profile)?;
+
+        let locations = sample.locations.try_as_slice()?;
+        let values = sample.values.try_as_slice()?;
+        let labels = sample.labels.try_as_slice()?;
+
+        let labels_iter = labels.iter().map(|label| -> anyhow::Result<api2::Label> {
+            Ok(api2::Label {
+                key: label.key,
+                str: core::str::from_utf8(label.str.try_as_bytes()?)?,
+                num: label.num,
+                num_unit: core::str::from_utf8(label.num_unit.try_as_bytes()?)?,
+            })
+        });
+        profile
+            .try_add_sample2(locations, values, labels_iter, timestamp)
+            .context("ddog_prof_Profile_add failed")
+    })())
+}
 
 pub(crate) unsafe fn profile_ptr_to_inner<'a>(
     profile_ptr: *mut Profile,