From 041973b91c04f2e06b27e5fda8c5726aecfb8a64 Mon Sep 17 00:00:00 2001
From: Daniel Schwartz-Narbonne <daniel.schwartznarbonne@datadoghq.com>
Date: Thu, 23 May 2024 14:40:49 -0400
Subject: [PATCH 01/54] [profiling] Fuzz profiler API

---
 Cargo.lock                        | 22 ++++++++++++++++++++++
 profiling/Cargo.toml              |  5 +++--
 profiling/src/api.rs              | 16 ++++++++++++++++
 profiling/src/internal/profile.rs | 10 ++++++++++
 4 files changed, 51 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cc280d547..439009e41 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -130,6 +130,15 @@ version = "1.0.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f538837af36e6f6a9be0faa67f9a314f8119e4e4b5867c6ab40ed60360142519"
 
+[[package]]
+name = "arbitrary"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
+dependencies = [
+ "derive_arbitrary",
+]
+
 [[package]]
 name = "arrayref"
 version = "0.3.7"
@@ -613,6 +622,7 @@ version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac749fb4f2e14734e835a9352c0d1eb2ab62a025d4c56a823fa3f391e015741a"
 dependencies = [
+ "arbitrary",
  "bolero-generator-derive",
  "either",
  "rand_core",
@@ -1190,6 +1200,7 @@ name = "datadog-profiling"
 version = "10.0.0"
 dependencies = [
  "anyhow",
+ "arbitrary",
  "bitmaps",
  "bolero",
  "bolero-generator",
@@ -1535,6 +1546,17 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "derive_arbitrary"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
 [[package]]
 name = "diff"
 version = "0.1.13"
diff --git a/profiling/Cargo.toml b/profiling/Cargo.toml
index e877b778c..a06234594 100644
--- a/profiling/Cargo.toml
+++ b/profiling/Cargo.toml
@@ -46,6 +46,7 @@ tokio-util = "0.7.1"
 byteorder = { version = "1.5", features = ["std"] }
 
 [dev-dependencies]
-bolero = "0.10.1"
-bolero-generator = "0.10.2"
+arbitrary = { version = "1.3.2", features = ["derive", "derive_arbitrary"] }
+bolero = { version = "0.10.1", features = ["arbitrary"] }
+bolero-generator = { version = "0.10.2", features = ["arbitrary"] }
 criterion = "0.5.1"
diff --git a/profiling/src/api.rs b/profiling/src/api.rs
index 477fd75ec..3342c8601 100644
--- a/profiling/src/api.rs
+++ b/profiling/src/api.rs
@@ -343,6 +343,22 @@ impl<'a> TryFrom<&'a pprof::Profile> for Profile<'a> {
     }
 }
 
+#[cfg(test)]
+pub mod OwnedApi {
+    #[derive(Clone, Debug, Eq, PartialEq)]
+    #[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
+    pub struct ValueType {
+        pub typ: String,
+        pub unit: String,
+    }
+
+    impl<'a> From<&'a ValueType> for super::ValueType<'a> {
+        fn from(value: &'a ValueType) -> Self {
+            super::ValueType::new(&value.typ, &value.unit)
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 09bcfe274..3dcf10587 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -545,6 +545,16 @@ impl Profile {
 mod api_tests {
     use super::*;
 
+    #[test]
+    fn fuzz() {
+        use bolero::TypeGenerator;
+
+        bolero::check!().with_generator(Vec::<api::OwnedApi::ValueType>::gen()).for_each(|val| {
+            let sample_types : Vec<_> = val.iter().map(api::ValueType::from).collect();
+            Profile::new(SystemTime::now(), &sample_types, None);
+        })
+    }
+
     #[test]
     fn interning() {
         let sample_types = [api::ValueType::new("samples", "count")];

From 50929a6f466132c811c94cc564118cbc545e4ae9 Mon Sep 17 00:00:00 2001
From: Daniel Schwartz-Narbonne <daniel.schwartznarbonne@datadoghq.com>
Date: Thu, 23 May 2024 15:06:46 -0400
Subject: [PATCH 02/54] make owned types orthogonal to api types

---
 profiling/src/internal/mod.rs         |  1 -
 profiling/src/internal/owned_types.rs | 17 +++++++++--------
 profiling/src/internal/profile.rs     | 18 +++++++++---------
 3 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/profiling/src/internal/mod.rs b/profiling/src/internal/mod.rs
index 72f11a9c1..063fd7006 100644
--- a/profiling/src/internal/mod.rs
+++ b/profiling/src/internal/mod.rs
@@ -23,7 +23,6 @@ pub use label::*;
 pub use location::*;
 pub use mapping::*;
 pub use observation::*;
-pub use owned_types::*;
 pub use profile::*;
 pub use sample::*;
 pub use stack_trace::*;
diff --git a/profiling/src/internal/owned_types.rs b/profiling/src/internal/owned_types.rs
index 4df1058ca..9769ba3a7 100644
--- a/profiling/src/internal/owned_types.rs
+++ b/profiling/src/internal/owned_types.rs
@@ -1,17 +1,18 @@
 // Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::api::{Period, ValueType};
+use crate::api;
 
 #[derive(Clone)]
-pub struct OwnedValueType {
+#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
+pub struct ValueType {
     pub typ: Box<str>,
     pub unit: Box<str>,
 }
 
-impl<'a> From<&'a ValueType<'a>> for OwnedValueType {
+impl<'a> From<&'a api::ValueType<'a>> for ValueType {
     #[inline]
-    fn from(value_type: &'a ValueType<'a>) -> Self {
+    fn from(value_type: &'a api::ValueType<'a>) -> Self {
         Self {
             typ: String::from(value_type.r#type).into(),
             unit: String::from(value_type.unit).into(),
@@ -21,15 +22,15 @@ impl<'a> From<&'a ValueType<'a>> for OwnedValueType {
 
 #[derive(Clone)]
 pub struct OwnedPeriod {
-    pub typ: OwnedValueType,
+    pub typ: ValueType,
     pub value: i64,
 }
 
-impl<'a> From<&'a Period<'a>> for OwnedPeriod {
+impl<'a> From<&'a api::Period<'a>> for OwnedPeriod {
     #[inline]
-    fn from(period: &'a Period<'a>) -> Self {
+    fn from(period: &'a api::Period<'a>) -> Self {
         Self {
-            typ: OwnedValueType::from(&period.r#type),
+            typ: ValueType::from(&period.r#type),
             value: period.value,
         }
     }
diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 3dcf10587..ceb0a10ad 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -19,10 +19,10 @@ pub struct Profile {
     /// maintains them in a way that does not depend on the string table. The
     /// Option part is this is taken from the old profile and moved to the new
     /// one.
-    owned_sample_types: Option<Box<[OwnedValueType]>>,
+    owned_sample_types: Option<Box<[owned_types::ValueType]>>,
     /// When profiles are reset, the period needs to be preserved. This
     /// stores it in a way that does not depend on the string table.
-    owned_period: Option<OwnedPeriod>,
+    owned_period: Option<owned_types::OwnedPeriod>,
     endpoints: Endpoints,
     functions: FxIndexSet<Function>,
     labels: FxIndexSet<Label>,
@@ -331,13 +331,13 @@ impl Profile {
     }
 
     #[inline]
-    fn backup_period(src: Option<api::Period>) -> Option<OwnedPeriod> {
-        src.as_ref().map(OwnedPeriod::from)
+    fn backup_period(src: Option<api::Period>) -> Option<owned_types::OwnedPeriod> {
+        src.as_ref().map(owned_types::OwnedPeriod::from)
     }
 
     #[inline]
-    fn backup_sample_types(src: &[api::ValueType]) -> Option<Box<[OwnedValueType]>> {
-        Some(src.iter().map(OwnedValueType::from).collect())
+    fn backup_sample_types(src: &[api::ValueType]) -> Option<Box<[owned_types::ValueType]>> {
+        Some(src.iter().map(owned_types::ValueType::from).collect())
     }
 
     /// Fetches the endpoint information for the label. There may be errors,
@@ -419,8 +419,8 @@ impl Profile {
     /// the owned values.
     #[inline(never)]
     fn new_internal(
-        owned_period: Option<OwnedPeriod>,
-        owned_sample_types: Option<Box<[OwnedValueType]>>,
+        owned_period: Option<owned_types::OwnedPeriod>,
+        owned_sample_types: Option<Box<[owned_types::ValueType]>>,
         start_time: SystemTime,
     ) -> Self {
         let mut profile = Self {
@@ -467,7 +467,7 @@ impl Profile {
         // Break "cannot borrow `*self` as mutable because it is also borrowed
         // as immutable" by moving it out, borrowing it, and putting it back.
         let owned_period = profile.owned_period.take();
-        if let Some(OwnedPeriod { value, typ }) = &owned_period {
+        if let Some(owned_types::OwnedPeriod { value, typ }) = &owned_period {
             profile.period = Some((
                 *value,
                 ValueType {

From 2ddda7a62695e31f372e065a23387b4c3c94e61f Mon Sep 17 00:00:00 2001
From: Daniel Schwartz-Narbonne <daniel.schwartznarbonne@datadoghq.com>
Date: Thu, 23 May 2024 15:06:59 -0400
Subject: [PATCH 03/54] make owned types orthogonal to api types

---
 profiling/src/internal/owned_types.rs |  4 ++--
 profiling/src/internal/profile.rs     | 10 +++++-----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/profiling/src/internal/owned_types.rs b/profiling/src/internal/owned_types.rs
index 9769ba3a7..fd87cc75c 100644
--- a/profiling/src/internal/owned_types.rs
+++ b/profiling/src/internal/owned_types.rs
@@ -21,12 +21,12 @@ impl<'a> From<&'a api::ValueType<'a>> for ValueType {
 }
 
 #[derive(Clone)]
-pub struct OwnedPeriod {
+pub struct Period {
     pub typ: ValueType,
     pub value: i64,
 }
 
-impl<'a> From<&'a api::Period<'a>> for OwnedPeriod {
+impl<'a> From<&'a api::Period<'a>> for Period {
     #[inline]
     fn from(period: &'a api::Period<'a>) -> Self {
         Self {
diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index ceb0a10ad..0fd84f806 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -22,7 +22,7 @@ pub struct Profile {
     owned_sample_types: Option<Box<[owned_types::ValueType]>>,
     /// When profiles are reset, the period needs to be preserved. This
     /// stores it in a way that does not depend on the string table.
-    owned_period: Option<owned_types::OwnedPeriod>,
+    owned_period: Option<owned_types::Period>,
     endpoints: Endpoints,
     functions: FxIndexSet<Function>,
     labels: FxIndexSet<Label>,
@@ -331,8 +331,8 @@ impl Profile {
     }
 
     #[inline]
-    fn backup_period(src: Option<api::Period>) -> Option<owned_types::OwnedPeriod> {
-        src.as_ref().map(owned_types::OwnedPeriod::from)
+    fn backup_period(src: Option<api::Period>) -> Option<owned_types::Period> {
+        src.as_ref().map(owned_types::Period::from)
     }
 
     #[inline]
@@ -419,7 +419,7 @@ impl Profile {
     /// the owned values.
     #[inline(never)]
     fn new_internal(
-        owned_period: Option<owned_types::OwnedPeriod>,
+        owned_period: Option<owned_types::Period>,
         owned_sample_types: Option<Box<[owned_types::ValueType]>>,
         start_time: SystemTime,
     ) -> Self {
@@ -467,7 +467,7 @@ impl Profile {
         // Break "cannot borrow `*self` as mutable because it is also borrowed
         // as immutable" by moving it out, borrowing it, and putting it back.
         let owned_period = profile.owned_period.take();
-        if let Some(owned_types::OwnedPeriod { value, typ }) = &owned_period {
+        if let Some(owned_types::Period { value, typ }) = &owned_period {
             profile.period = Some((
                 *value,
                 ValueType {

From ef3de369d897b711e6dc3024901b56e44cd41119 Mon Sep 17 00:00:00 2001
From: Daniel Schwartz-Narbonne <daniel.schwartznarbonne@datadoghq.com>
Date: Thu, 23 May 2024 15:07:14 -0400
Subject: [PATCH 04/54] reformat

---
 profiling/src/internal/profile.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 0fd84f806..0c8407cf2 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -549,10 +549,12 @@ mod api_tests {
     fn fuzz() {
         use bolero::TypeGenerator;
 
-        bolero::check!().with_generator(Vec::<api::OwnedApi::ValueType>::gen()).for_each(|val| {
-            let sample_types : Vec<_> = val.iter().map(api::ValueType::from).collect();
-            Profile::new(SystemTime::now(), &sample_types, None);
-        })
+        bolero::check!()
+            .with_generator(Vec::<api::OwnedApi::ValueType>::gen())
+            .for_each(|val| {
+                let sample_types: Vec<_> = val.iter().map(api::ValueType::from).collect();
+                Profile::new(SystemTime::now(), &sample_types, None);
+            })
     }
 
     #[test]

From f23896c0f60e7b8a36031032a2b9d5507420fd38 Mon Sep 17 00:00:00 2001
From: Daniel Schwartz-Narbonne <daniel.schwartznarbonne@datadoghq.com>
Date: Thu, 23 May 2024 15:08:14 -0400
Subject: [PATCH 05/54] reformat

---
 profiling/src/internal/owned_types.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/profiling/src/internal/owned_types.rs b/profiling/src/internal/owned_types.rs
index fd87cc75c..e5468329b 100644
--- a/profiling/src/internal/owned_types.rs
+++ b/profiling/src/internal/owned_types.rs
@@ -20,7 +20,15 @@ impl<'a> From<&'a api::ValueType<'a>> for ValueType {
     }
 }
 
+impl<'a> From<&'a ValueType> for api::ValueType<'a> {
+    fn from(value: &'a ValueType) -> Self {
+        Self::new(&value.typ, &value.unit)
+    }
+}
+
+
 #[derive(Clone)]
+#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
 pub struct Period {
     pub typ: ValueType,
     pub value: i64,

From aa6fd91fca5ca990f8e1f46706c2ee51f79f25af Mon Sep 17 00:00:00 2001
From: Daniel Schwartz-Narbonne <daniel.schwartznarbonne@datadoghq.com>
Date: Thu, 23 May 2024 15:56:07 -0400
Subject: [PATCH 06/54] all the nice types

---
 profiling/src/api.rs                  |  16 ---
 profiling/src/internal/owned_types.rs | 192 ++++++++++++++++++++++++--
 profiling/src/internal/profile.rs     |   2 +-
 3 files changed, 180 insertions(+), 30 deletions(-)

diff --git a/profiling/src/api.rs b/profiling/src/api.rs
index 3342c8601..477fd75ec 100644
--- a/profiling/src/api.rs
+++ b/profiling/src/api.rs
@@ -343,22 +343,6 @@ impl<'a> TryFrom<&'a pprof::Profile> for Profile<'a> {
     }
 }
 
-#[cfg(test)]
-pub mod OwnedApi {
-    #[derive(Clone, Debug, Eq, PartialEq)]
-    #[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
-    pub struct ValueType {
-        pub typ: String,
-        pub unit: String,
-    }
-
-    impl<'a> From<&'a ValueType> for super::ValueType<'a> {
-        fn from(value: &'a ValueType) -> Self {
-            super::ValueType::new(&value.typ, &value.unit)
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/profiling/src/internal/owned_types.rs b/profiling/src/internal/owned_types.rs
index e5468329b..719a83245 100644
--- a/profiling/src/internal/owned_types.rs
+++ b/profiling/src/internal/owned_types.rs
@@ -3,31 +3,145 @@
 
 use crate::api;
 
-#[derive(Clone)]
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
 #[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
-pub struct ValueType {
-    pub typ: Box<str>,
-    pub unit: Box<str>,
+pub struct Function {
+    /// Name of the function, in human-readable form if available.
+    pub name: Box<str>,
+
+    /// Name of the function, as identified by the system.
+    /// For instance, it can be a C++ mangled name.
+    pub system_name: Box<str>,
+
+    /// Source file containing the function.
+    pub filename: Box<str>,
+
+    /// Line number in source file.
+    pub start_line: i64,
 }
 
-impl<'a> From<&'a api::ValueType<'a>> for ValueType {
-    #[inline]
-    fn from(value_type: &'a api::ValueType<'a>) -> Self {
+impl<'a> From<&'a Function> for api::Function<'a> {
+    fn from(value: &'a Function) -> Self {
         Self {
-            typ: String::from(value_type.r#type).into(),
-            unit: String::from(value_type.unit).into(),
+            name: &value.name,
+            system_name: &value.system_name,
+            filename: &value.filename,
+            start_line: value.start_line,
         }
     }
 }
 
-impl<'a> From<&'a ValueType> for api::ValueType<'a> {
-    fn from(value: &'a ValueType) -> Self {
-        Self::new(&value.typ, &value.unit)
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
+pub struct Label {
+    pub key: Box<str>,
+
+    /// At most one of the following must be present
+    pub str: Option<String>,
+    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: Option<Box<str>>,
+}
+
+impl<'a> From<&'a Label> for api::Label<'a> {
+    fn from(value: &'a Label) -> Self {
+        Self {
+            key: &value.key,
+            str: value.str.as_deref(),
+            num: value.num,
+            num_unit: value.num_unit.as_deref(),
+        }
     }
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
+pub struct Line {
+    /// The corresponding profile.Function for this line.
+    pub function: Function,
+
+    /// Line number in source code.
+    pub line: i64,
+}
+
+impl<'a> From<&'a Line> for api::Line<'a> {
+    fn from(value: &'a Line) -> Self {
+        Self {
+            function: (&value.function).into(),
+            line: value.line,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
+pub struct Location {
+    pub mapping: Mapping,
+    pub function: Function,
+
+    /// The instruction address for this location, if available.  It
+    /// should be within [Mapping.memory_start...Mapping.memory_limit]
+    /// for the corresponding mapping. A non-leaf address may be in the
+    /// middle of a call instruction. It is up to display tools to find
+    /// the beginning of the instruction if necessary.
+    pub address: u64,
+    pub line: i64,
+}
+
+impl<'a> From<&'a Location> for api::Location<'a> {
+    fn from(value: &'a Location) -> Self {
+        Self {
+            mapping: (&value.mapping).into(),
+            function: (&value.function).into(),
+            address: value.address,
+            line: value.line,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
+pub struct Mapping {
+    /// Address at which the binary (or DLL) is loaded into memory.
+    pub memory_start: u64,
+
+    /// The limit of the address range occupied by this mapping.
+    pub memory_limit: u64,
+
+    /// Offset in the binary that corresponds to the first mapped address.
+    pub file_offset: u64,
+
+    /// The object this entry is loaded from.  This can be a filename on
+    /// disk for the main binary and shared libraries, or virtual
+    /// abstractions like "[vdso]".
+    pub filename: Box<str>,
+
+    /// A string that uniquely identifies a particular program version
+    /// with high probability. E.g., for binaries generated by GNU tools,
+    /// it could be the contents of the .note.gnu.build-id field.
+    pub build_id: Box<str>,
+}
+
+impl<'a> From<&'a Mapping> for api::Mapping<'a> {
+    fn from(value: &'a Mapping) -> Self {
+        Self {
+            memory_start: value.memory_start,
+            memory_limit: value.memory_limit,
+            file_offset: value.file_offset,
+            filename: &value.filename,
+            build_id: &value.build_id,
+        }
+    }
+}
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 #[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
 pub struct Period {
     pub typ: ValueType,
@@ -43,3 +157,55 @@ impl<'a> From<&'a api::Period<'a>> for Period {
         }
     }
 }
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
+pub struct Sample {
+    /// The leaf is at locations[0].
+    pub locations: Vec<Location>,
+
+    /// 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: Vec<i64>,
+
+    /// label includes additional context for this sample. It can include
+    /// things like a thread id, allocation size, etc
+    pub labels: Vec<Label>,
+}
+
+impl<'a> From<&'a Sample> for api::Sample<'a> {
+    fn from(value: &'a Sample) -> Self {
+        Self {
+            locations: value.locations.iter().map(api::Location::from).collect(),
+            values: value.values.clone(),
+            labels: value.labels.iter().map(api::Label::from).collect(),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
+pub struct ValueType {
+    pub typ: Box<str>,
+    pub unit: Box<str>,
+}
+
+impl<'a> From<&'a api::ValueType<'a>> for ValueType {
+    #[inline]
+    fn from(value_type: &'a api::ValueType<'a>) -> Self {
+        Self {
+            typ: String::from(value_type.r#type).into(),
+            unit: String::from(value_type.unit).into(),
+        }
+    }
+}
+
+impl<'a> From<&'a ValueType> for api::ValueType<'a> {
+    fn from(value: &'a ValueType) -> Self {
+        Self::new(&value.typ, &value.unit)
+    }
+}
diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 0c8407cf2..65b6f1a23 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -550,7 +550,7 @@ mod api_tests {
         use bolero::TypeGenerator;
 
         bolero::check!()
-            .with_generator(Vec::<api::OwnedApi::ValueType>::gen())
+            .with_generator(Vec::<owned_types::ValueType>::gen())
             .for_each(|val| {
                 let sample_types: Vec<_> = val.iter().map(api::ValueType::from).collect();
                 Profile::new(SystemTime::now(), &sample_types, None);

From 82cbc79d033cafc52dbd8e73d3de37796f522acc Mon Sep 17 00:00:00 2001
From: Daniel Schwartz-Narbonne <daniel.schwartznarbonne@datadoghq.com>
Date: Thu, 23 May 2024 16:12:37 -0400
Subject: [PATCH 07/54] initial fuzz test, fails with duplicate labels on
 sample

---
 profiling/src/internal/profile.rs | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 65b6f1a23..9f0937f35 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -550,10 +550,16 @@ mod api_tests {
         use bolero::TypeGenerator;
 
         bolero::check!()
-            .with_generator(Vec::<owned_types::ValueType>::gen())
-            .for_each(|val| {
+            .with_generator((Vec::<owned_types::ValueType>::gen(), owned_types::Sample::gen()))
+            .for_each(|(val, sample)| {
                 let sample_types: Vec<_> = val.iter().map(api::ValueType::from).collect();
-                Profile::new(SystemTime::now(), &sample_types, None);
+                let mut profile = Profile::new(SystemTime::now(), &sample_types, None);
+                let r = profile.add_sample(sample.into(), None);
+                if val.len() == sample.values.len() {
+                    r.unwrap();
+                } else {
+                    r.unwrap_err();
+                }
             })
     }
 

From 1ccf691786347d20c04dba5d9cbcb89fd3395bc3 Mon Sep 17 00:00:00 2001
From: Daniel Schwartz-Narbonne <daniel.schwartznarbonne@datadoghq.com>
Date: Thu, 23 May 2024 16:36:37 -0400
Subject: [PATCH 08/54] add timestamp to fuzz test

---
 profiling/src/internal/owned_types.rs | 12 ++++++++++++
 profiling/src/internal/profile.rs     | 24 +++++++++++++++++-------
 2 files changed, 29 insertions(+), 7 deletions(-)

diff --git a/profiling/src/internal/owned_types.rs b/profiling/src/internal/owned_types.rs
index 719a83245..04ace3d98 100644
--- a/profiling/src/internal/owned_types.rs
+++ b/profiling/src/internal/owned_types.rs
@@ -187,6 +187,18 @@ impl<'a> From<&'a Sample> for api::Sample<'a> {
     }
 }
 
+#[cfg(test)]
+impl Sample {
+    /// Checks if the sample is well formed.  Useful in testing.
+    pub fn is_well_formed(&self) -> bool {
+        let labels_are_unique = {
+            let mut uniq = std::collections::HashSet::new();
+            self.labels.iter().map(|l| &l.key).all(|x| uniq.insert(x))
+        };
+        labels_are_unique
+    }
+}
+
 #[derive(Clone, Debug)]
 #[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
 pub struct ValueType {
diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 9f0937f35..ba477f23d 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -545,20 +545,30 @@ impl Profile {
 mod api_tests {
     use super::*;
 
+    /// Fuzzes adding a bunch of samples to the profile.
+    /// TODO: many of the samples will be of the wrong length, and will give a boring error right 
+    /// away.  Improve the generator to test the case where samples are the right length to get 
+    /// more coverage faster
+    /// TODO: Test the expected result of adding the samples
     #[test]
     fn fuzz() {
         use bolero::TypeGenerator;
 
         bolero::check!()
-            .with_generator((Vec::<owned_types::ValueType>::gen(), owned_types::Sample::gen()))
-            .for_each(|(val, sample)| {
+            .with_generator((
+                Vec::<owned_types::ValueType>::gen(),
+                Vec::<(Option<Timestamp>, owned_types::Sample)>::gen(),
+            ))
+            .for_each(|(val, samples)| {
                 let sample_types: Vec<_> = val.iter().map(api::ValueType::from).collect();
                 let mut profile = Profile::new(SystemTime::now(), &sample_types, None);
-                let r = profile.add_sample(sample.into(), None);
-                if val.len() == sample.values.len() {
-                    r.unwrap();
-                } else {
-                    r.unwrap_err();
+                for (timestamp, sample) in samples {
+                    let r = profile.add_sample(sample.into(), timestamp.clone());
+                    if val.len() == sample.values.len() && sample.is_well_formed() {
+                        r.unwrap();
+                    } else {
+                        r.unwrap_err();
+                    }
                 }
             })
     }

From afdb3b67eb7d2978cf6bb69d9064a7012f15097f Mon Sep 17 00:00:00 2001
From: Daniel Schwartz-Narbonne <daniel.schwartznarbonne@datadoghq.com>
Date: Thu, 23 May 2024 16:40:52 -0400
Subject: [PATCH 09/54] serialize the pprof at the end

---
 profiling/src/internal/profile.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index ba477f23d..995b823ad 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -570,6 +570,9 @@ mod api_tests {
                         r.unwrap_err();
                     }
                 }
+                // TODO, set actual values here
+                // TODO, evaluate the result
+                profile.serialize_into_compressed_pprof(None, None).unwrap();
             })
     }
 

From f41836c2d118934b40c67b90e486194c5bc6d6f0 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Fri, 24 May 2024 09:43:06 -0400
Subject: [PATCH 10/54] remove arbitrary from deps

---
 Cargo.lock           | 22 ----------------------
 profiling/Cargo.toml |  5 ++---
 2 files changed, 2 insertions(+), 25 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 439009e41..cc280d547 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -130,15 +130,6 @@ version = "1.0.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f538837af36e6f6a9be0faa67f9a314f8119e4e4b5867c6ab40ed60360142519"
 
-[[package]]
-name = "arbitrary"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
-dependencies = [
- "derive_arbitrary",
-]
-
 [[package]]
 name = "arrayref"
 version = "0.3.7"
@@ -622,7 +613,6 @@ version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac749fb4f2e14734e835a9352c0d1eb2ab62a025d4c56a823fa3f391e015741a"
 dependencies = [
- "arbitrary",
  "bolero-generator-derive",
  "either",
  "rand_core",
@@ -1200,7 +1190,6 @@ name = "datadog-profiling"
 version = "10.0.0"
 dependencies = [
  "anyhow",
- "arbitrary",
  "bitmaps",
  "bolero",
  "bolero-generator",
@@ -1546,17 +1535,6 @@ dependencies = [
  "syn 1.0.109",
 ]
 
-[[package]]
-name = "derive_arbitrary"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.58",
-]
-
 [[package]]
 name = "diff"
 version = "0.1.13"
diff --git a/profiling/Cargo.toml b/profiling/Cargo.toml
index a06234594..e877b778c 100644
--- a/profiling/Cargo.toml
+++ b/profiling/Cargo.toml
@@ -46,7 +46,6 @@ tokio-util = "0.7.1"
 byteorder = { version = "1.5", features = ["std"] }
 
 [dev-dependencies]
-arbitrary = { version = "1.3.2", features = ["derive", "derive_arbitrary"] }
-bolero = { version = "0.10.1", features = ["arbitrary"] }
-bolero-generator = { version = "0.10.2", features = ["arbitrary"] }
+bolero = "0.10.1"
+bolero-generator = "0.10.2"
 criterion = "0.5.1"

From 09f6c272c8bc0fdf1f4941d188b89d3861114bc1 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Fri, 24 May 2024 13:07:19 -0400
Subject: [PATCH 11/54] fuzz with right length samples

---
 Cargo.lock                        | 10 ++++
 profiling/Cargo.toml              |  1 +
 profiling/src/internal/profile.rs | 82 ++++++++++++++++++++++++++++---
 3 files changed, 87 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cc280d547..116fbfb7e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1209,6 +1209,7 @@ dependencies = [
  "hyper",
  "hyper-multipart-rfc7578",
  "indexmap 2.2.6",
+ "itertools 0.13.0",
  "libc",
  "lz4_flex",
  "mime",
@@ -2309,6 +2310,15 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.11"
diff --git a/profiling/Cargo.toml b/profiling/Cargo.toml
index e877b778c..88816fc4f 100644
--- a/profiling/Cargo.toml
+++ b/profiling/Cargo.toml
@@ -49,3 +49,4 @@ byteorder = { version = "1.5", features = ["std"] }
 bolero = "0.10.1"
 bolero-generator = "0.10.2"
 criterion = "0.5.1"
+itertools = "0.13.0"
diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 995b823ad..8ddf40611 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -544,16 +544,16 @@ impl Profile {
 #[cfg(test)]
 mod api_tests {
     use super::*;
+    use bolero::TypeGenerator;
+    use itertools::Itertools;
 
     /// Fuzzes adding a bunch of samples to the profile.
-    /// TODO: many of the samples will be of the wrong length, and will give a boring error right 
-    /// away.  Improve the generator to test the case where samples are the right length to get 
+    /// TODO: many of the samples will be of the wrong length, and will give a boring error right
+    /// away.  Improve the generator to test the case where samples are the right length to get
     /// more coverage faster
     /// TODO: Test the expected result of adding the samples
     #[test]
     fn fuzz() {
-        use bolero::TypeGenerator;
-
         bolero::check!()
             .with_generator((
                 Vec::<owned_types::ValueType>::gen(),
@@ -565,9 +565,9 @@ mod api_tests {
                 for (timestamp, sample) in samples {
                     let r = profile.add_sample(sample.into(), timestamp.clone());
                     if val.len() == sample.values.len() && sample.is_well_formed() {
-                        r.unwrap();
+                        assert!(r.is_ok());
                     } else {
-                        r.unwrap_err();
+                        assert!(r.is_err());
                     }
                 }
                 // TODO, set actual values here
@@ -576,6 +576,76 @@ mod api_tests {
             })
     }
 
+    #[test]
+    fn fuzz_with_fixed_sample_length() {
+        let sample_length_gen = 1..=64usize;
+
+        bolero::check!()
+            .with_generator((sample_length_gen, i64::gen(), u64::gen()))
+            .and_then(|(sample_len, start_time_ns, duration_ns)| {
+                let sample_types = Vec::<owned_types::ValueType>::gen().with().len(sample_len);
+
+                let timestamps = Option::<Timestamp>::gen();
+                let locations = Vec::<owned_types::Location>::gen();
+                let values = Vec::<i64>::gen().with().len(sample_len);
+                let labels = Vec::<owned_types::Label>::gen();
+
+                let samples = Vec::<(
+                    Option<Timestamp>,
+                    Vec<owned_types::Location>,
+                    Vec<i64>,
+                    Vec<owned_types::Label>,
+                )>::gen()
+                .with()
+                .values((timestamps, locations, values, labels));
+                (sample_types, samples, start_time_ns, duration_ns)
+            })
+            .for_each(|(sample_types, samples, start_time_ns, duration_ns)| {
+                let start_time =
+                    SystemTime::from(chrono::DateTime::from_timestamp_nanos(*start_time_ns));
+                let duration = Duration::from_nanos(*duration_ns);
+                let end_time = start_time + duration;
+                let sample_types: Vec<_> = sample_types.iter().map(api::ValueType::from).collect();
+                let mut profile = Profile::new(start_time, &sample_types, None);
+                let mut num_timestamped = 0;
+
+                for (timestamp, locations, values, labels) in samples {
+                    // Deduplicate labels using their key, as expected by validate_sample_labels
+                    let deduped_labels: Vec<owned_types::Label> = labels
+                        .clone()
+                        .into_iter()
+                        .unique_by(|l| l.key.clone())
+                        .collect();
+
+                    let sample = owned_types::Sample {
+                        locations: locations.clone(),
+                        values: values.clone(),
+                        labels: deduped_labels,
+                    };
+                    let r = profile.add_sample((&sample).into(), timestamp.clone());
+                    if r.is_err() {
+                        panic!("Failed to add sample: {:?}", r);
+                    }
+                    assert!(r.is_ok());
+                    if timestamp.is_some() {
+                        num_timestamped += 1;
+                    }
+                }
+                assert_eq!(
+                    profile.only_for_testing_num_timestamped_samples(),
+                    num_timestamped
+                );
+
+                let encoded = profile
+                    .serialize_into_compressed_pprof(Some(end_time), Some(duration))
+                    .unwrap();
+                let serialized_profile =
+                    pprof::deserialize_compressed_pprof(&encoded.buffer).unwrap();
+
+                assert_eq!(sample_types.len(), serialized_profile.sample_types.len());
+            });
+    }
+
     #[test]
     fn interning() {
         let sample_types = [api::ValueType::new("samples", "count")];

From 1fa27bad0f1f53ee1baf8857983e2fd494ae2964 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Fri, 24 May 2024 13:27:04 -0400
Subject: [PATCH 12/54] impl custom PartialEq and Hash so that the fuzzer can
 generate unique Labels instead of deduping

---
 Cargo.lock                            | 10 ----------
 profiling/Cargo.toml                  |  1 -
 profiling/src/internal/owned_types.rs | 16 +++++++++++++++-
 profiling/src/internal/profile.rs     | 16 +++++-----------
 4 files changed, 20 insertions(+), 23 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 116fbfb7e..cc280d547 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1209,7 +1209,6 @@ dependencies = [
  "hyper",
  "hyper-multipart-rfc7578",
  "indexmap 2.2.6",
- "itertools 0.13.0",
  "libc",
  "lz4_flex",
  "mime",
@@ -2310,15 +2309,6 @@ dependencies = [
  "either",
 ]
 
-[[package]]
-name = "itertools"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itoa"
 version = "1.0.11"
diff --git a/profiling/Cargo.toml b/profiling/Cargo.toml
index 88816fc4f..e877b778c 100644
--- a/profiling/Cargo.toml
+++ b/profiling/Cargo.toml
@@ -49,4 +49,3 @@ byteorder = { version = "1.5", features = ["std"] }
 bolero = "0.10.1"
 bolero-generator = "0.10.2"
 criterion = "0.5.1"
-itertools = "0.13.0"
diff --git a/profiling/src/internal/owned_types.rs b/profiling/src/internal/owned_types.rs
index 04ace3d98..3f169bc2a 100644
--- a/profiling/src/internal/owned_types.rs
+++ b/profiling/src/internal/owned_types.rs
@@ -31,7 +31,7 @@ impl<'a> From<&'a Function> for api::Function<'a> {
     }
 }
 
-#[derive(Clone, Debug, Default, Eq, PartialEq)]
+#[derive(Clone, Debug, Default)]
 #[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
 pub struct Label {
     pub key: Box<str>,
@@ -50,6 +50,20 @@ pub struct Label {
     pub num_unit: Option<Box<str>>,
 }
 
+impl PartialEq for Label {
+    fn eq(&self, other: &Self) -> bool {
+        self.key == other.key
+    }
+}
+
+impl Eq for Label {}
+
+impl std::hash::Hash for Label {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.key.hash(state)
+    }
+}
+
 impl<'a> From<&'a Label> for api::Label<'a> {
     fn from(value: &'a Label) -> Self {
         Self {
diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 8ddf40611..faa3595b8 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -545,7 +545,7 @@ impl Profile {
 mod api_tests {
     use super::*;
     use bolero::TypeGenerator;
-    use itertools::Itertools;
+    use std::collections::HashSet;
 
     /// Fuzzes adding a bunch of samples to the profile.
     /// TODO: many of the samples will be of the wrong length, and will give a boring error right
@@ -588,13 +588,14 @@ mod api_tests {
                 let timestamps = Option::<Timestamp>::gen();
                 let locations = Vec::<owned_types::Location>::gen();
                 let values = Vec::<i64>::gen().with().len(sample_len);
-                let labels = Vec::<owned_types::Label>::gen();
+                // Generate labels with unique keys
+                let labels = HashSet::<owned_types::Label>::gen();
 
                 let samples = Vec::<(
                     Option<Timestamp>,
                     Vec<owned_types::Location>,
                     Vec<i64>,
-                    Vec<owned_types::Label>,
+                    HashSet<owned_types::Label>,
                 )>::gen()
                 .with()
                 .values((timestamps, locations, values, labels));
@@ -610,17 +611,10 @@ mod api_tests {
                 let mut num_timestamped = 0;
 
                 for (timestamp, locations, values, labels) in samples {
-                    // Deduplicate labels using their key, as expected by validate_sample_labels
-                    let deduped_labels: Vec<owned_types::Label> = labels
-                        .clone()
-                        .into_iter()
-                        .unique_by(|l| l.key.clone())
-                        .collect();
-
                     let sample = owned_types::Sample {
                         locations: locations.clone(),
                         values: values.clone(),
-                        labels: deduped_labels,
+                        labels: labels.clone().into_iter().collect(),
                     };
                     let r = profile.add_sample((&sample).into(), timestamp.clone());
                     if r.is_err() {

From 60bdbfbe30920e06732a73dc60a78897b1ecb0ad Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Fri, 24 May 2024 14:07:31 -0400
Subject: [PATCH 13/54] comments

---
 profiling/src/internal/profile.rs | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index faa3595b8..39170990f 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -637,6 +637,22 @@ mod api_tests {
                     pprof::deserialize_compressed_pprof(&encoded.buffer).unwrap();
 
                 assert_eq!(sample_types.len(), serialized_profile.sample_types.len());
+                // The next line passes but I thought that aggregated samples would
+                // decrease the samples count and thus the next line would fail.
+                assert_eq!(samples.len(), serialized_profile.samples.len());
+
+                // TODO: test data in serialized_profile?
+                // for (sample, serialized_sample) in samples.iter().zip(serialized_profile.samples.iter()) {
+                //     // assert_eq!(sample.1, serialized_sample.location_ids);
+                //     // assert_eq!(sample.2, serialized_sample.values);
+                //     // assert_eq!(sample.3.len(), serialized_sample.labels.len());
+                //     // for (label, serialized_label) in sample.3.iter().zip(serialized_sample.labels.iter()) {
+                //     //     assert_eq!(label.key, serialized_label.key);
+                //     //     assert_eq!(label.num, serialized_label.num);
+                //     //     assert_eq!(label.str, serialized_label.str);
+                //     //     assert_eq!(label.num_unit, serialized_label.num_unit);
+                //     // }
+                // }
             });
     }
 

From 61d54ad25746842b7c6418605322829a99143c5c Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Fri, 24 May 2024 14:18:46 -0400
Subject: [PATCH 14/54] rename

---
 profiling/src/internal/profile.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 39170990f..3c57684bd 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -553,7 +553,7 @@ mod api_tests {
     /// more coverage faster
     /// TODO: Test the expected result of adding the samples
     #[test]
-    fn fuzz() {
+    fn fuzz_add_sample() {
         bolero::check!()
             .with_generator((
                 Vec::<owned_types::ValueType>::gen(),
@@ -577,7 +577,7 @@ mod api_tests {
     }
 
     #[test]
-    fn fuzz_with_fixed_sample_length() {
+    fn fuzz_add_sample_with_fixed_sample_length() {
         let sample_length_gen = 1..=64usize;
 
         bolero::check!()

From bb3e6daee86fa6cd80286ad0785d5a988b649059 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Fri, 24 May 2024 14:33:28 -0400
Subject: [PATCH 15/54] fuzz add_endpoint

---
 profiling/src/internal/profile.rs | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 3c57684bd..ad1483aaf 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -656,6 +656,23 @@ mod api_tests {
             });
     }
 
+    #[test]
+    fn fuzz_add_endpoint() {
+        bolero::check!()
+            .with_type::<Vec<(u64, String)>>()
+            .for_each(|endpoints| {
+                let mut profile = Profile::new(SystemTime::now(), &[], None);
+
+                for (local_root_span_id, endpoint) in endpoints {
+                    let r = profile.add_endpoint(*local_root_span_id, endpoint.into());
+                    assert!(r.is_ok());
+                }
+
+                let encoded = profile.serialize_into_compressed_pprof(None, None).unwrap();
+                pprof::deserialize_compressed_pprof(&encoded.buffer).unwrap();
+            });
+    }
+
     #[test]
     fn interning() {
         let sample_types = [api::ValueType::new("samples", "count")];

From 1c8a1735db91ff0f5636937c9c0a7c29d6ad8813 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Fri, 24 May 2024 14:47:20 -0400
Subject: [PATCH 16/54] use saturating add

---
 profiling/src/internal/endpoint_stats.rs |  3 ++-
 profiling/src/internal/profile.rs        | 15 ++++++++++++++-
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/profiling/src/internal/endpoint_stats.rs b/profiling/src/internal/endpoint_stats.rs
index 60420e26d..9277aec68 100644
--- a/profiling/src/internal/endpoint_stats.rs
+++ b/profiling/src/internal/endpoint_stats.rs
@@ -19,7 +19,8 @@ impl From<HashMap<String, i64>> for ProfiledEndpointsStats {
 
 impl ProfiledEndpointsStats {
     pub fn add_endpoint_count(&mut self, endpoint_name: String, value: i64) {
-        *self.count.entry(endpoint_name).or_insert(0) += value;
+        let entry = self.count.entry(endpoint_name).or_insert(0);
+        *entry = entry.saturating_add(value);
     }
 
     pub fn is_empty(&self) -> bool {
diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index ad1483aaf..ff129128e 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -662,12 +662,25 @@ mod api_tests {
             .with_type::<Vec<(u64, String)>>()
             .for_each(|endpoints| {
                 let mut profile = Profile::new(SystemTime::now(), &[], None);
-
                 for (local_root_span_id, endpoint) in endpoints {
                     let r = profile.add_endpoint(*local_root_span_id, endpoint.into());
                     assert!(r.is_ok());
                 }
+                let encoded = profile.serialize_into_compressed_pprof(None, None).unwrap();
+                pprof::deserialize_compressed_pprof(&encoded.buffer).unwrap();
+            });
+    }
 
+    #[test]
+    fn fuzz_add_endpoint_count() {
+        bolero::check!()
+            .with_type::<Vec<(String, i64)>>()
+            .for_each(|endpoint_counts| {
+                let mut profile = Profile::new(SystemTime::now(), &[], None);
+                for (endpoint, count) in endpoint_counts {
+                    let r = profile.add_endpoint_count(endpoint.into(), *count);
+                    assert!(r.is_ok());
+                }
                 let encoded = profile.serialize_into_compressed_pprof(None, None).unwrap();
                 pprof::deserialize_compressed_pprof(&encoded.buffer).unwrap();
             });

From bc2cba916bed59f14fe25d91a3553b1080a76fcb Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Fri, 24 May 2024 15:06:23 -0400
Subject: [PATCH 17/54] derive TypeGenerator for UpscalingInfo

---
 profiling/src/api.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/profiling/src/api.rs b/profiling/src/api.rs
index 477fd75ec..98a926b7c 100644
--- a/profiling/src/api.rs
+++ b/profiling/src/api.rs
@@ -128,6 +128,7 @@ pub struct Sample<'a> {
 }
 
 #[derive(Debug)]
+#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
 pub enum UpscalingInfo {
     Poisson {
         // sum_value_offset and count_value_offset are offsets in the profile values type array

From a5aa7d7ca12a3e08e2db26c0b5da8bbfe6b27c5d Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Tue, 28 May 2024 14:14:12 -0400
Subject: [PATCH 18/54] use roundtrip to test

---
 profiling/src/internal/profile.rs | 34 +++++++++++++++----------------
 1 file changed, 16 insertions(+), 18 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index ff129128e..5ad18a6bb 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -561,18 +561,29 @@ mod api_tests {
             ))
             .for_each(|(val, samples)| {
                 let sample_types: Vec<_> = val.iter().map(api::ValueType::from).collect();
-                let mut profile = Profile::new(SystemTime::now(), &sample_types, None);
+                let mut expected_profile = Profile::new(SystemTime::now(), &sample_types, None);
+                let mut added_samples: Vec<&owned_types::Sample> = Vec::new();
                 for (timestamp, sample) in samples {
-                    let r = profile.add_sample(sample.into(), timestamp.clone());
+                    let r = expected_profile.add_sample(sample.into(), timestamp.clone());
                     if val.len() == sample.values.len() && sample.is_well_formed() {
                         assert!(r.is_ok());
+                        added_samples.push(sample);
                     } else {
                         assert!(r.is_err());
                     }
                 }
-                // TODO, set actual values here
-                // TODO, evaluate the result
-                profile.serialize_into_compressed_pprof(None, None).unwrap();
+
+                let profile = pprof::roundtrip_to_pprof(expected_profile).unwrap();
+
+                for (typ, expecte_typ) in profile.sample_types.iter().zip(sample_types.iter()) {
+                    assert_eq!(
+                        profile.string_table[typ.r#type as usize],
+                        expecte_typ.r#type
+                    );
+                    assert_eq!(profile.string_table[typ.unit as usize], expecte_typ.unit);
+                }
+
+                assert_eq!(added_samples.len(), profile.samples.len());
             })
     }
 
@@ -640,19 +651,6 @@ mod api_tests {
                 // The next line passes but I thought that aggregated samples would
                 // decrease the samples count and thus the next line would fail.
                 assert_eq!(samples.len(), serialized_profile.samples.len());
-
-                // TODO: test data in serialized_profile?
-                // for (sample, serialized_sample) in samples.iter().zip(serialized_profile.samples.iter()) {
-                //     // assert_eq!(sample.1, serialized_sample.location_ids);
-                //     // assert_eq!(sample.2, serialized_sample.values);
-                //     // assert_eq!(sample.3.len(), serialized_sample.labels.len());
-                //     // for (label, serialized_label) in sample.3.iter().zip(serialized_sample.labels.iter()) {
-                //     //     assert_eq!(label.key, serialized_label.key);
-                //     //     assert_eq!(label.num, serialized_label.num);
-                //     //     assert_eq!(label.str, serialized_label.str);
-                //     //     assert_eq!(label.num_unit, serialized_label.num_unit);
-                //     // }
-                // }
             });
     }
 

From 313781ce4a42030787ddfaf0fd0bc725f6c05821 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Tue, 28 May 2024 15:04:55 -0400
Subject: [PATCH 19/54] follow ids to assert the values

---
 Cargo.lock                        | 10 ++++++++
 profiling/Cargo.toml              |  1 +
 profiling/src/internal/profile.rs | 42 ++++++++++++++++++++++++++-----
 3 files changed, 47 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cc280d547..116fbfb7e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1209,6 +1209,7 @@ dependencies = [
  "hyper",
  "hyper-multipart-rfc7578",
  "indexmap 2.2.6",
+ "itertools 0.13.0",
  "libc",
  "lz4_flex",
  "mime",
@@ -2309,6 +2310,15 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.11"
diff --git a/profiling/Cargo.toml b/profiling/Cargo.toml
index e877b778c..88816fc4f 100644
--- a/profiling/Cargo.toml
+++ b/profiling/Cargo.toml
@@ -49,3 +49,4 @@ byteorder = { version = "1.5", features = ["std"] }
 bolero = "0.10.1"
 bolero-generator = "0.10.2"
 criterion = "0.5.1"
+itertools = "0.13.0"
diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 5ad18a6bb..6a04d7707 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -545,6 +545,7 @@ impl Profile {
 mod api_tests {
     use super::*;
     use bolero::TypeGenerator;
+    use itertools::Itertools;
     use std::collections::HashSet;
 
     /// Fuzzes adding a bunch of samples to the profile.
@@ -562,12 +563,12 @@ mod api_tests {
             .for_each(|(val, samples)| {
                 let sample_types: Vec<_> = val.iter().map(api::ValueType::from).collect();
                 let mut expected_profile = Profile::new(SystemTime::now(), &sample_types, None);
-                let mut added_samples: Vec<&owned_types::Sample> = Vec::new();
+                let mut expected_samples: Vec<&owned_types::Sample> = Vec::new();
                 for (timestamp, sample) in samples {
                     let r = expected_profile.add_sample(sample.into(), timestamp.clone());
                     if val.len() == sample.values.len() && sample.is_well_formed() {
                         assert!(r.is_ok());
-                        added_samples.push(sample);
+                        expected_samples.push(sample);
                     } else {
                         assert!(r.is_err());
                     }
@@ -575,15 +576,44 @@ mod api_tests {
 
                 let profile = pprof::roundtrip_to_pprof(expected_profile).unwrap();
 
-                for (typ, expecte_typ) in profile.sample_types.iter().zip(sample_types.iter()) {
+                for (typ, expected_typ) in profile.sample_types.iter().zip_eq(sample_types.iter()) {
                     assert_eq!(
                         profile.string_table[typ.r#type as usize],
-                        expecte_typ.r#type
+                        expected_typ.r#type
                     );
-                    assert_eq!(profile.string_table[typ.unit as usize], expecte_typ.unit);
+                    assert_eq!(profile.string_table[typ.unit as usize], expected_typ.unit);
                 }
 
-                assert_eq!(added_samples.len(), profile.samples.len());
+                assert_eq!(profile.samples.len(), expected_samples.len());
+                for (sample, expected_sample) in
+                    profile.samples.iter().zip_eq(expected_samples.iter())
+                {
+                    assert_eq!(sample.location_ids.len(), expected_sample.locations.len());
+                    for (loc_id, expected_location) in sample
+                        .location_ids
+                        .iter()
+                        .zip_eq(expected_sample.locations.iter())
+                    {
+                        let location = &profile
+                            .locations
+                            .iter()
+                            .find(|l| l.id == *loc_id)
+                            .expect("Location not found");
+
+                        let mapping = &profile
+                            .mappings
+                            .iter()
+                            .find(|m| m.id == location.mapping_id)
+                            .expect("Mapping not found");
+
+                        assert_eq!(
+                            *profile.string_table[mapping.filename as usize],
+                            *expected_location.mapping.filename
+                        );
+                    }
+
+                    assert_eq!(sample.values, expected_sample.values);
+                }
             })
     }
 

From 232dd137601df326bfcfb30a2907e1996bd52c4d Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Tue, 28 May 2024 16:55:15 -0400
Subject: [PATCH 20/54] test mapping

---
 profiling/src/internal/profile.rs | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 6a04d7707..38982df1a 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -561,8 +561,9 @@ mod api_tests {
                 Vec::<(Option<Timestamp>, owned_types::Sample)>::gen(),
             ))
             .for_each(|(val, samples)| {
-                let sample_types: Vec<_> = val.iter().map(api::ValueType::from).collect();
-                let mut expected_profile = Profile::new(SystemTime::now(), &sample_types, None);
+                let expected_sample_types: Vec<_> = val.iter().map(api::ValueType::from).collect();
+                let mut expected_profile =
+                    Profile::new(SystemTime::now(), &expected_sample_types, None);
                 let mut expected_samples: Vec<&owned_types::Sample> = Vec::new();
                 for (timestamp, sample) in samples {
                     let r = expected_profile.add_sample(sample.into(), timestamp.clone());
@@ -576,7 +577,11 @@ mod api_tests {
 
                 let profile = pprof::roundtrip_to_pprof(expected_profile).unwrap();
 
-                for (typ, expected_typ) in profile.sample_types.iter().zip_eq(sample_types.iter()) {
+                for (typ, expected_typ) in profile
+                    .sample_types
+                    .iter()
+                    .zip_eq(expected_sample_types.iter())
+                {
                     assert_eq!(
                         profile.string_table[typ.r#type as usize],
                         expected_typ.r#type
@@ -605,11 +610,19 @@ mod api_tests {
                             .iter()
                             .find(|m| m.id == location.mapping_id)
                             .expect("Mapping not found");
-
                         assert_eq!(
                             *profile.string_table[mapping.filename as usize],
                             *expected_location.mapping.filename
                         );
+                        assert_eq!(
+                            *profile.string_table[mapping.build_id as usize],
+                            *expected_location.mapping.build_id
+                        );
+                        assert_eq!(mapping.memory_start, expected_location.mapping.memory_start);
+                        assert_eq!(mapping.memory_limit, expected_location.mapping.memory_limit);
+                        assert_eq!(mapping.file_offset, expected_location.mapping.file_offset);
+
+                        assert_eq!(location.address, expected_location.address);
                     }
 
                     assert_eq!(sample.values, expected_sample.values);

From a01599c136fdd30b49b1803b3629f80e4c4c4e3a Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Tue, 28 May 2024 20:30:25 -0400
Subject: [PATCH 21/54] pprof vs. owned_type test

---
 Cargo.lock                            |  10 --
 profiling/Cargo.toml                  |   1 -
 profiling/src/internal/owned_types.rs |  13 +-
 profiling/src/internal/profile.rs     | 194 +++++++++++++++++++++++---
 4 files changed, 183 insertions(+), 35 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 116fbfb7e..cc280d547 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1209,7 +1209,6 @@ dependencies = [
  "hyper",
  "hyper-multipart-rfc7578",
  "indexmap 2.2.6",
- "itertools 0.13.0",
  "libc",
  "lz4_flex",
  "mime",
@@ -2310,15 +2309,6 @@ dependencies = [
  "either",
 ]
 
-[[package]]
-name = "itertools"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itoa"
 version = "1.0.11"
diff --git a/profiling/Cargo.toml b/profiling/Cargo.toml
index 88816fc4f..e877b778c 100644
--- a/profiling/Cargo.toml
+++ b/profiling/Cargo.toml
@@ -49,4 +49,3 @@ byteorder = { version = "1.5", features = ["std"] }
 bolero = "0.10.1"
 bolero-generator = "0.10.2"
 criterion = "0.5.1"
-itertools = "0.13.0"
diff --git a/profiling/src/internal/owned_types.rs b/profiling/src/internal/owned_types.rs
index 3f169bc2a..5c69b5ba0 100644
--- a/profiling/src/internal/owned_types.rs
+++ b/profiling/src/internal/owned_types.rs
@@ -3,7 +3,7 @@
 
 use crate::api;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Hash)]
 #[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
 pub struct Function {
     /// Name of the function, in human-readable form if available.
@@ -94,7 +94,7 @@ impl<'a> From<&'a Line> for api::Line<'a> {
     }
 }
 
-#[derive(Clone, Debug, Default, Eq, PartialEq)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Hash)]
 #[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
 pub struct Location {
     pub mapping: Mapping,
@@ -120,7 +120,7 @@ impl<'a> From<&'a Location> for api::Location<'a> {
     }
 }
 
-#[derive(Clone, Debug, Default, Eq, PartialEq)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Hash)]
 #[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
 pub struct Mapping {
     /// Address at which the binary (or DLL) is loaded into memory.
@@ -191,6 +191,13 @@ pub struct Sample {
     pub labels: Vec<Label>,
 }
 
+impl std::hash::Hash for Sample {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.locations.hash(state);
+        self.labels.hash(state);
+    }
+}
+
 impl<'a> From<&'a Sample> for api::Sample<'a> {
     fn from(value: &'a Sample) -> Self {
         Self {
diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 38982df1a..18565f123 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -545,7 +545,6 @@ impl Profile {
 mod api_tests {
     use super::*;
     use bolero::TypeGenerator;
-    use itertools::Itertools;
     use std::collections::HashSet;
 
     /// Fuzzes adding a bunch of samples to the profile.
@@ -564,12 +563,28 @@ mod api_tests {
                 let expected_sample_types: Vec<_> = val.iter().map(api::ValueType::from).collect();
                 let mut expected_profile =
                     Profile::new(SystemTime::now(), &expected_sample_types, None);
-                let mut expected_samples: Vec<&owned_types::Sample> = Vec::new();
+                let mut samples_with_timestamps = Vec::new();
+                let mut samples_without_timestamps: HashSet<owned_types::Sample> = HashSet::new();
                 for (timestamp, sample) in samples {
                     let r = expected_profile.add_sample(sample.into(), timestamp.clone());
                     if val.len() == sample.values.len() && sample.is_well_formed() {
                         assert!(r.is_ok());
-                        expected_samples.push(sample);
+                        if timestamp.is_some() {
+                            samples_with_timestamps.push(sample);
+                        } else {
+                            if let Some(mut existing_sample) =
+                                samples_without_timestamps.take(&sample)
+                            {
+                                existing_sample
+                                    .values
+                                    .iter_mut()
+                                    .zip(sample.values.iter())
+                                    .for_each(|(a, b)| *a = a.saturating_add(*b));
+                                samples_without_timestamps.insert(existing_sample);
+                            } else {
+                                samples_without_timestamps.insert(sample.clone());
+                            }
+                        }
                     } else {
                         assert!(r.is_err());
                     }
@@ -577,10 +592,15 @@ mod api_tests {
 
                 let profile = pprof::roundtrip_to_pprof(expected_profile).unwrap();
 
+                assert_eq!(
+                    profile.sample_types.len(),
+                    expected_sample_types.len(),
+                    "Sample types length mismatch"
+                );
                 for (typ, expected_typ) in profile
                     .sample_types
                     .iter()
-                    .zip_eq(expected_sample_types.iter())
+                    .zip(expected_sample_types.iter())
                 {
                     assert_eq!(
                         profile.string_table[typ.r#type as usize],
@@ -589,27 +609,29 @@ mod api_tests {
                     assert_eq!(profile.string_table[typ.unit as usize], expected_typ.unit);
                 }
 
-                assert_eq!(profile.samples.len(), expected_samples.len());
-                for (sample, expected_sample) in
-                    profile.samples.iter().zip_eq(expected_samples.iter())
-                {
-                    assert_eq!(sample.location_ids.len(), expected_sample.locations.len());
+                assert_eq!(
+                    profile.samples.len(),
+                    samples_with_timestamps.len() + samples_without_timestamps.len(),
+                    "Samples length mismatch"
+                );
+
+                let mut iter = profile.samples.iter();
+
+                for expected_sample in samples_with_timestamps.iter() {
+                    let sample = iter.next().unwrap();
+                    assert_eq!(
+                        sample.location_ids.len(),
+                        expected_sample.locations.len(),
+                        "Locations length mismatch"
+                    );
                     for (loc_id, expected_location) in sample
                         .location_ids
                         .iter()
-                        .zip_eq(expected_sample.locations.iter())
+                        .zip(expected_sample.locations.iter())
                     {
-                        let location = &profile
-                            .locations
-                            .iter()
-                            .find(|l| l.id == *loc_id)
-                            .expect("Location not found");
-
-                        let mapping = &profile
-                            .mappings
-                            .iter()
-                            .find(|m| m.id == location.mapping_id)
-                            .expect("Mapping not found");
+                        let location = &profile.locations[*loc_id as usize - 1];
+
+                        let mapping = &profile.mappings[location.mapping_id as usize - 1];
                         assert_eq!(
                             *profile.string_table[mapping.filename as usize],
                             *expected_location.mapping.filename
@@ -623,7 +645,137 @@ mod api_tests {
                         assert_eq!(mapping.file_offset, expected_location.mapping.file_offset);
 
                         assert_eq!(location.address, expected_location.address);
+
+                        assert!(location.lines.len() == 1);
+
+                        let line = location.lines[0];
+                        assert_eq!(line.line, expected_location.line);
+                        let function = profile.functions[line.function_id as usize - 1];
+                        let expected_function = &expected_location.function;
+                        assert_eq!(
+                            *profile.string_table[function.name as usize],
+                            *expected_function.name
+                        );
+                        assert_eq!(
+                            *profile.string_table[function.system_name as usize],
+                            *expected_function.system_name
+                        );
+                        assert_eq!(
+                            *profile.string_table[function.filename as usize],
+                            *expected_function.filename
+                        );
+                        assert_eq!(function.start_line, expected_function.start_line);
+
+                        assert!(!location.is_folded);
+                    }
+
+                    assert_eq!(sample.values, expected_sample.values);
+
+                    for (label, expected_label) in
+                        sample.labels.iter().zip(expected_sample.labels.iter())
+                    {
+                        assert_eq!(
+                            *profile.string_table[label.key as usize],
+                            *expected_label.key
+                        );
+                        if let Some(str) = &expected_label.str {
+                            assert_eq!(*profile.string_table[label.str as usize], *str);
+                        } else {
+                            assert_eq!(label.num, expected_label.num);
+                            if let Some(num_unit) = &expected_label.num_unit {
+                                assert_eq!(
+                                    *profile.string_table[label.num_unit as usize],
+                                    **num_unit
+                                );
+                            }
+                        }
                     }
+                }
+
+                // Compare aggregated (non-timestamped) samples
+                for sample in iter {
+                    // Recreate owned_locations from the pprof::Location
+                    let mut owned_locations = Vec::new();
+
+                    for loc_id in sample.location_ids.iter() {
+                        let location = &profile.locations[*loc_id as usize - 1];
+                        let mapping = &profile.mappings[location.mapping_id as usize - 1];
+                        let line = location.lines[0];
+                        let function = profile.functions[line.function_id as usize - 1];
+
+                        let owned_location = owned_types::Location {
+                            mapping: owned_types::Mapping {
+                                memory_start: mapping.memory_start,
+                                memory_limit: mapping.memory_limit,
+                                file_offset: mapping.file_offset,
+                                filename: profile.string_table[mapping.filename as usize]
+                                    .clone()
+                                    .into_boxed_str(),
+                                build_id: profile.string_table[mapping.build_id as usize]
+                                    .clone()
+                                    .into_boxed_str(),
+                            },
+                            function: owned_types::Function {
+                                name: profile.string_table[function.name as usize]
+                                    .clone()
+                                    .into_boxed_str(),
+                                system_name: profile.string_table[function.system_name as usize]
+                                    .clone()
+                                    .into_boxed_str(),
+                                filename: profile.string_table[function.filename as usize]
+                                    .clone()
+                                    .into_boxed_str(),
+                                start_line: function.start_line,
+                            },
+                            address: location.address,
+                            line: line.line,
+                        };
+
+                        owned_locations.push(owned_location);
+                    }
+
+                    let mut owned_labels = Vec::new();
+                    for label in sample.labels.iter() {
+                        let key = profile.string_table[label.key as usize]
+                            .clone()
+                            .into_boxed_str();
+                        if label.str != 0 {
+                            let str = profile.string_table[label.str as usize].clone();
+                            owned_labels.push(owned_types::Label {
+                                key,
+                                str: Some(str),
+                                num: 0,
+                                num_unit: None,
+                            });
+                        } else {
+                            let num = label.num;
+                            let num_unit = if label.num_unit != 0 {
+                                Some(
+                                    profile.string_table[label.num_unit as usize]
+                                        .clone()
+                                        .into_boxed_str(),
+                                )
+                            } else {
+                                None
+                            };
+                            owned_labels.push(owned_types::Label {
+                                key,
+                                str: None,
+                                num: num,
+                                num_unit,
+                            });
+                        }
+                    }
+
+                    let key = owned_types::Sample {
+                        locations: owned_locations,
+                        values: Vec::new(),
+                        labels: owned_labels,
+                    };
+
+                    let expected_sample = samples_without_timestamps
+                        .get(&key)
+                        .expect("Sample not found");
 
                     assert_eq!(sample.values, expected_sample.values);
                 }

From 7a80bac1b4cdab34c24454ccfce5843dd9c229f5 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Tue, 28 May 2024 21:38:47 -0400
Subject: [PATCH 22/54] use same code for timestamped and non-timestamped
 samples

---
 profiling/src/internal/profile.rs | 135 ++++++++----------------------
 1 file changed, 35 insertions(+), 100 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 18565f123..c27be8af1 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -545,7 +545,7 @@ impl Profile {
 mod api_tests {
     use super::*;
     use bolero::TypeGenerator;
-    use std::collections::HashSet;
+    use std::collections::{HashMap, HashSet};
 
     /// Fuzzes adding a bunch of samples to the profile.
     /// TODO: many of the samples will be of the wrong length, and will give a boring error right
@@ -564,7 +564,10 @@ mod api_tests {
                 let mut expected_profile =
                     Profile::new(SystemTime::now(), &expected_sample_types, None);
                 let mut samples_with_timestamps = Vec::new();
-                let mut samples_without_timestamps: HashSet<owned_types::Sample> = HashSet::new();
+                let mut samples_without_timestamps: HashMap<
+                    (&Vec<owned_types::Location>, &Vec<owned_types::Label>),
+                    Vec<i64>,
+                > = HashMap::new();
                 for (timestamp, sample) in samples {
                     let r = expected_profile.add_sample(sample.into(), timestamp.clone());
                     if val.len() == sample.values.len() && sample.is_well_formed() {
@@ -572,17 +575,18 @@ mod api_tests {
                         if timestamp.is_some() {
                             samples_with_timestamps.push(sample);
                         } else {
-                            if let Some(mut existing_sample) =
-                                samples_without_timestamps.take(&sample)
+                            if let Some(existing_values) = samples_without_timestamps
+                                .get_mut(&(&sample.locations, &sample.labels))
                             {
-                                existing_sample
-                                    .values
+                                existing_values
                                     .iter_mut()
                                     .zip(sample.values.iter())
                                     .for_each(|(a, b)| *a = a.saturating_add(*b));
-                                samples_without_timestamps.insert(existing_sample);
                             } else {
-                                samples_without_timestamps.insert(sample.clone());
+                                samples_without_timestamps.insert(
+                                    (&sample.locations, &sample.labels),
+                                    sample.values.clone(),
+                                );
                             }
                         }
                     } else {
@@ -615,93 +619,18 @@ mod api_tests {
                     "Samples length mismatch"
                 );
 
-                let mut iter = profile.samples.iter();
-
-                for expected_sample in samples_with_timestamps.iter() {
-                    let sample = iter.next().unwrap();
-                    assert_eq!(
-                        sample.location_ids.len(),
-                        expected_sample.locations.len(),
-                        "Locations length mismatch"
-                    );
-                    for (loc_id, expected_location) in sample
-                        .location_ids
-                        .iter()
-                        .zip(expected_sample.locations.iter())
-                    {
-                        let location = &profile.locations[*loc_id as usize - 1];
-
-                        let mapping = &profile.mappings[location.mapping_id as usize - 1];
-                        assert_eq!(
-                            *profile.string_table[mapping.filename as usize],
-                            *expected_location.mapping.filename
-                        );
-                        assert_eq!(
-                            *profile.string_table[mapping.build_id as usize],
-                            *expected_location.mapping.build_id
-                        );
-                        assert_eq!(mapping.memory_start, expected_location.mapping.memory_start);
-                        assert_eq!(mapping.memory_limit, expected_location.mapping.memory_limit);
-                        assert_eq!(mapping.file_offset, expected_location.mapping.file_offset);
-
-                        assert_eq!(location.address, expected_location.address);
-
-                        assert!(location.lines.len() == 1);
-
-                        let line = location.lines[0];
-                        assert_eq!(line.line, expected_location.line);
-                        let function = profile.functions[line.function_id as usize - 1];
-                        let expected_function = &expected_location.function;
-                        assert_eq!(
-                            *profile.string_table[function.name as usize],
-                            *expected_function.name
-                        );
-                        assert_eq!(
-                            *profile.string_table[function.system_name as usize],
-                            *expected_function.system_name
-                        );
-                        assert_eq!(
-                            *profile.string_table[function.filename as usize],
-                            *expected_function.filename
-                        );
-                        assert_eq!(function.start_line, expected_function.start_line);
-
-                        assert!(!location.is_folded);
-                    }
-
-                    assert_eq!(sample.values, expected_sample.values);
-
-                    for (label, expected_label) in
-                        sample.labels.iter().zip(expected_sample.labels.iter())
-                    {
-                        assert_eq!(
-                            *profile.string_table[label.key as usize],
-                            *expected_label.key
-                        );
-                        if let Some(str) = &expected_label.str {
-                            assert_eq!(*profile.string_table[label.str as usize], *str);
-                        } else {
-                            assert_eq!(label.num, expected_label.num);
-                            if let Some(num_unit) = &expected_label.num_unit {
-                                assert_eq!(
-                                    *profile.string_table[label.num_unit as usize],
-                                    **num_unit
-                                );
-                            }
-                        }
-                    }
-                }
+                let mut expected_timestamped_samples = samples_with_timestamps.iter();
 
-                // Compare aggregated (non-timestamped) samples
-                for sample in iter {
-                    // Recreate owned_locations from the pprof::Location
+                for sample in profile.samples.iter() {
+                    // Recreate owned_locations from vector of pprof::Location
                     let mut owned_locations = Vec::new();
-
                     for loc_id in sample.location_ids.iter() {
                         let location = &profile.locations[*loc_id as usize - 1];
                         let mapping = &profile.mappings[location.mapping_id as usize - 1];
+                        assert!(location.lines.len() == 1);
                         let line = location.lines[0];
                         let function = profile.functions[line.function_id as usize - 1];
+                        assert!(!location.is_folded);
 
                         let owned_location = owned_types::Location {
                             mapping: owned_types::Mapping {
@@ -734,11 +663,17 @@ mod api_tests {
                         owned_locations.push(owned_location);
                     }
 
+                    // Recreate owned_labels from vector of pprof::Label
                     let mut owned_labels = Vec::new();
                     for label in sample.labels.iter() {
                         let key = profile.string_table[label.key as usize]
                             .clone()
                             .into_boxed_str();
+
+                        if *key == *"end_timestamp_ns" {
+                            continue;
+                        }
+
                         if label.str != 0 {
                             let str = profile.string_table[label.str as usize].clone();
                             owned_labels.push(owned_types::Label {
@@ -761,23 +696,23 @@ mod api_tests {
                             owned_labels.push(owned_types::Label {
                                 key,
                                 str: None,
-                                num: num,
+                                num,
                                 num_unit,
                             });
                         }
                     }
 
-                    let key = owned_types::Sample {
-                        locations: owned_locations,
-                        values: Vec::new(),
-                        labels: owned_labels,
-                    };
-
-                    let expected_sample = samples_without_timestamps
-                        .get(&key)
-                        .expect("Sample not found");
-
-                    assert_eq!(sample.values, expected_sample.values);
+                    if let Some(expected_sample) = expected_timestamped_samples.next() {
+                        assert_eq!(owned_locations, expected_sample.locations);
+                        assert_eq!(sample.values, expected_sample.values);
+                        assert_eq!(owned_labels, expected_sample.labels);
+                    } else {
+                        let key = (&owned_locations, &owned_labels);
+                        let expected_values = samples_without_timestamps
+                            .get(&key)
+                            .expect("Value not found for an aggregated sample");
+                        assert_eq!(&sample.values, expected_values);
+                    }
                 }
             })
     }

From 1caaf05f89bf45b943573d8c1138ae0502c2e7c2 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Tue, 28 May 2024 22:07:15 -0400
Subject: [PATCH 23/54] helper functions

---
 profiling/src/internal/profile.rs | 269 ++++++++++++++++--------------
 1 file changed, 146 insertions(+), 123 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index c27be8af1..f84f2d98c 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -547,6 +547,139 @@ mod api_tests {
     use bolero::TypeGenerator;
     use std::collections::{HashMap, HashSet};
 
+    fn assert_sample_types_eq(
+        profile: &pprof::Profile,
+        expected_sample_types: &[owned_types::ValueType],
+    ) {
+        assert_eq!(
+            profile.sample_types.len(),
+            expected_sample_types.len(),
+            "Sample types length mismatch"
+        );
+        for (typ, expected_typ) in profile
+            .sample_types
+            .iter()
+            .zip(expected_sample_types.iter())
+        {
+            assert_eq!(
+                *profile.string_table[typ.r#type as usize],
+                *expected_typ.r#typ
+            );
+            assert_eq!(*profile.string_table[typ.unit as usize], *expected_typ.unit);
+        }
+    }
+
+    fn assert_samples_eq(
+        profile: &pprof::Profile,
+        samples_with_timestamps: &[&owned_types::Sample],
+        samples_without_timestamps: &HashMap<
+            (&Vec<owned_types::Location>, &Vec<owned_types::Label>),
+            Vec<i64>,
+        >,
+    ) {
+        assert_eq!(
+            profile.samples.len(),
+            samples_with_timestamps.len() + samples_without_timestamps.len(),
+            "Samples length mismatch"
+        );
+
+        let mut expected_timestamped_samples = samples_with_timestamps.iter();
+
+        for sample in profile.samples.iter() {
+            // Recreate owned_locations from vector of pprof::Location
+            let mut owned_locations = Vec::new();
+            for loc_id in sample.location_ids.iter() {
+                let location = &profile.locations[*loc_id as usize - 1];
+                let mapping = &profile.mappings[location.mapping_id as usize - 1];
+                assert!(location.lines.len() == 1);
+                let line = location.lines[0];
+                let function = profile.functions[line.function_id as usize - 1];
+                assert!(!location.is_folded);
+
+                let owned_location = owned_types::Location {
+                    mapping: owned_types::Mapping {
+                        memory_start: mapping.memory_start,
+                        memory_limit: mapping.memory_limit,
+                        file_offset: mapping.file_offset,
+                        filename: profile.string_table[mapping.filename as usize]
+                            .clone()
+                            .into_boxed_str(),
+                        build_id: profile.string_table[mapping.build_id as usize]
+                            .clone()
+                            .into_boxed_str(),
+                    },
+                    function: owned_types::Function {
+                        name: profile.string_table[function.name as usize]
+                            .clone()
+                            .into_boxed_str(),
+                        system_name: profile.string_table[function.system_name as usize]
+                            .clone()
+                            .into_boxed_str(),
+                        filename: profile.string_table[function.filename as usize]
+                            .clone()
+                            .into_boxed_str(),
+                        start_line: function.start_line,
+                    },
+                    address: location.address,
+                    line: line.line,
+                };
+
+                owned_locations.push(owned_location);
+            }
+
+            // Recreate owned_labels from vector of pprof::Label
+            let mut owned_labels = Vec::new();
+            for label in sample.labels.iter() {
+                let key = profile.string_table[label.key as usize]
+                    .clone()
+                    .into_boxed_str();
+
+                if *key == *"end_timestamp_ns" {
+                    continue;
+                }
+
+                if label.str != 0 {
+                    let str = profile.string_table[label.str as usize].clone();
+                    owned_labels.push(owned_types::Label {
+                        key,
+                        str: Some(str),
+                        num: 0,
+                        num_unit: None,
+                    });
+                } else {
+                    let num = label.num;
+                    let num_unit = if label.num_unit != 0 {
+                        Some(
+                            profile.string_table[label.num_unit as usize]
+                                .clone()
+                                .into_boxed_str(),
+                        )
+                    } else {
+                        None
+                    };
+                    owned_labels.push(owned_types::Label {
+                        key,
+                        str: None,
+                        num,
+                        num_unit,
+                    });
+                }
+            }
+
+            if let Some(expected_sample) = expected_timestamped_samples.next() {
+                assert_eq!(owned_locations, expected_sample.locations);
+                assert_eq!(sample.values, expected_sample.values);
+                assert_eq!(owned_labels, expected_sample.labels);
+            } else {
+                let key = (&owned_locations, &owned_labels);
+                let expected_values = samples_without_timestamps
+                    .get(&key)
+                    .expect("Value not found for an aggregated sample");
+                assert_eq!(&sample.values, expected_values);
+            }
+        }
+    }
+
     /// Fuzzes adding a bunch of samples to the profile.
     /// TODO: many of the samples will be of the wrong length, and will give a boring error right
     /// away.  Improve the generator to test the case where samples are the right length to get
@@ -559,10 +692,12 @@ mod api_tests {
                 Vec::<owned_types::ValueType>::gen(),
                 Vec::<(Option<Timestamp>, owned_types::Sample)>::gen(),
             ))
-            .for_each(|(val, samples)| {
-                let expected_sample_types: Vec<_> = val.iter().map(api::ValueType::from).collect();
-                let mut expected_profile =
-                    Profile::new(SystemTime::now(), &expected_sample_types, None);
+            .for_each(|(expected_sample_types, samples)| {
+                let sample_types: Vec<_> = expected_sample_types
+                    .iter()
+                    .map(api::ValueType::from)
+                    .collect();
+                let mut expected_profile = Profile::new(SystemTime::now(), &sample_types, None);
                 let mut samples_with_timestamps = Vec::new();
                 let mut samples_without_timestamps: HashMap<
                     (&Vec<owned_types::Location>, &Vec<owned_types::Label>),
@@ -570,7 +705,8 @@ mod api_tests {
                 > = HashMap::new();
                 for (timestamp, sample) in samples {
                     let r = expected_profile.add_sample(sample.into(), timestamp.clone());
-                    if val.len() == sample.values.len() && sample.is_well_formed() {
+                    if expected_sample_types.len() == sample.values.len() && sample.is_well_formed()
+                    {
                         assert!(r.is_ok());
                         if timestamp.is_some() {
                             samples_with_timestamps.push(sample);
@@ -595,125 +731,12 @@ mod api_tests {
                 }
 
                 let profile = pprof::roundtrip_to_pprof(expected_profile).unwrap();
-
-                assert_eq!(
-                    profile.sample_types.len(),
-                    expected_sample_types.len(),
-                    "Sample types length mismatch"
+                assert_sample_types_eq(&profile, &expected_sample_types);
+                assert_samples_eq(
+                    &profile,
+                    &samples_with_timestamps,
+                    &samples_without_timestamps,
                 );
-                for (typ, expected_typ) in profile
-                    .sample_types
-                    .iter()
-                    .zip(expected_sample_types.iter())
-                {
-                    assert_eq!(
-                        profile.string_table[typ.r#type as usize],
-                        expected_typ.r#type
-                    );
-                    assert_eq!(profile.string_table[typ.unit as usize], expected_typ.unit);
-                }
-
-                assert_eq!(
-                    profile.samples.len(),
-                    samples_with_timestamps.len() + samples_without_timestamps.len(),
-                    "Samples length mismatch"
-                );
-
-                let mut expected_timestamped_samples = samples_with_timestamps.iter();
-
-                for sample in profile.samples.iter() {
-                    // Recreate owned_locations from vector of pprof::Location
-                    let mut owned_locations = Vec::new();
-                    for loc_id in sample.location_ids.iter() {
-                        let location = &profile.locations[*loc_id as usize - 1];
-                        let mapping = &profile.mappings[location.mapping_id as usize - 1];
-                        assert!(location.lines.len() == 1);
-                        let line = location.lines[0];
-                        let function = profile.functions[line.function_id as usize - 1];
-                        assert!(!location.is_folded);
-
-                        let owned_location = owned_types::Location {
-                            mapping: owned_types::Mapping {
-                                memory_start: mapping.memory_start,
-                                memory_limit: mapping.memory_limit,
-                                file_offset: mapping.file_offset,
-                                filename: profile.string_table[mapping.filename as usize]
-                                    .clone()
-                                    .into_boxed_str(),
-                                build_id: profile.string_table[mapping.build_id as usize]
-                                    .clone()
-                                    .into_boxed_str(),
-                            },
-                            function: owned_types::Function {
-                                name: profile.string_table[function.name as usize]
-                                    .clone()
-                                    .into_boxed_str(),
-                                system_name: profile.string_table[function.system_name as usize]
-                                    .clone()
-                                    .into_boxed_str(),
-                                filename: profile.string_table[function.filename as usize]
-                                    .clone()
-                                    .into_boxed_str(),
-                                start_line: function.start_line,
-                            },
-                            address: location.address,
-                            line: line.line,
-                        };
-
-                        owned_locations.push(owned_location);
-                    }
-
-                    // Recreate owned_labels from vector of pprof::Label
-                    let mut owned_labels = Vec::new();
-                    for label in sample.labels.iter() {
-                        let key = profile.string_table[label.key as usize]
-                            .clone()
-                            .into_boxed_str();
-
-                        if *key == *"end_timestamp_ns" {
-                            continue;
-                        }
-
-                        if label.str != 0 {
-                            let str = profile.string_table[label.str as usize].clone();
-                            owned_labels.push(owned_types::Label {
-                                key,
-                                str: Some(str),
-                                num: 0,
-                                num_unit: None,
-                            });
-                        } else {
-                            let num = label.num;
-                            let num_unit = if label.num_unit != 0 {
-                                Some(
-                                    profile.string_table[label.num_unit as usize]
-                                        .clone()
-                                        .into_boxed_str(),
-                                )
-                            } else {
-                                None
-                            };
-                            owned_labels.push(owned_types::Label {
-                                key,
-                                str: None,
-                                num,
-                                num_unit,
-                            });
-                        }
-                    }
-
-                    if let Some(expected_sample) = expected_timestamped_samples.next() {
-                        assert_eq!(owned_locations, expected_sample.locations);
-                        assert_eq!(sample.values, expected_sample.values);
-                        assert_eq!(owned_labels, expected_sample.labels);
-                    } else {
-                        let key = (&owned_locations, &owned_labels);
-                        let expected_values = samples_without_timestamps
-                            .get(&key)
-                            .expect("Value not found for an aggregated sample");
-                        assert_eq!(&sample.values, expected_values);
-                    }
-                }
             })
     }
 

From f8a8ec14fdda3b5221f4408569b6baa01ff433a5 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Tue, 28 May 2024 22:39:21 -0400
Subject: [PATCH 24/54] use the same pattern for fixed_sample_length

---
 profiling/src/internal/profile.rs | 68 +++++++++++++++++++++----------
 1 file changed, 47 insertions(+), 21 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index f84f2d98c..f9fa7d71a 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -770,40 +770,66 @@ mod api_tests {
                     SystemTime::from(chrono::DateTime::from_timestamp_nanos(*start_time_ns));
                 let duration = Duration::from_nanos(*duration_ns);
                 let end_time = start_time + duration;
-                let sample_types: Vec<_> = sample_types.iter().map(api::ValueType::from).collect();
-                let mut profile = Profile::new(start_time, &sample_types, None);
-                let mut num_timestamped = 0;
-
-                for (timestamp, locations, values, labels) in samples {
-                    let sample = owned_types::Sample {
-                        locations: locations.clone(),
-                        values: values.clone(),
-                        labels: labels.clone().into_iter().collect(),
-                    };
-                    let r = profile.add_sample((&sample).into(), timestamp.clone());
+                let api_sample_types: Vec<_> =
+                    sample_types.iter().map(api::ValueType::from).collect();
+                let mut profile = Profile::new(start_time, &api_sample_types, None);
+                let mut samples_with_timestamps = Vec::new();
+                let mut samples_without_timestamps: HashMap<
+                    (&Vec<owned_types::Location>, &Vec<owned_types::Label>),
+                    Vec<i64>,
+                > = HashMap::new();
+
+                let samples: Vec<(&Option<Timestamp>, owned_types::Sample)> = samples
+                    .into_iter()
+                    .map(|(timestamp, locations, values, labels)| {
+                        (
+                            timestamp,
+                            owned_types::Sample {
+                                locations: locations.clone(),
+                                values: values.clone(),
+                                labels: labels
+                                    .clone()
+                                    .into_iter()
+                                    .collect::<Vec<owned_types::Label>>(),
+                            },
+                        )
+                    })
+                    .collect();
+
+                for (timestamp, sample) in samples.iter() {
+                    let r = profile.add_sample(sample.into(), **timestamp);
                     if r.is_err() {
                         panic!("Failed to add sample: {:?}", r);
                     }
                     assert!(r.is_ok());
                     if timestamp.is_some() {
-                        num_timestamped += 1;
+                        samples_with_timestamps.push(sample);
+                    } else {
+                        if let Some(existing_values) =
+                            samples_without_timestamps.get_mut(&(&sample.locations, &sample.labels))
+                        {
+                            existing_values
+                                .iter_mut()
+                                .zip(sample.values.iter())
+                                .for_each(|(a, b)| *a = a.saturating_add(*b));
+                        } else {
+                            samples_without_timestamps
+                                .insert((&sample.locations, &sample.labels), sample.values.clone());
+                        }
                     }
                 }
-                assert_eq!(
-                    profile.only_for_testing_num_timestamped_samples(),
-                    num_timestamped
-                );
-
                 let encoded = profile
                     .serialize_into_compressed_pprof(Some(end_time), Some(duration))
                     .unwrap();
                 let serialized_profile =
                     pprof::deserialize_compressed_pprof(&encoded.buffer).unwrap();
 
-                assert_eq!(sample_types.len(), serialized_profile.sample_types.len());
-                // The next line passes but I thought that aggregated samples would
-                // decrease the samples count and thus the next line would fail.
-                assert_eq!(samples.len(), serialized_profile.samples.len());
+                assert_sample_types_eq(&serialized_profile, &sample_types);
+                assert_samples_eq(
+                    &serialized_profile,
+                    &samples_with_timestamps,
+                    &samples_without_timestamps,
+                );
             });
     }
 

From fe06bb7023166e580ccd1345437d26f926f41156 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Tue, 28 May 2024 22:46:08 -0400
Subject: [PATCH 25/54] update comments

---
 profiling/src/internal/profile.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index f9fa7d71a..0afda1fe0 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -681,10 +681,6 @@ mod api_tests {
     }
 
     /// Fuzzes adding a bunch of samples to the profile.
-    /// TODO: many of the samples will be of the wrong length, and will give a boring error right
-    /// away.  Improve the generator to test the case where samples are the right length to get
-    /// more coverage faster
-    /// TODO: Test the expected result of adding the samples
     #[test]
     fn fuzz_add_sample() {
         bolero::check!()

From f7ca80bc7338726599092bc279d1c2e06febf2bf Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Tue, 28 May 2024 22:48:43 -0400
Subject: [PATCH 26/54] clippy

---
 profiling/src/internal/profile.rs | 50 ++++++++++++++-----------------
 1 file changed, 22 insertions(+), 28 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 0afda1fe0..846833e2c 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -700,26 +700,22 @@ mod api_tests {
                     Vec<i64>,
                 > = HashMap::new();
                 for (timestamp, sample) in samples {
-                    let r = expected_profile.add_sample(sample.into(), timestamp.clone());
+                    let r = expected_profile.add_sample(sample.into(), *timestamp);
                     if expected_sample_types.len() == sample.values.len() && sample.is_well_formed()
                     {
                         assert!(r.is_ok());
                         if timestamp.is_some() {
                             samples_with_timestamps.push(sample);
+                        } else if let Some(existing_values) =
+                            samples_without_timestamps.get_mut(&(&sample.locations, &sample.labels))
+                        {
+                            existing_values
+                                .iter_mut()
+                                .zip(sample.values.iter())
+                                .for_each(|(a, b)| *a = a.saturating_add(*b));
                         } else {
-                            if let Some(existing_values) = samples_without_timestamps
-                                .get_mut(&(&sample.locations, &sample.labels))
-                            {
-                                existing_values
-                                    .iter_mut()
-                                    .zip(sample.values.iter())
-                                    .for_each(|(a, b)| *a = a.saturating_add(*b));
-                            } else {
-                                samples_without_timestamps.insert(
-                                    (&sample.locations, &sample.labels),
-                                    sample.values.clone(),
-                                );
-                            }
+                            samples_without_timestamps
+                                .insert((&sample.locations, &sample.labels), sample.values.clone());
                         }
                     } else {
                         assert!(r.is_err());
@@ -727,7 +723,7 @@ mod api_tests {
                 }
 
                 let profile = pprof::roundtrip_to_pprof(expected_profile).unwrap();
-                assert_sample_types_eq(&profile, &expected_sample_types);
+                assert_sample_types_eq(&profile, expected_sample_types);
                 assert_samples_eq(
                     &profile,
                     &samples_with_timestamps,
@@ -776,7 +772,7 @@ mod api_tests {
                 > = HashMap::new();
 
                 let samples: Vec<(&Option<Timestamp>, owned_types::Sample)> = samples
-                    .into_iter()
+                    .iter()
                     .map(|(timestamp, locations, values, labels)| {
                         (
                             timestamp,
@@ -800,18 +796,16 @@ mod api_tests {
                     assert!(r.is_ok());
                     if timestamp.is_some() {
                         samples_with_timestamps.push(sample);
+                    } else if let Some(existing_values) =
+                        samples_without_timestamps.get_mut(&(&sample.locations, &sample.labels))
+                    {
+                        existing_values
+                            .iter_mut()
+                            .zip(sample.values.iter())
+                            .for_each(|(a, b)| *a = a.saturating_add(*b));
                     } else {
-                        if let Some(existing_values) =
-                            samples_without_timestamps.get_mut(&(&sample.locations, &sample.labels))
-                        {
-                            existing_values
-                                .iter_mut()
-                                .zip(sample.values.iter())
-                                .for_each(|(a, b)| *a = a.saturating_add(*b));
-                        } else {
-                            samples_without_timestamps
-                                .insert((&sample.locations, &sample.labels), sample.values.clone());
-                        }
+                        samples_without_timestamps
+                            .insert((&sample.locations, &sample.labels), sample.values.clone());
                     }
                 }
                 let encoded = profile
@@ -820,7 +814,7 @@ mod api_tests {
                 let serialized_profile =
                     pprof::deserialize_compressed_pprof(&encoded.buffer).unwrap();
 
-                assert_sample_types_eq(&serialized_profile, &sample_types);
+                assert_sample_types_eq(&serialized_profile, sample_types);
                 assert_samples_eq(
                     &serialized_profile,
                     &samples_with_timestamps,

From fac921d731eead0031ed6fabeccb9ada04209986 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Wed, 29 May 2024 10:18:21 -0400
Subject: [PATCH 27/54] api function calls

---
 profiling/src/internal/profile.rs | 82 +++++++++++++++++++++++++++++--
 1 file changed, 77 insertions(+), 5 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 846833e2c..8ff7f3aab 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -789,11 +789,9 @@ mod api_tests {
                     .collect();
 
                 for (timestamp, sample) in samples.iter() {
-                    let r = profile.add_sample(sample.into(), **timestamp);
-                    if r.is_err() {
-                        panic!("Failed to add sample: {:?}", r);
-                    }
-                    assert!(r.is_ok());
+                    profile
+                        .add_sample(sample.into(), **timestamp)
+                        .expect("Failed to add sample");
                     if timestamp.is_some() {
                         samples_with_timestamps.push(sample);
                     } else if let Some(existing_values) =
@@ -853,6 +851,80 @@ mod api_tests {
             });
     }
 
+    #[derive(Debug, TypeGenerator)]
+    enum Function {
+        AddSample(Option<Timestamp>, owned_types::Sample),
+        AddEndpoint,
+    }
+
+    #[derive(Debug, TypeGenerator)]
+    struct ApiFunctionCalls {
+        sample_types: Vec<owned_types::ValueType>,
+        operations: Vec<Function>,
+    }
+
+    #[test]
+    fn fuzz_api_function_calls() {
+        let sample_length_gen = 1..=64usize;
+
+        bolero::check!()
+            .with_generator(sample_length_gen)
+            .and_then(|sample_len| {
+                let sample_types = Vec::<owned_types::ValueType>::gen().with().len(sample_len);
+                let operations = Vec::<Function>::gen();
+
+                (sample_types, operations)
+            })
+            .for_each(|(sample_types, operations)| {
+                let api_sample_types: Vec<_> =
+                    sample_types.iter().map(api::ValueType::from).collect();
+                let mut profile = Profile::new(SystemTime::now(), &api_sample_types, None);
+                let mut samples_with_timestamps: Vec<&owned_types::Sample> = Vec::new();
+                let mut samples_without_timestamps: HashMap<
+                    (&Vec<owned_types::Location>, &Vec<owned_types::Label>),
+                    Vec<i64>,
+                > = HashMap::new();
+
+                for operation in operations {
+                    match operation {
+                        Function::AddSample(timestamp, sample) => {
+                            let r = profile.add_sample(sample.into(), *timestamp);
+                            if sample_types.len() == sample.values.len() && sample.is_well_formed()
+                            {
+                                assert!(r.is_ok());
+                                if timestamp.is_some() {
+                                    samples_with_timestamps.push(sample);
+                                } else if let Some(existing_values) = samples_without_timestamps
+                                    .get_mut(&(&sample.locations, &sample.labels))
+                                {
+                                    existing_values
+                                        .iter_mut()
+                                        .zip(sample.values.iter())
+                                        .for_each(|(a, b)| *a = a.saturating_add(*b));
+                                } else {
+                                    samples_without_timestamps.insert(
+                                        (&sample.locations, &sample.labels),
+                                        sample.values.clone(),
+                                    );
+                                }
+                            } else {
+                                assert!(r.is_err());
+                            }
+                        }
+                        Function::AddEndpoint => {}
+                    }
+                }
+
+                let pprof_profile = pprof::roundtrip_to_pprof(profile).unwrap();
+                assert_sample_types_eq(&pprof_profile, &sample_types);
+                assert_samples_eq(
+                    &pprof_profile,
+                    &samples_with_timestamps,
+                    &samples_without_timestamps,
+                );
+            })
+    }
+
     #[test]
     fn interning() {
         let sample_types = [api::ValueType::new("samples", "count")];

From 799a4e8b9b1bad38cfc29fa107b4c1081d7739b1 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Wed, 29 May 2024 11:49:31 -0400
Subject: [PATCH 28/54] fuzz with add_endpoint

---
 profiling/src/internal/owned_types.rs | 33 ++++++++++++++++++++++++++-
 profiling/src/internal/profile.rs     | 26 +++++++++++++++++++--
 2 files changed, 56 insertions(+), 3 deletions(-)

diff --git a/profiling/src/internal/owned_types.rs b/profiling/src/internal/owned_types.rs
index 5c69b5ba0..ef4d8b031 100644
--- a/profiling/src/internal/owned_types.rs
+++ b/profiling/src/internal/owned_types.rs
@@ -1,6 +1,9 @@
 // Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
+#[cfg(test)]
+use bolero_generator::{TypeGeneratorWithParams, ValueGenerator};
+
 use crate::api;
 
 #[derive(Clone, Debug, Default, Eq, PartialEq, Hash)]
@@ -173,7 +176,6 @@ impl<'a> From<&'a api::Period<'a>> for Period {
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
 pub struct Sample {
     /// The leaf is at locations[0].
     pub locations: Vec<Location>,
@@ -191,6 +193,35 @@ pub struct Sample {
     pub labels: Vec<Label>,
 }
 
+#[cfg(test)]
+impl bolero_generator::TypeGenerator for Sample {
+    fn generate<D: bolero_generator::Driver>(driver: &mut D) -> Option<Self> {
+        let locations = Vec::<Location>::gen_with().generate(driver)?;
+        let values = Vec::<i64>::gen_with().generate(driver)?;
+        let mut labels = std::collections::HashSet::<Label>::gen_with().generate(driver)?;
+
+        // Ensure that the label has "local root span id" key
+        // Generate non-zero i64 value for the label
+        let num = i64::gen().generate(driver)?;
+        if num == 0 {
+            return None;
+        }
+
+        labels.insert(Label {
+            key: "local root span id".into(),
+            str: None,
+            num,
+            num_unit: None,
+        });
+        let labels = labels.into_iter().collect();
+        Some(Self {
+            locations,
+            values,
+            labels,
+        })
+    }
+}
+
 impl std::hash::Hash for Sample {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         self.locations.hash(state);
diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 8ff7f3aab..bd2f17d37 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -576,6 +576,7 @@ mod api_tests {
             (&Vec<owned_types::Location>, &Vec<owned_types::Label>),
             Vec<i64>,
         >,
+        endpoint_mappings: &FxIndexMap<u64, &String>,
     ) {
         assert_eq!(
             profile.samples.len(),
@@ -636,6 +637,18 @@ mod api_tests {
 
                 if *key == *"end_timestamp_ns" {
                     continue;
+                } else if *key == *"trace endpoint" {
+                    let actual_str = &profile.string_table[label.str as usize];
+
+                    let prev_label: &owned_types::Label =
+                        owned_labels.last().expect("No previous label");
+                    let num = prev_label.num as u64;
+                    let expected_str = endpoint_mappings
+                        .get(&num)
+                        .expect("No endpoint mapping found");
+
+                    assert_eq!(actual_str, *expected_str);
+                    continue;
                 }
 
                 if label.str != 0 {
@@ -728,6 +741,7 @@ mod api_tests {
                     &profile,
                     &samples_with_timestamps,
                     &samples_without_timestamps,
+                    &FxIndexMap::default(),
                 );
             })
     }
@@ -817,6 +831,7 @@ mod api_tests {
                     &serialized_profile,
                     &samples_with_timestamps,
                     &samples_without_timestamps,
+                    &FxIndexMap::default(),
                 );
             });
     }
@@ -854,7 +869,7 @@ mod api_tests {
     #[derive(Debug, TypeGenerator)]
     enum Function {
         AddSample(Option<Timestamp>, owned_types::Sample),
-        AddEndpoint,
+        AddEndpoint(u64, String),
     }
 
     #[derive(Debug, TypeGenerator)]
@@ -884,6 +899,7 @@ mod api_tests {
                     (&Vec<owned_types::Location>, &Vec<owned_types::Label>),
                     Vec<i64>,
                 > = HashMap::new();
+                let mut endpoint_mappings: FxIndexMap<u64, &String> = FxIndexMap::default();
 
                 for operation in operations {
                     match operation {
@@ -911,7 +927,12 @@ mod api_tests {
                                 assert!(r.is_err());
                             }
                         }
-                        Function::AddEndpoint => {}
+                        Function::AddEndpoint(local_root_span_id, endpoint) => {
+                            profile
+                                .add_endpoint(*local_root_span_id, endpoint.into())
+                                .expect("Failed to add endpoint");
+                            endpoint_mappings.insert(*local_root_span_id, endpoint);
+                        }
                     }
                 }
 
@@ -921,6 +942,7 @@ mod api_tests {
                     &pprof_profile,
                     &samples_with_timestamps,
                     &samples_without_timestamps,
+                    &endpoint_mappings,
                 );
             })
     }

From 383fe4b337b5a722b17a6548d0b70e063eb88b4d Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Wed, 29 May 2024 11:55:36 -0400
Subject: [PATCH 29/54] fix clippy

---
 profiling/src/internal/profile.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index bd2f17d37..95ff87200 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -937,7 +937,7 @@ mod api_tests {
                 }
 
                 let pprof_profile = pprof::roundtrip_to_pprof(profile).unwrap();
-                assert_sample_types_eq(&pprof_profile, &sample_types);
+                assert_sample_types_eq(&pprof_profile, sample_types);
                 assert_samples_eq(
                     &pprof_profile,
                     &samples_with_timestamps,

From 88bde3df85d2db3217d0cbcc7a447d5fb3256942 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Wed, 29 May 2024 12:00:46 -0400
Subject: [PATCH 30/54] assert, expect

---
 profiling/src/internal/profile.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 95ff87200..fe8ab7046 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -843,11 +843,11 @@ mod api_tests {
             .for_each(|endpoints| {
                 let mut profile = Profile::new(SystemTime::now(), &[], None);
                 for (local_root_span_id, endpoint) in endpoints {
-                    let r = profile.add_endpoint(*local_root_span_id, endpoint.into());
-                    assert!(r.is_ok());
+                    profile
+                        .add_endpoint(*local_root_span_id, endpoint.into())
+                        .expect("add_endpoint to succeed");
                 }
-                let encoded = profile.serialize_into_compressed_pprof(None, None).unwrap();
-                pprof::deserialize_compressed_pprof(&encoded.buffer).unwrap();
+                pprof::roundtrip_to_pprof(profile).expect("roundtrip_to_pprof to succeed");
             });
     }
 
@@ -858,11 +858,11 @@ mod api_tests {
             .for_each(|endpoint_counts| {
                 let mut profile = Profile::new(SystemTime::now(), &[], None);
                 for (endpoint, count) in endpoint_counts {
-                    let r = profile.add_endpoint_count(endpoint.into(), *count);
-                    assert!(r.is_ok());
+                    profile
+                        .add_endpoint_count(endpoint.into(), *count)
+                        .expect("add_endpoint_count to succeed");
                 }
-                let encoded = profile.serialize_into_compressed_pprof(None, None).unwrap();
-                pprof::deserialize_compressed_pprof(&encoded.buffer).unwrap();
+                pprof::roundtrip_to_pprof(profile).expect("roundtrip_to_pprof to succeed");
             });
     }
 
@@ -930,7 +930,7 @@ mod api_tests {
                         Function::AddEndpoint(local_root_span_id, endpoint) => {
                             profile
                                 .add_endpoint(*local_root_span_id, endpoint.into())
-                                .expect("Failed to add endpoint");
+                                .expect("add_endpoint to succeed");
                             endpoint_mappings.insert(*local_root_span_id, endpoint);
                         }
                     }

From fa1680ef2c3a72c9806eff7b88362fbb4d1fc1a2 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Wed, 29 May 2024 13:05:11 -0400
Subject: [PATCH 31/54] comments

---
 profiling/src/internal/owned_types.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/profiling/src/internal/owned_types.rs b/profiling/src/internal/owned_types.rs
index ef4d8b031..c97e1fea2 100644
--- a/profiling/src/internal/owned_types.rs
+++ b/profiling/src/internal/owned_types.rs
@@ -201,8 +201,9 @@ impl bolero_generator::TypeGenerator for Sample {
         let mut labels = std::collections::HashSet::<Label>::gen_with().generate(driver)?;
 
         // Ensure that the label has "local root span id" key
-        // Generate non-zero i64 value for the label
+        // Generate non-zero num value for the label
         let num = i64::gen().generate(driver)?;
+        // zero num is considered as invalid, see Profile::validate_sample_labels
         if num == 0 {
             return None;
         }

From cdb9236bcf616f41215698bfa1c5f6de40c72093 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Wed, 29 May 2024 13:05:49 -0400
Subject: [PATCH 32/54] remove unneeded

---
 profiling/src/internal/owned_types.rs | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/profiling/src/internal/owned_types.rs b/profiling/src/internal/owned_types.rs
index c97e1fea2..28db71a33 100644
--- a/profiling/src/internal/owned_types.rs
+++ b/profiling/src/internal/owned_types.rs
@@ -223,13 +223,6 @@ impl bolero_generator::TypeGenerator for Sample {
     }
 }
 
-impl std::hash::Hash for Sample {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.locations.hash(state);
-        self.labels.hash(state);
-    }
-}
-
 impl<'a> From<&'a Sample> for api::Sample<'a> {
     fn from(value: &'a Sample) -> Self {
         Self {

From 5b576f7b7c14a4db8f471bac86a438fc02b7fde1 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Wed, 29 May 2024 13:08:21 -0400
Subject: [PATCH 33/54] remove is_well_formed

---
 profiling/src/internal/owned_types.rs | 12 ------------
 profiling/src/internal/profile.rs     |  4 ++--
 2 files changed, 2 insertions(+), 14 deletions(-)

diff --git a/profiling/src/internal/owned_types.rs b/profiling/src/internal/owned_types.rs
index 28db71a33..8623e6f43 100644
--- a/profiling/src/internal/owned_types.rs
+++ b/profiling/src/internal/owned_types.rs
@@ -233,18 +233,6 @@ impl<'a> From<&'a Sample> for api::Sample<'a> {
     }
 }
 
-#[cfg(test)]
-impl Sample {
-    /// Checks if the sample is well formed.  Useful in testing.
-    pub fn is_well_formed(&self) -> bool {
-        let labels_are_unique = {
-            let mut uniq = std::collections::HashSet::new();
-            self.labels.iter().map(|l| &l.key).all(|x| uniq.insert(x))
-        };
-        labels_are_unique
-    }
-}
-
 #[derive(Clone, Debug)]
 #[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
 pub struct ValueType {
diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index fe8ab7046..e2221c3b4 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -714,7 +714,7 @@ mod api_tests {
                 > = HashMap::new();
                 for (timestamp, sample) in samples {
                     let r = expected_profile.add_sample(sample.into(), *timestamp);
-                    if expected_sample_types.len() == sample.values.len() && sample.is_well_formed()
+                    if expected_sample_types.len() == sample.values.len()
                     {
                         assert!(r.is_ok());
                         if timestamp.is_some() {
@@ -905,7 +905,7 @@ mod api_tests {
                     match operation {
                         Function::AddSample(timestamp, sample) => {
                             let r = profile.add_sample(sample.into(), *timestamp);
-                            if sample_types.len() == sample.values.len() && sample.is_well_formed()
+                            if sample_types.len() == sample.values.len()
                             {
                                 assert!(r.is_ok());
                                 if timestamp.is_some() {

From 6a1177097c62015d1273d10da65beae057036f0a Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Wed, 29 May 2024 13:09:51 -0400
Subject: [PATCH 34/54] update expect

---
 profiling/src/internal/profile.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index e2221c3b4..e8abfd428 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -640,12 +640,13 @@ mod api_tests {
                 } else if *key == *"trace endpoint" {
                     let actual_str = &profile.string_table[label.str as usize];
 
-                    let prev_label: &owned_types::Label =
-                        owned_labels.last().expect("No previous label");
+                    let prev_label: &owned_types::Label = owned_labels
+                        .last()
+                        .expect("Previous label to exist for endpoint label");
                     let num = prev_label.num as u64;
                     let expected_str = endpoint_mappings
                         .get(&num)
-                        .expect("No endpoint mapping found");
+                        .expect("Endpoint mapping to exist");
 
                     assert_eq!(actual_str, *expected_str);
                     continue;
@@ -714,8 +715,7 @@ mod api_tests {
                 > = HashMap::new();
                 for (timestamp, sample) in samples {
                     let r = expected_profile.add_sample(sample.into(), *timestamp);
-                    if expected_sample_types.len() == sample.values.len()
-                    {
+                    if expected_sample_types.len() == sample.values.len() {
                         assert!(r.is_ok());
                         if timestamp.is_some() {
                             samples_with_timestamps.push(sample);
@@ -905,8 +905,7 @@ mod api_tests {
                     match operation {
                         Function::AddSample(timestamp, sample) => {
                             let r = profile.add_sample(sample.into(), *timestamp);
-                            if sample_types.len() == sample.values.len()
-                            {
+                            if sample_types.len() == sample.values.len() {
                                 assert!(r.is_ok());
                                 if timestamp.is_some() {
                                     samples_with_timestamps.push(sample);

From 583f4835755465fdab78c131db0987c6021f81c6 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Wed, 29 May 2024 13:18:47 -0400
Subject: [PATCH 35/54] refactor into add_sample

---
 profiling/src/internal/profile.rs | 90 +++++++++++++++++--------------
 1 file changed, 49 insertions(+), 41 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index e8abfd428..ad89398f2 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -636,6 +636,7 @@ mod api_tests {
                     .into_boxed_str();
 
                 if *key == *"end_timestamp_ns" {
+                    // TODO: Check end timestamp label
                     continue;
                 } else if *key == *"trace endpoint" {
                     let actual_str = &profile.string_table[label.str as usize];
@@ -694,6 +695,38 @@ mod api_tests {
         }
     }
 
+    fn add_sample<'a>(
+        timestamp: &Option<Timestamp>,
+        sample: &'a owned_types::Sample,
+        expected_sample_types: &[owned_types::ValueType],
+        profile: &mut Profile,
+        samples_with_timestamps: &mut Vec<&'a owned_types::Sample>,
+        samples_without_timestamps: &mut HashMap<
+            (&'a Vec<owned_types::Location>, &'a Vec<owned_types::Label>),
+            Vec<i64>,
+        >,
+    ) {
+        let r = profile.add_sample(sample.into(), *timestamp);
+        if expected_sample_types.len() == sample.values.len() {
+            assert!(r.is_ok());
+            if timestamp.is_some() {
+                samples_with_timestamps.push(sample);
+            } else if let Some(existing_values) =
+                samples_without_timestamps.get_mut(&(&sample.locations, &sample.labels))
+            {
+                existing_values
+                    .iter_mut()
+                    .zip(sample.values.iter())
+                    .for_each(|(a, b)| *a = a.saturating_add(*b));
+            } else {
+                samples_without_timestamps
+                    .insert((&sample.locations, &sample.labels), sample.values.clone());
+            }
+        } else {
+            assert!(r.is_err());
+        }
+    }
+
     /// Fuzzes adding a bunch of samples to the profile.
     #[test]
     fn fuzz_add_sample() {
@@ -714,27 +747,15 @@ mod api_tests {
                     Vec<i64>,
                 > = HashMap::new();
                 for (timestamp, sample) in samples {
-                    let r = expected_profile.add_sample(sample.into(), *timestamp);
-                    if expected_sample_types.len() == sample.values.len() {
-                        assert!(r.is_ok());
-                        if timestamp.is_some() {
-                            samples_with_timestamps.push(sample);
-                        } else if let Some(existing_values) =
-                            samples_without_timestamps.get_mut(&(&sample.locations, &sample.labels))
-                        {
-                            existing_values
-                                .iter_mut()
-                                .zip(sample.values.iter())
-                                .for_each(|(a, b)| *a = a.saturating_add(*b));
-                        } else {
-                            samples_without_timestamps
-                                .insert((&sample.locations, &sample.labels), sample.values.clone());
-                        }
-                    } else {
-                        assert!(r.is_err());
-                    }
+                    add_sample(
+                        &timestamp,
+                        &sample,
+                        &expected_sample_types,
+                        &mut expected_profile,
+                        &mut samples_with_timestamps,
+                        &mut samples_without_timestamps,
+                    );
                 }
-
                 let profile = pprof::roundtrip_to_pprof(expected_profile).unwrap();
                 assert_sample_types_eq(&profile, expected_sample_types);
                 assert_samples_eq(
@@ -904,27 +925,14 @@ mod api_tests {
                 for operation in operations {
                     match operation {
                         Function::AddSample(timestamp, sample) => {
-                            let r = profile.add_sample(sample.into(), *timestamp);
-                            if sample_types.len() == sample.values.len() {
-                                assert!(r.is_ok());
-                                if timestamp.is_some() {
-                                    samples_with_timestamps.push(sample);
-                                } else if let Some(existing_values) = samples_without_timestamps
-                                    .get_mut(&(&sample.locations, &sample.labels))
-                                {
-                                    existing_values
-                                        .iter_mut()
-                                        .zip(sample.values.iter())
-                                        .for_each(|(a, b)| *a = a.saturating_add(*b));
-                                } else {
-                                    samples_without_timestamps.insert(
-                                        (&sample.locations, &sample.labels),
-                                        sample.values.clone(),
-                                    );
-                                }
-                            } else {
-                                assert!(r.is_err());
-                            }
+                            add_sample(
+                                &timestamp,
+                                &sample,
+                                &sample_types,
+                                &mut profile,
+                                &mut samples_with_timestamps,
+                                &mut samples_without_timestamps,
+                            );
                         }
                         Function::AddEndpoint(local_root_span_id, endpoint) => {
                             profile

From 5c8c354a19e515d2e22750beff5d9a05a8c45920 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Wed, 29 May 2024 13:21:25 -0400
Subject: [PATCH 36/54] clippy

---
 profiling/src/internal/profile.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index ad89398f2..8e08c89e2 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -748,9 +748,9 @@ mod api_tests {
                 > = HashMap::new();
                 for (timestamp, sample) in samples {
                     add_sample(
-                        &timestamp,
-                        &sample,
-                        &expected_sample_types,
+                        timestamp,
+                        sample,
+                        expected_sample_types,
                         &mut expected_profile,
                         &mut samples_with_timestamps,
                         &mut samples_without_timestamps,
@@ -926,9 +926,9 @@ mod api_tests {
                     match operation {
                         Function::AddSample(timestamp, sample) => {
                             add_sample(
-                                &timestamp,
-                                &sample,
-                                &sample_types,
+                                timestamp,
+                                sample,
+                                sample_types,
                                 &mut profile,
                                 &mut samples_with_timestamps,
                                 &mut samples_without_timestamps,

From a94c1261e14e004aaaf395a723adf7fd82a8a1f6 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Wed, 29 May 2024 14:12:50 -0400
Subject: [PATCH 37/54] narrow search space by not using times

---
 profiling/src/internal/profile.rs | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 8e08c89e2..b8f98a6e9 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -772,8 +772,8 @@ mod api_tests {
         let sample_length_gen = 1..=64usize;
 
         bolero::check!()
-            .with_generator((sample_length_gen, i64::gen(), u64::gen()))
-            .and_then(|(sample_len, start_time_ns, duration_ns)| {
+            .with_generator(sample_length_gen)
+            .and_then(|sample_len| {
                 let sample_types = Vec::<owned_types::ValueType>::gen().with().len(sample_len);
 
                 let timestamps = Option::<Timestamp>::gen();
@@ -790,16 +790,12 @@ mod api_tests {
                 )>::gen()
                 .with()
                 .values((timestamps, locations, values, labels));
-                (sample_types, samples, start_time_ns, duration_ns)
+                (sample_types, samples)
             })
-            .for_each(|(sample_types, samples, start_time_ns, duration_ns)| {
-                let start_time =
-                    SystemTime::from(chrono::DateTime::from_timestamp_nanos(*start_time_ns));
-                let duration = Duration::from_nanos(*duration_ns);
-                let end_time = start_time + duration;
+            .for_each(|(sample_types, samples)| {
                 let api_sample_types: Vec<_> =
                     sample_types.iter().map(api::ValueType::from).collect();
-                let mut profile = Profile::new(start_time, &api_sample_types, None);
+                let mut profile = Profile::new(SystemTime::now(), &api_sample_types, None);
                 let mut samples_with_timestamps = Vec::new();
                 let mut samples_without_timestamps: HashMap<
                     (&Vec<owned_types::Location>, &Vec<owned_types::Label>),
@@ -841,11 +837,8 @@ mod api_tests {
                             .insert((&sample.locations, &sample.labels), sample.values.clone());
                     }
                 }
-                let encoded = profile
-                    .serialize_into_compressed_pprof(Some(end_time), Some(duration))
-                    .unwrap();
                 let serialized_profile =
-                    pprof::deserialize_compressed_pprof(&encoded.buffer).unwrap();
+                    pprof::roundtrip_to_pprof(profile).expect("Failed to roundtrip to pprof");
 
                 assert_sample_types_eq(&serialized_profile, sample_types);
                 assert_samples_eq(

From 5117532972f387d6f6c48c10e9cdba9a6c927dd3 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Wed, 29 May 2024 16:40:59 -0400
Subject: [PATCH 38/54] reduce range for miri

---
 profiling/src/internal/profile.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index b8f98a6e9..4639dafba 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -769,7 +769,7 @@ mod api_tests {
 
     #[test]
     fn fuzz_add_sample_with_fixed_sample_length() {
-        let sample_length_gen = 1..=64usize;
+        let sample_length_gen = if cfg!(miri) { 1..=8usize } else { 1..=64usize };
 
         bolero::check!()
             .with_generator(sample_length_gen)
@@ -894,7 +894,7 @@ mod api_tests {
 
     #[test]
     fn fuzz_api_function_calls() {
-        let sample_length_gen = 1..=64usize;
+        let sample_length_gen = if cfg!(miri) { 1..=8usize } else { 1..=64usize };
 
         bolero::check!()
             .with_generator(sample_length_gen)

From 41a5debfcb0df483a56a572caeb1de5149b0fa00 Mon Sep 17 00:00:00 2001
From: Levi Morrison <levi.morrison@datadoghq.com>
Date: Thu, 30 May 2024 13:27:19 -0600
Subject: [PATCH 39/54] refactor: move stuff for better diff, convert String to
 Box<str>

---
 profiling/src/internal/owned_types.rs | 50 +++++++++++++--------------
 profiling/src/internal/profile.rs     |  2 +-
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/profiling/src/internal/owned_types.rs b/profiling/src/internal/owned_types.rs
index 8623e6f43..98066363b 100644
--- a/profiling/src/internal/owned_types.rs
+++ b/profiling/src/internal/owned_types.rs
@@ -6,6 +6,29 @@ use bolero_generator::{TypeGeneratorWithParams, ValueGenerator};
 
 use crate::api;
 
+#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
+#[derive(Clone, Debug)]
+pub struct ValueType {
+    pub typ: Box<str>,
+    pub unit: Box<str>,
+}
+
+impl<'a> From<&'a api::ValueType<'a>> for ValueType {
+    #[inline]
+    fn from(value_type: &'a api::ValueType<'a>) -> Self {
+        Self {
+            typ: Box::from(value_type.r#type),
+            unit: Box::from(value_type.unit),
+        }
+    }
+}
+
+impl<'a> From<&'a ValueType> for api::ValueType<'a> {
+    fn from(value: &'a ValueType) -> Self {
+        Self::new(&value.typ, &value.unit)
+    }
+}
+
 #[derive(Clone, Debug, Default, Eq, PartialEq, Hash)]
 #[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
 pub struct Function {
@@ -40,7 +63,7 @@ pub struct Label {
     pub key: Box<str>,
 
     /// At most one of the following must be present
-    pub str: Option<String>,
+    pub str: Option<Box<str>>,
     pub num: i64,
 
     /// Should only be present when num is present.
@@ -158,8 +181,8 @@ impl<'a> From<&'a Mapping> for api::Mapping<'a> {
     }
 }
 
-#[derive(Clone, Debug)]
 #[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
+#[derive(Clone, Debug)]
 pub struct Period {
     pub typ: ValueType,
     pub value: i64,
@@ -232,26 +255,3 @@ impl<'a> From<&'a Sample> for api::Sample<'a> {
         }
     }
 }
-
-#[derive(Clone, Debug)]
-#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
-pub struct ValueType {
-    pub typ: Box<str>,
-    pub unit: Box<str>,
-}
-
-impl<'a> From<&'a api::ValueType<'a>> for ValueType {
-    #[inline]
-    fn from(value_type: &'a api::ValueType<'a>) -> Self {
-        Self {
-            typ: String::from(value_type.r#type).into(),
-            unit: String::from(value_type.unit).into(),
-        }
-    }
-}
-
-impl<'a> From<&'a ValueType> for api::ValueType<'a> {
-    fn from(value: &'a ValueType) -> Self {
-        Self::new(&value.typ, &value.unit)
-    }
-}
diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile.rs
index 4639dafba..6848992df 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile.rs
@@ -654,7 +654,7 @@ mod api_tests {
                 }
 
                 if label.str != 0 {
-                    let str = profile.string_table[label.str as usize].clone();
+                    let str = Box::from(profile.string_table[label.str as usize].as_str());
                     owned_labels.push(owned_types::Label {
                         key,
                         str: Some(str),

From 58c131775d20790acbffd33983c5e2aa38450aa3 Mon Sep 17 00:00:00 2001
From: Levi Morrison <levi.morrison@datadoghq.com>
Date: Thu, 30 May 2024 14:14:05 -0600
Subject: [PATCH 40/54] refactor: move fuzz tests for profile.rs into their own
 file

---
 profiling/src/internal/owned_types.rs         | 257 --------
 profiling/src/internal/owned_types/mod.rs     |  44 ++
 profiling/src/internal/profile/fuzz_tests.rs  | 597 ++++++++++++++++++
 .../internal/{profile.rs => profile/mod.rs}   | 406 +-----------
 4 files changed, 645 insertions(+), 659 deletions(-)
 delete mode 100644 profiling/src/internal/owned_types.rs
 create mode 100644 profiling/src/internal/owned_types/mod.rs
 create mode 100644 profiling/src/internal/profile/fuzz_tests.rs
 rename profiling/src/internal/{profile.rs => profile/mod.rs} (80%)

diff --git a/profiling/src/internal/owned_types.rs b/profiling/src/internal/owned_types.rs
deleted file mode 100644
index 98066363b..000000000
--- a/profiling/src/internal/owned_types.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-// Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
-// SPDX-License-Identifier: Apache-2.0
-
-#[cfg(test)]
-use bolero_generator::{TypeGeneratorWithParams, ValueGenerator};
-
-use crate::api;
-
-#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
-#[derive(Clone, Debug)]
-pub struct ValueType {
-    pub typ: Box<str>,
-    pub unit: Box<str>,
-}
-
-impl<'a> From<&'a api::ValueType<'a>> for ValueType {
-    #[inline]
-    fn from(value_type: &'a api::ValueType<'a>) -> Self {
-        Self {
-            typ: Box::from(value_type.r#type),
-            unit: Box::from(value_type.unit),
-        }
-    }
-}
-
-impl<'a> From<&'a ValueType> for api::ValueType<'a> {
-    fn from(value: &'a ValueType) -> Self {
-        Self::new(&value.typ, &value.unit)
-    }
-}
-
-#[derive(Clone, Debug, Default, Eq, PartialEq, Hash)]
-#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
-pub struct Function {
-    /// Name of the function, in human-readable form if available.
-    pub name: Box<str>,
-
-    /// Name of the function, as identified by the system.
-    /// For instance, it can be a C++ mangled name.
-    pub system_name: Box<str>,
-
-    /// Source file containing the function.
-    pub filename: Box<str>,
-
-    /// Line number in source file.
-    pub start_line: i64,
-}
-
-impl<'a> From<&'a Function> for api::Function<'a> {
-    fn from(value: &'a Function) -> Self {
-        Self {
-            name: &value.name,
-            system_name: &value.system_name,
-            filename: &value.filename,
-            start_line: value.start_line,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
-pub struct Label {
-    pub key: Box<str>,
-
-    /// At most one of the following must be present
-    pub str: Option<Box<str>>,
-    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: Option<Box<str>>,
-}
-
-impl PartialEq for Label {
-    fn eq(&self, other: &Self) -> bool {
-        self.key == other.key
-    }
-}
-
-impl Eq for Label {}
-
-impl std::hash::Hash for Label {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.key.hash(state)
-    }
-}
-
-impl<'a> From<&'a Label> for api::Label<'a> {
-    fn from(value: &'a Label) -> Self {
-        Self {
-            key: &value.key,
-            str: value.str.as_deref(),
-            num: value.num,
-            num_unit: value.num_unit.as_deref(),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
-pub struct Line {
-    /// The corresponding profile.Function for this line.
-    pub function: Function,
-
-    /// Line number in source code.
-    pub line: i64,
-}
-
-impl<'a> From<&'a Line> for api::Line<'a> {
-    fn from(value: &'a Line) -> Self {
-        Self {
-            function: (&value.function).into(),
-            line: value.line,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default, Eq, PartialEq, Hash)]
-#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
-pub struct Location {
-    pub mapping: Mapping,
-    pub function: Function,
-
-    /// The instruction address for this location, if available.  It
-    /// should be within [Mapping.memory_start...Mapping.memory_limit]
-    /// for the corresponding mapping. A non-leaf address may be in the
-    /// middle of a call instruction. It is up to display tools to find
-    /// the beginning of the instruction if necessary.
-    pub address: u64,
-    pub line: i64,
-}
-
-impl<'a> From<&'a Location> for api::Location<'a> {
-    fn from(value: &'a Location) -> Self {
-        Self {
-            mapping: (&value.mapping).into(),
-            function: (&value.function).into(),
-            address: value.address,
-            line: value.line,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default, Eq, PartialEq, Hash)]
-#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
-pub struct Mapping {
-    /// Address at which the binary (or DLL) is loaded into memory.
-    pub memory_start: u64,
-
-    /// The limit of the address range occupied by this mapping.
-    pub memory_limit: u64,
-
-    /// Offset in the binary that corresponds to the first mapped address.
-    pub file_offset: u64,
-
-    /// The object this entry is loaded from.  This can be a filename on
-    /// disk for the main binary and shared libraries, or virtual
-    /// abstractions like "[vdso]".
-    pub filename: Box<str>,
-
-    /// A string that uniquely identifies a particular program version
-    /// with high probability. E.g., for binaries generated by GNU tools,
-    /// it could be the contents of the .note.gnu.build-id field.
-    pub build_id: Box<str>,
-}
-
-impl<'a> From<&'a Mapping> for api::Mapping<'a> {
-    fn from(value: &'a Mapping) -> Self {
-        Self {
-            memory_start: value.memory_start,
-            memory_limit: value.memory_limit,
-            file_offset: value.file_offset,
-            filename: &value.filename,
-            build_id: &value.build_id,
-        }
-    }
-}
-
-#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
-#[derive(Clone, Debug)]
-pub struct Period {
-    pub typ: ValueType,
-    pub value: i64,
-}
-
-impl<'a> From<&'a api::Period<'a>> for Period {
-    #[inline]
-    fn from(period: &'a api::Period<'a>) -> Self {
-        Self {
-            typ: ValueType::from(&period.r#type),
-            value: period.value,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct Sample {
-    /// The leaf is at locations[0].
-    pub locations: Vec<Location>,
-
-    /// 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: Vec<i64>,
-
-    /// label includes additional context for this sample. It can include
-    /// things like a thread id, allocation size, etc
-    pub labels: Vec<Label>,
-}
-
-#[cfg(test)]
-impl bolero_generator::TypeGenerator for Sample {
-    fn generate<D: bolero_generator::Driver>(driver: &mut D) -> Option<Self> {
-        let locations = Vec::<Location>::gen_with().generate(driver)?;
-        let values = Vec::<i64>::gen_with().generate(driver)?;
-        let mut labels = std::collections::HashSet::<Label>::gen_with().generate(driver)?;
-
-        // Ensure that the label has "local root span id" key
-        // Generate non-zero num value for the label
-        let num = i64::gen().generate(driver)?;
-        // zero num is considered as invalid, see Profile::validate_sample_labels
-        if num == 0 {
-            return None;
-        }
-
-        labels.insert(Label {
-            key: "local root span id".into(),
-            str: None,
-            num,
-            num_unit: None,
-        });
-        let labels = labels.into_iter().collect();
-        Some(Self {
-            locations,
-            values,
-            labels,
-        })
-    }
-}
-
-impl<'a> From<&'a Sample> for api::Sample<'a> {
-    fn from(value: &'a Sample) -> Self {
-        Self {
-            locations: value.locations.iter().map(api::Location::from).collect(),
-            values: value.values.clone(),
-            labels: value.labels.iter().map(api::Label::from).collect(),
-        }
-    }
-}
diff --git a/profiling/src/internal/owned_types/mod.rs b/profiling/src/internal/owned_types/mod.rs
new file mode 100644
index 000000000..e667ee299
--- /dev/null
+++ b/profiling/src/internal/owned_types/mod.rs
@@ -0,0 +1,44 @@
+// Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::api;
+
+#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
+#[derive(Clone, Debug)]
+pub struct ValueType {
+    pub typ: Box<str>,
+    pub unit: Box<str>,
+}
+
+impl<'a> From<&'a api::ValueType<'a>> for ValueType {
+    #[inline]
+    fn from(value_type: &'a api::ValueType<'a>) -> Self {
+        Self {
+            typ: Box::from(value_type.r#type),
+            unit: Box::from(value_type.unit),
+        }
+    }
+}
+
+impl<'a> From<&'a ValueType> for api::ValueType<'a> {
+    fn from(value: &'a ValueType) -> Self {
+        Self::new(&value.typ, &value.unit)
+    }
+}
+
+#[cfg_attr(test, derive(bolero_generator::TypeGenerator))]
+#[derive(Clone, Debug)]
+pub struct Period {
+    pub typ: ValueType,
+    pub value: i64,
+}
+
+impl<'a> From<&'a api::Period<'a>> for Period {
+    #[inline]
+    fn from(period: &'a api::Period<'a>) -> Self {
+        Self {
+            typ: ValueType::from(&period.r#type),
+            value: period.value,
+        }
+    }
+}
diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
new file mode 100644
index 000000000..7cf2243dc
--- /dev/null
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -0,0 +1,597 @@
+// Copyright 2024-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use super::*;
+use crate::collections::identifiable::FxIndexMap;
+use crate::internal::{owned_types, Profile, Timestamp};
+use crate::pprof;
+use bolero::TypeGenerator;
+use bolero_generator::{TypeGeneratorWithParams, ValueGenerator};
+use std::collections::{HashMap, HashSet};
+use std::time::SystemTime;
+
+#[derive(Clone, Debug, Default, Eq, PartialEq, Hash, bolero_generator::TypeGenerator)]
+pub struct Function {
+    /// Name of the function, in human-readable form if available.
+    pub name: Box<str>,
+
+    /// Name of the function, as identified by the system.
+    /// For instance, it can be a C++ mangled name.
+    pub system_name: Box<str>,
+
+    /// Source file containing the function.
+    pub filename: Box<str>,
+
+    /// Line number in source file.
+    pub start_line: i64,
+}
+
+impl<'a> From<&'a Function> for api::Function<'a> {
+    fn from(value: &'a Function) -> Self {
+        Self {
+            name: &value.name,
+            system_name: &value.system_name,
+            filename: &value.filename,
+            start_line: value.start_line,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, bolero_generator::TypeGenerator)]
+pub struct Label {
+    pub key: Box<str>,
+
+    /// At most one of the following must be present
+    pub str: Option<Box<str>>,
+    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: Option<Box<str>>,
+}
+
+impl<'a> From<&'a Label> for api::Label<'a> {
+    fn from(value: &'a Label) -> Self {
+        Self {
+            key: &value.key,
+            str: value.str.as_deref(),
+            num: value.num,
+            num_unit: value.num_unit.as_deref(),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, bolero_generator::TypeGenerator)]
+pub struct Line {
+    /// The corresponding profile.Function for this line.
+    pub function: Function,
+
+    /// Line number in source code.
+    pub line: i64,
+}
+
+impl<'a> From<&'a Line> for api::Line<'a> {
+    fn from(value: &'a Line) -> Self {
+        Self {
+            function: (&value.function).into(),
+            line: value.line,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq, Hash, bolero_generator::TypeGenerator)]
+pub struct Location {
+    pub mapping: Mapping,
+    pub function: Function,
+
+    /// The instruction address for this location, if available.  It
+    /// should be within [Mapping.memory_start...Mapping.memory_limit]
+    /// for the corresponding mapping. A non-leaf address may be in the
+    /// middle of a call instruction. It is up to display tools to find
+    /// the beginning of the instruction if necessary.
+    pub address: u64,
+    pub line: i64,
+}
+
+impl<'a> From<&'a Location> for api::Location<'a> {
+    fn from(value: &'a Location) -> Self {
+        Self {
+            mapping: (&value.mapping).into(),
+            function: (&value.function).into(),
+            address: value.address,
+            line: value.line,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq, Hash, bolero_generator::TypeGenerator)]
+pub struct Mapping {
+    /// Address at which the binary (or DLL) is loaded into memory.
+    pub memory_start: u64,
+
+    /// The limit of the address range occupied by this mapping.
+    pub memory_limit: u64,
+
+    /// Offset in the binary that corresponds to the first mapped address.
+    pub file_offset: u64,
+
+    /// The object this entry is loaded from.  This can be a filename on
+    /// disk for the main binary and shared libraries, or virtual
+    /// abstractions like "[vdso]".
+    pub filename: Box<str>,
+
+    /// A string that uniquely identifies a particular program version
+    /// with high probability. E.g., for binaries generated by GNU tools,
+    /// it could be the contents of the .note.gnu.build-id field.
+    pub build_id: Box<str>,
+}
+
+impl<'a> From<&'a Mapping> for api::Mapping<'a> {
+    fn from(value: &'a Mapping) -> Self {
+        Self {
+            memory_start: value.memory_start,
+            memory_limit: value.memory_limit,
+            file_offset: value.file_offset,
+            filename: &value.filename,
+            build_id: &value.build_id,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Sample {
+    /// The leaf is at locations[0].
+    pub locations: Vec<Location>,
+
+    /// 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: Vec<i64>,
+
+    /// label includes additional context for this sample. It can include
+    /// things like a thread id, allocation size, etc
+    pub labels: Vec<Label>,
+}
+
+impl<'a> From<&'a Sample> for api::Sample<'a> {
+    fn from(value: &'a Sample) -> Self {
+        Self {
+            locations: value.locations.iter().map(api::Location::from).collect(),
+            values: value.values.clone(),
+            labels: value.labels.iter().map(api::Label::from).collect(),
+        }
+    }
+}
+
+/// PartialEq and Hash work on just the key to avoid getting duplicate
+/// label keys.
+impl PartialEq for Label {
+    fn eq(&self, other: &Self) -> bool {
+        self.key == other.key
+    }
+}
+
+impl Eq for Label {}
+
+/// PartialEq and Hash work on just the key to avoid getting duplicate
+/// label keys.
+impl std::hash::Hash for Label {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.key.hash(state)
+    }
+}
+impl bolero_generator::TypeGenerator for Sample {
+    fn generate<D: bolero_generator::Driver>(driver: &mut D) -> Option<Self> {
+        let locations = Vec::<Location>::gen_with().generate(driver)?;
+        let values = Vec::<i64>::gen_with().generate(driver)?;
+        let mut labels = std::collections::HashSet::<Label>::gen_with().generate(driver)?;
+
+        // Ensure that the label has "local root span id" key
+        // Generate non-zero num value for the label
+        let num = i64::gen().generate(driver)?;
+        // zero num is considered as invalid, see Profile::validate_sample_labels
+        if num == 0 {
+            return None;
+        }
+
+        labels.insert(Label {
+            key: "local root span id".into(),
+            str: None,
+            num,
+            num_unit: None,
+        });
+        let labels = labels.into_iter().collect();
+        Some(Self {
+            locations,
+            values,
+            labels,
+        })
+    }
+}
+
+fn assert_sample_types_eq(
+    profile: &pprof::Profile,
+    expected_sample_types: &[owned_types::ValueType],
+) {
+    assert_eq!(
+        profile.sample_types.len(),
+        expected_sample_types.len(),
+        "Sample types length mismatch"
+    );
+    for (typ, expected_typ) in profile
+        .sample_types
+        .iter()
+        .zip(expected_sample_types.iter())
+    {
+        assert_eq!(
+            *profile.string_table[typ.r#type as usize],
+            *expected_typ.r#typ
+        );
+        assert_eq!(*profile.string_table[typ.unit as usize], *expected_typ.unit);
+    }
+}
+
+fn assert_samples_eq(
+    profile: &pprof::Profile,
+    samples_with_timestamps: &[&Sample],
+    samples_without_timestamps: &HashMap<(&Vec<Location>, &Vec<Label>), Vec<i64>>,
+    endpoint_mappings: &FxIndexMap<u64, &String>,
+) {
+    assert_eq!(
+        profile.samples.len(),
+        samples_with_timestamps.len() + samples_without_timestamps.len(),
+        "Samples length mismatch"
+    );
+
+    let mut expected_timestamped_samples = samples_with_timestamps.iter();
+
+    for sample in profile.samples.iter() {
+        // Recreate owned_locations from vector of pprof::Location
+        let mut owned_locations = Vec::new();
+        for loc_id in sample.location_ids.iter() {
+            let location = &profile.locations[*loc_id as usize - 1];
+            let mapping = &profile.mappings[location.mapping_id as usize - 1];
+            assert!(location.lines.len() == 1);
+            let line = location.lines[0];
+            let function = profile.functions[line.function_id as usize - 1];
+            assert!(!location.is_folded);
+
+            let owned_location = Location {
+                mapping: Mapping {
+                    memory_start: mapping.memory_start,
+                    memory_limit: mapping.memory_limit,
+                    file_offset: mapping.file_offset,
+                    filename: profile.string_table[mapping.filename as usize]
+                        .clone()
+                        .into_boxed_str(),
+                    build_id: profile.string_table[mapping.build_id as usize]
+                        .clone()
+                        .into_boxed_str(),
+                },
+                function: Function {
+                    name: profile.string_table[function.name as usize]
+                        .clone()
+                        .into_boxed_str(),
+                    system_name: profile.string_table[function.system_name as usize]
+                        .clone()
+                        .into_boxed_str(),
+                    filename: profile.string_table[function.filename as usize]
+                        .clone()
+                        .into_boxed_str(),
+                    start_line: function.start_line,
+                },
+                address: location.address,
+                line: line.line,
+            };
+
+            owned_locations.push(owned_location);
+        }
+
+        // Recreate owned_labels from vector of pprof::Label
+        let mut owned_labels = Vec::new();
+        for label in sample.labels.iter() {
+            let key = profile.string_table[label.key as usize]
+                .clone()
+                .into_boxed_str();
+
+            if *key == *"end_timestamp_ns" {
+                // TODO: Check end timestamp label
+                continue;
+            } else if *key == *"trace endpoint" {
+                let actual_str = &profile.string_table[label.str as usize];
+
+                let prev_label: &Label = owned_labels
+                    .last()
+                    .expect("Previous label to exist for endpoint label");
+                let num = prev_label.num as u64;
+                let expected_str = endpoint_mappings
+                    .get(&num)
+                    .expect("Endpoint mapping to exist");
+
+                assert_eq!(actual_str, *expected_str);
+                continue;
+            }
+
+            if label.str != 0 {
+                let str = Box::from(profile.string_table[label.str as usize].as_str());
+                owned_labels.push(Label {
+                    key,
+                    str: Some(str),
+                    num: 0,
+                    num_unit: None,
+                });
+            } else {
+                let num = label.num;
+                let num_unit = if label.num_unit != 0 {
+                    Some(
+                        profile.string_table[label.num_unit as usize]
+                            .clone()
+                            .into_boxed_str(),
+                    )
+                } else {
+                    None
+                };
+                owned_labels.push(Label {
+                    key,
+                    str: None,
+                    num,
+                    num_unit,
+                });
+            }
+        }
+
+        if let Some(expected_sample) = expected_timestamped_samples.next() {
+            assert_eq!(owned_locations, expected_sample.locations);
+            assert_eq!(sample.values, expected_sample.values);
+            assert_eq!(owned_labels, expected_sample.labels);
+        } else {
+            let key = (&owned_locations, &owned_labels);
+            let expected_values = samples_without_timestamps
+                .get(&key)
+                .expect("Value not found for an aggregated sample");
+            assert_eq!(&sample.values, expected_values);
+        }
+    }
+}
+
+fn add_sample<'a>(
+    timestamp: &Option<Timestamp>,
+    sample: &'a Sample,
+    expected_sample_types: &[owned_types::ValueType],
+    profile: &mut Profile,
+    samples_with_timestamps: &mut Vec<&'a Sample>,
+    samples_without_timestamps: &mut HashMap<(&'a Vec<Location>, &'a Vec<Label>), Vec<i64>>,
+) {
+    let r = profile.add_sample(sample.into(), *timestamp);
+    if expected_sample_types.len() == sample.values.len() {
+        assert!(r.is_ok());
+        if timestamp.is_some() {
+            samples_with_timestamps.push(sample);
+        } else if let Some(existing_values) =
+            samples_without_timestamps.get_mut(&(&sample.locations, &sample.labels))
+        {
+            existing_values
+                .iter_mut()
+                .zip(sample.values.iter())
+                .for_each(|(a, b)| *a = a.saturating_add(*b));
+        } else {
+            samples_without_timestamps
+                .insert((&sample.locations, &sample.labels), sample.values.clone());
+        }
+    } else {
+        assert!(r.is_err());
+    }
+}
+
+/// Fuzzes adding a bunch of samples to the profile.
+#[test]
+fn fuzz_add_sample() {
+    bolero::check!()
+        .with_generator((
+            Vec::<owned_types::ValueType>::gen(),
+            Vec::<(Option<Timestamp>, Sample)>::gen(),
+        ))
+        .for_each(|(expected_sample_types, samples)| {
+            let sample_types: Vec<_> = expected_sample_types
+                .iter()
+                .map(api::ValueType::from)
+                .collect();
+            let mut expected_profile = Profile::new(SystemTime::now(), &sample_types, None);
+            let mut samples_with_timestamps = Vec::new();
+            let mut samples_without_timestamps: HashMap<(&Vec<Location>, &Vec<Label>), Vec<i64>> =
+                HashMap::new();
+            for (timestamp, sample) in samples {
+                add_sample(
+                    timestamp,
+                    sample,
+                    expected_sample_types,
+                    &mut expected_profile,
+                    &mut samples_with_timestamps,
+                    &mut samples_without_timestamps,
+                );
+            }
+            let profile = pprof::roundtrip_to_pprof(expected_profile).unwrap();
+            assert_sample_types_eq(&profile, expected_sample_types);
+            assert_samples_eq(
+                &profile,
+                &samples_with_timestamps,
+                &samples_without_timestamps,
+                &FxIndexMap::default(),
+            );
+        })
+}
+
+#[test]
+fn fuzz_add_sample_with_fixed_sample_length() {
+    let sample_length_gen = if cfg!(miri) { 1..=8usize } else { 1..=64usize };
+
+    bolero::check!()
+        .with_generator(sample_length_gen)
+        .and_then(|sample_len| {
+            let sample_types = Vec::<owned_types::ValueType>::gen().with().len(sample_len);
+
+            let timestamps = Option::<Timestamp>::gen();
+            let locations = Vec::<Location>::gen();
+            let values = Vec::<i64>::gen().with().len(sample_len);
+            // Generate labels with unique keys
+            let labels = HashSet::<Label>::gen();
+
+            let samples =
+                Vec::<(Option<Timestamp>, Vec<Location>, Vec<i64>, HashSet<Label>)>::gen()
+                    .with()
+                    .values((timestamps, locations, values, labels));
+            (sample_types, samples)
+        })
+        .for_each(|(sample_types, samples)| {
+            let api_sample_types: Vec<_> = sample_types.iter().map(api::ValueType::from).collect();
+            let mut profile = Profile::new(SystemTime::now(), &api_sample_types, None);
+            let mut samples_with_timestamps = Vec::new();
+            let mut samples_without_timestamps: HashMap<(&Vec<Location>, &Vec<Label>), Vec<i64>> =
+                HashMap::new();
+
+            let samples: Vec<(&Option<Timestamp>, Sample)> = samples
+                .iter()
+                .map(|(timestamp, locations, values, labels)| {
+                    (
+                        timestamp,
+                        Sample {
+                            locations: locations.clone(),
+                            values: values.clone(),
+                            labels: labels.clone().into_iter().collect::<Vec<Label>>(),
+                        },
+                    )
+                })
+                .collect();
+
+            for (timestamp, sample) in samples.iter() {
+                profile
+                    .add_sample(sample.into(), **timestamp)
+                    .expect("Failed to add sample");
+                if timestamp.is_some() {
+                    samples_with_timestamps.push(sample);
+                } else if let Some(existing_values) =
+                    samples_without_timestamps.get_mut(&(&sample.locations, &sample.labels))
+                {
+                    existing_values
+                        .iter_mut()
+                        .zip(sample.values.iter())
+                        .for_each(|(a, b)| *a = a.saturating_add(*b));
+                } else {
+                    samples_without_timestamps
+                        .insert((&sample.locations, &sample.labels), sample.values.clone());
+                }
+            }
+            let serialized_profile =
+                pprof::roundtrip_to_pprof(profile).expect("Failed to roundtrip to pprof");
+
+            assert_sample_types_eq(&serialized_profile, sample_types);
+            assert_samples_eq(
+                &serialized_profile,
+                &samples_with_timestamps,
+                &samples_without_timestamps,
+                &FxIndexMap::default(),
+            );
+        });
+}
+
+#[test]
+fn fuzz_add_endpoint() {
+    bolero::check!()
+        .with_type::<Vec<(u64, String)>>()
+        .for_each(|endpoints| {
+            let mut profile = Profile::new(SystemTime::now(), &[], None);
+            for (local_root_span_id, endpoint) in endpoints {
+                profile
+                    .add_endpoint(*local_root_span_id, endpoint.into())
+                    .expect("add_endpoint to succeed");
+            }
+            pprof::roundtrip_to_pprof(profile).expect("roundtrip_to_pprof to succeed");
+        });
+}
+
+#[test]
+fn fuzz_add_endpoint_count() {
+    bolero::check!()
+        .with_type::<Vec<(String, i64)>>()
+        .for_each(|endpoint_counts| {
+            let mut profile = Profile::new(SystemTime::now(), &[], None);
+            for (endpoint, count) in endpoint_counts {
+                profile
+                    .add_endpoint_count(endpoint.into(), *count)
+                    .expect("add_endpoint_count to succeed");
+            }
+            pprof::roundtrip_to_pprof(profile).expect("roundtrip_to_pprof to succeed");
+        });
+}
+
+#[derive(Debug, TypeGenerator)]
+enum Operation {
+    AddSample(Option<Timestamp>, Sample),
+    AddEndpoint(u64, String),
+}
+
+#[derive(Debug, TypeGenerator)]
+struct ApiFunctionCalls {
+    sample_types: Vec<owned_types::ValueType>,
+    operations: Vec<Operation>,
+}
+
+#[test]
+fn fuzz_api_function_calls() {
+    let sample_length_gen = if cfg!(miri) { 1..=8usize } else { 1..=64usize };
+
+    bolero::check!()
+        .with_generator(sample_length_gen)
+        .and_then(|sample_len| {
+            let sample_types = Vec::<owned_types::ValueType>::gen().with().len(sample_len);
+            let operations = Vec::<Operation>::gen();
+
+            (sample_types, operations)
+        })
+        .for_each(|(sample_types, operations)| {
+            let api_sample_types: Vec<_> = sample_types.iter().map(api::ValueType::from).collect();
+            let mut profile = Profile::new(SystemTime::now(), &api_sample_types, None);
+            let mut samples_with_timestamps: Vec<&Sample> = Vec::new();
+            let mut samples_without_timestamps: HashMap<(&Vec<Location>, &Vec<Label>), Vec<i64>> =
+                HashMap::new();
+            let mut endpoint_mappings: FxIndexMap<u64, &String> = FxIndexMap::default();
+
+            for operation in operations {
+                match operation {
+                    Operation::AddSample(timestamp, sample) => {
+                        add_sample(
+                            timestamp,
+                            sample,
+                            sample_types,
+                            &mut profile,
+                            &mut samples_with_timestamps,
+                            &mut samples_without_timestamps,
+                        );
+                    }
+                    Operation::AddEndpoint(local_root_span_id, endpoint) => {
+                        profile
+                            .add_endpoint(*local_root_span_id, endpoint.into())
+                            .expect("add_endpoint to succeed");
+                        endpoint_mappings.insert(*local_root_span_id, endpoint);
+                    }
+                }
+            }
+
+            let pprof_profile = pprof::roundtrip_to_pprof(profile).unwrap();
+            assert_sample_types_eq(&pprof_profile, sample_types);
+            assert_samples_eq(
+                &pprof_profile,
+                &samples_with_timestamps,
+                &samples_without_timestamps,
+                &endpoint_mappings,
+            );
+        })
+}
diff --git a/profiling/src/internal/profile.rs b/profiling/src/internal/profile/mod.rs
similarity index 80%
rename from profiling/src/internal/profile.rs
rename to profiling/src/internal/profile/mod.rs
index 6848992df..d61929cd3 100644
--- a/profiling/src/internal/profile.rs
+++ b/profiling/src/internal/profile/mod.rs
@@ -1,6 +1,9 @@
 // Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
+#[cfg(test)]
+mod fuzz_tests;
+
 use self::api::UpscalingInfo;
 use super::*;
 use crate::api;
@@ -544,408 +547,7 @@ impl Profile {
 #[cfg(test)]
 mod api_tests {
     use super::*;
-    use bolero::TypeGenerator;
-    use std::collections::{HashMap, HashSet};
-
-    fn assert_sample_types_eq(
-        profile: &pprof::Profile,
-        expected_sample_types: &[owned_types::ValueType],
-    ) {
-        assert_eq!(
-            profile.sample_types.len(),
-            expected_sample_types.len(),
-            "Sample types length mismatch"
-        );
-        for (typ, expected_typ) in profile
-            .sample_types
-            .iter()
-            .zip(expected_sample_types.iter())
-        {
-            assert_eq!(
-                *profile.string_table[typ.r#type as usize],
-                *expected_typ.r#typ
-            );
-            assert_eq!(*profile.string_table[typ.unit as usize], *expected_typ.unit);
-        }
-    }
-
-    fn assert_samples_eq(
-        profile: &pprof::Profile,
-        samples_with_timestamps: &[&owned_types::Sample],
-        samples_without_timestamps: &HashMap<
-            (&Vec<owned_types::Location>, &Vec<owned_types::Label>),
-            Vec<i64>,
-        >,
-        endpoint_mappings: &FxIndexMap<u64, &String>,
-    ) {
-        assert_eq!(
-            profile.samples.len(),
-            samples_with_timestamps.len() + samples_without_timestamps.len(),
-            "Samples length mismatch"
-        );
-
-        let mut expected_timestamped_samples = samples_with_timestamps.iter();
-
-        for sample in profile.samples.iter() {
-            // Recreate owned_locations from vector of pprof::Location
-            let mut owned_locations = Vec::new();
-            for loc_id in sample.location_ids.iter() {
-                let location = &profile.locations[*loc_id as usize - 1];
-                let mapping = &profile.mappings[location.mapping_id as usize - 1];
-                assert!(location.lines.len() == 1);
-                let line = location.lines[0];
-                let function = profile.functions[line.function_id as usize - 1];
-                assert!(!location.is_folded);
-
-                let owned_location = owned_types::Location {
-                    mapping: owned_types::Mapping {
-                        memory_start: mapping.memory_start,
-                        memory_limit: mapping.memory_limit,
-                        file_offset: mapping.file_offset,
-                        filename: profile.string_table[mapping.filename as usize]
-                            .clone()
-                            .into_boxed_str(),
-                        build_id: profile.string_table[mapping.build_id as usize]
-                            .clone()
-                            .into_boxed_str(),
-                    },
-                    function: owned_types::Function {
-                        name: profile.string_table[function.name as usize]
-                            .clone()
-                            .into_boxed_str(),
-                        system_name: profile.string_table[function.system_name as usize]
-                            .clone()
-                            .into_boxed_str(),
-                        filename: profile.string_table[function.filename as usize]
-                            .clone()
-                            .into_boxed_str(),
-                        start_line: function.start_line,
-                    },
-                    address: location.address,
-                    line: line.line,
-                };
-
-                owned_locations.push(owned_location);
-            }
-
-            // Recreate owned_labels from vector of pprof::Label
-            let mut owned_labels = Vec::new();
-            for label in sample.labels.iter() {
-                let key = profile.string_table[label.key as usize]
-                    .clone()
-                    .into_boxed_str();
-
-                if *key == *"end_timestamp_ns" {
-                    // TODO: Check end timestamp label
-                    continue;
-                } else if *key == *"trace endpoint" {
-                    let actual_str = &profile.string_table[label.str as usize];
-
-                    let prev_label: &owned_types::Label = owned_labels
-                        .last()
-                        .expect("Previous label to exist for endpoint label");
-                    let num = prev_label.num as u64;
-                    let expected_str = endpoint_mappings
-                        .get(&num)
-                        .expect("Endpoint mapping to exist");
-
-                    assert_eq!(actual_str, *expected_str);
-                    continue;
-                }
-
-                if label.str != 0 {
-                    let str = Box::from(profile.string_table[label.str as usize].as_str());
-                    owned_labels.push(owned_types::Label {
-                        key,
-                        str: Some(str),
-                        num: 0,
-                        num_unit: None,
-                    });
-                } else {
-                    let num = label.num;
-                    let num_unit = if label.num_unit != 0 {
-                        Some(
-                            profile.string_table[label.num_unit as usize]
-                                .clone()
-                                .into_boxed_str(),
-                        )
-                    } else {
-                        None
-                    };
-                    owned_labels.push(owned_types::Label {
-                        key,
-                        str: None,
-                        num,
-                        num_unit,
-                    });
-                }
-            }
-
-            if let Some(expected_sample) = expected_timestamped_samples.next() {
-                assert_eq!(owned_locations, expected_sample.locations);
-                assert_eq!(sample.values, expected_sample.values);
-                assert_eq!(owned_labels, expected_sample.labels);
-            } else {
-                let key = (&owned_locations, &owned_labels);
-                let expected_values = samples_without_timestamps
-                    .get(&key)
-                    .expect("Value not found for an aggregated sample");
-                assert_eq!(&sample.values, expected_values);
-            }
-        }
-    }
-
-    fn add_sample<'a>(
-        timestamp: &Option<Timestamp>,
-        sample: &'a owned_types::Sample,
-        expected_sample_types: &[owned_types::ValueType],
-        profile: &mut Profile,
-        samples_with_timestamps: &mut Vec<&'a owned_types::Sample>,
-        samples_without_timestamps: &mut HashMap<
-            (&'a Vec<owned_types::Location>, &'a Vec<owned_types::Label>),
-            Vec<i64>,
-        >,
-    ) {
-        let r = profile.add_sample(sample.into(), *timestamp);
-        if expected_sample_types.len() == sample.values.len() {
-            assert!(r.is_ok());
-            if timestamp.is_some() {
-                samples_with_timestamps.push(sample);
-            } else if let Some(existing_values) =
-                samples_without_timestamps.get_mut(&(&sample.locations, &sample.labels))
-            {
-                existing_values
-                    .iter_mut()
-                    .zip(sample.values.iter())
-                    .for_each(|(a, b)| *a = a.saturating_add(*b));
-            } else {
-                samples_without_timestamps
-                    .insert((&sample.locations, &sample.labels), sample.values.clone());
-            }
-        } else {
-            assert!(r.is_err());
-        }
-    }
-
-    /// Fuzzes adding a bunch of samples to the profile.
-    #[test]
-    fn fuzz_add_sample() {
-        bolero::check!()
-            .with_generator((
-                Vec::<owned_types::ValueType>::gen(),
-                Vec::<(Option<Timestamp>, owned_types::Sample)>::gen(),
-            ))
-            .for_each(|(expected_sample_types, samples)| {
-                let sample_types: Vec<_> = expected_sample_types
-                    .iter()
-                    .map(api::ValueType::from)
-                    .collect();
-                let mut expected_profile = Profile::new(SystemTime::now(), &sample_types, None);
-                let mut samples_with_timestamps = Vec::new();
-                let mut samples_without_timestamps: HashMap<
-                    (&Vec<owned_types::Location>, &Vec<owned_types::Label>),
-                    Vec<i64>,
-                > = HashMap::new();
-                for (timestamp, sample) in samples {
-                    add_sample(
-                        timestamp,
-                        sample,
-                        expected_sample_types,
-                        &mut expected_profile,
-                        &mut samples_with_timestamps,
-                        &mut samples_without_timestamps,
-                    );
-                }
-                let profile = pprof::roundtrip_to_pprof(expected_profile).unwrap();
-                assert_sample_types_eq(&profile, expected_sample_types);
-                assert_samples_eq(
-                    &profile,
-                    &samples_with_timestamps,
-                    &samples_without_timestamps,
-                    &FxIndexMap::default(),
-                );
-            })
-    }
-
-    #[test]
-    fn fuzz_add_sample_with_fixed_sample_length() {
-        let sample_length_gen = if cfg!(miri) { 1..=8usize } else { 1..=64usize };
-
-        bolero::check!()
-            .with_generator(sample_length_gen)
-            .and_then(|sample_len| {
-                let sample_types = Vec::<owned_types::ValueType>::gen().with().len(sample_len);
-
-                let timestamps = Option::<Timestamp>::gen();
-                let locations = Vec::<owned_types::Location>::gen();
-                let values = Vec::<i64>::gen().with().len(sample_len);
-                // Generate labels with unique keys
-                let labels = HashSet::<owned_types::Label>::gen();
-
-                let samples = Vec::<(
-                    Option<Timestamp>,
-                    Vec<owned_types::Location>,
-                    Vec<i64>,
-                    HashSet<owned_types::Label>,
-                )>::gen()
-                .with()
-                .values((timestamps, locations, values, labels));
-                (sample_types, samples)
-            })
-            .for_each(|(sample_types, samples)| {
-                let api_sample_types: Vec<_> =
-                    sample_types.iter().map(api::ValueType::from).collect();
-                let mut profile = Profile::new(SystemTime::now(), &api_sample_types, None);
-                let mut samples_with_timestamps = Vec::new();
-                let mut samples_without_timestamps: HashMap<
-                    (&Vec<owned_types::Location>, &Vec<owned_types::Label>),
-                    Vec<i64>,
-                > = HashMap::new();
-
-                let samples: Vec<(&Option<Timestamp>, owned_types::Sample)> = samples
-                    .iter()
-                    .map(|(timestamp, locations, values, labels)| {
-                        (
-                            timestamp,
-                            owned_types::Sample {
-                                locations: locations.clone(),
-                                values: values.clone(),
-                                labels: labels
-                                    .clone()
-                                    .into_iter()
-                                    .collect::<Vec<owned_types::Label>>(),
-                            },
-                        )
-                    })
-                    .collect();
-
-                for (timestamp, sample) in samples.iter() {
-                    profile
-                        .add_sample(sample.into(), **timestamp)
-                        .expect("Failed to add sample");
-                    if timestamp.is_some() {
-                        samples_with_timestamps.push(sample);
-                    } else if let Some(existing_values) =
-                        samples_without_timestamps.get_mut(&(&sample.locations, &sample.labels))
-                    {
-                        existing_values
-                            .iter_mut()
-                            .zip(sample.values.iter())
-                            .for_each(|(a, b)| *a = a.saturating_add(*b));
-                    } else {
-                        samples_without_timestamps
-                            .insert((&sample.locations, &sample.labels), sample.values.clone());
-                    }
-                }
-                let serialized_profile =
-                    pprof::roundtrip_to_pprof(profile).expect("Failed to roundtrip to pprof");
-
-                assert_sample_types_eq(&serialized_profile, sample_types);
-                assert_samples_eq(
-                    &serialized_profile,
-                    &samples_with_timestamps,
-                    &samples_without_timestamps,
-                    &FxIndexMap::default(),
-                );
-            });
-    }
-
-    #[test]
-    fn fuzz_add_endpoint() {
-        bolero::check!()
-            .with_type::<Vec<(u64, String)>>()
-            .for_each(|endpoints| {
-                let mut profile = Profile::new(SystemTime::now(), &[], None);
-                for (local_root_span_id, endpoint) in endpoints {
-                    profile
-                        .add_endpoint(*local_root_span_id, endpoint.into())
-                        .expect("add_endpoint to succeed");
-                }
-                pprof::roundtrip_to_pprof(profile).expect("roundtrip_to_pprof to succeed");
-            });
-    }
-
-    #[test]
-    fn fuzz_add_endpoint_count() {
-        bolero::check!()
-            .with_type::<Vec<(String, i64)>>()
-            .for_each(|endpoint_counts| {
-                let mut profile = Profile::new(SystemTime::now(), &[], None);
-                for (endpoint, count) in endpoint_counts {
-                    profile
-                        .add_endpoint_count(endpoint.into(), *count)
-                        .expect("add_endpoint_count to succeed");
-                }
-                pprof::roundtrip_to_pprof(profile).expect("roundtrip_to_pprof to succeed");
-            });
-    }
-
-    #[derive(Debug, TypeGenerator)]
-    enum Function {
-        AddSample(Option<Timestamp>, owned_types::Sample),
-        AddEndpoint(u64, String),
-    }
-
-    #[derive(Debug, TypeGenerator)]
-    struct ApiFunctionCalls {
-        sample_types: Vec<owned_types::ValueType>,
-        operations: Vec<Function>,
-    }
-
-    #[test]
-    fn fuzz_api_function_calls() {
-        let sample_length_gen = if cfg!(miri) { 1..=8usize } else { 1..=64usize };
-
-        bolero::check!()
-            .with_generator(sample_length_gen)
-            .and_then(|sample_len| {
-                let sample_types = Vec::<owned_types::ValueType>::gen().with().len(sample_len);
-                let operations = Vec::<Function>::gen();
-
-                (sample_types, operations)
-            })
-            .for_each(|(sample_types, operations)| {
-                let api_sample_types: Vec<_> =
-                    sample_types.iter().map(api::ValueType::from).collect();
-                let mut profile = Profile::new(SystemTime::now(), &api_sample_types, None);
-                let mut samples_with_timestamps: Vec<&owned_types::Sample> = Vec::new();
-                let mut samples_without_timestamps: HashMap<
-                    (&Vec<owned_types::Location>, &Vec<owned_types::Label>),
-                    Vec<i64>,
-                > = HashMap::new();
-                let mut endpoint_mappings: FxIndexMap<u64, &String> = FxIndexMap::default();
-
-                for operation in operations {
-                    match operation {
-                        Function::AddSample(timestamp, sample) => {
-                            add_sample(
-                                timestamp,
-                                sample,
-                                sample_types,
-                                &mut profile,
-                                &mut samples_with_timestamps,
-                                &mut samples_without_timestamps,
-                            );
-                        }
-                        Function::AddEndpoint(local_root_span_id, endpoint) => {
-                            profile
-                                .add_endpoint(*local_root_span_id, endpoint.into())
-                                .expect("add_endpoint to succeed");
-                            endpoint_mappings.insert(*local_root_span_id, endpoint);
-                        }
-                    }
-                }
-
-                let pprof_profile = pprof::roundtrip_to_pprof(profile).unwrap();
-                assert_sample_types_eq(&pprof_profile, sample_types);
-                assert_samples_eq(
-                    &pprof_profile,
-                    &samples_with_timestamps,
-                    &samples_without_timestamps,
-                    &endpoint_mappings,
-                );
-            })
-    }
+    use std::collections::HashMap;
 
     #[test]
     fn interning() {

From ce4b45358cbce089136b060cedc3ac30f878ca23 Mon Sep 17 00:00:00 2001
From: Levi Morrison <levi.morrison@datadoghq.com>
Date: Fri, 31 May 2024 05:39:25 -0600
Subject: [PATCH 41/54] refactor: simplify derives, rename method

---
 profiling/src/internal/profile/fuzz_tests.rs | 20 ++++++++++----------
 profiling/src/internal/profile/mod.rs        |  1 -
 2 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
index 7cf2243dc..41df2c757 100644
--- a/profiling/src/internal/profile/fuzz_tests.rs
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -10,7 +10,7 @@ use bolero_generator::{TypeGeneratorWithParams, ValueGenerator};
 use std::collections::{HashMap, HashSet};
 use std::time::SystemTime;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Hash, bolero_generator::TypeGenerator)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Hash, TypeGenerator)]
 pub struct Function {
     /// Name of the function, in human-readable form if available.
     pub name: Box<str>,
@@ -37,7 +37,7 @@ impl<'a> From<&'a Function> for api::Function<'a> {
     }
 }
 
-#[derive(Clone, Debug, Default, bolero_generator::TypeGenerator)]
+#[derive(Clone, Debug, Default, TypeGenerator)]
 pub struct Label {
     pub key: Box<str>,
 
@@ -66,7 +66,7 @@ impl<'a> From<&'a Label> for api::Label<'a> {
     }
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, bolero_generator::TypeGenerator)]
+#[derive(Clone, Debug, Eq, PartialEq, TypeGenerator)]
 pub struct Line {
     /// The corresponding profile.Function for this line.
     pub function: Function,
@@ -84,7 +84,7 @@ impl<'a> From<&'a Line> for api::Line<'a> {
     }
 }
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Hash, bolero_generator::TypeGenerator)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Hash, TypeGenerator)]
 pub struct Location {
     pub mapping: Mapping,
     pub function: Function,
@@ -109,7 +109,7 @@ impl<'a> From<&'a Location> for api::Location<'a> {
     }
 }
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Hash, bolero_generator::TypeGenerator)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Hash, TypeGenerator)]
 pub struct Mapping {
     /// Address at which the binary (or DLL) is loaded into memory.
     pub memory_start: u64,
@@ -188,7 +188,7 @@ impl std::hash::Hash for Label {
         self.key.hash(state)
     }
 }
-impl bolero_generator::TypeGenerator for Sample {
+impl TypeGenerator for Sample {
     fn generate<D: bolero_generator::Driver>(driver: &mut D) -> Option<Self> {
         let locations = Vec::<Location>::gen_with().generate(driver)?;
         let values = Vec::<i64>::gen_with().generate(driver)?;
@@ -362,7 +362,7 @@ fn assert_samples_eq(
     }
 }
 
-fn add_sample<'a>(
+fn fuzz_add_sample<'a>(
     timestamp: &Option<Timestamp>,
     sample: &'a Sample,
     expected_sample_types: &[owned_types::ValueType],
@@ -393,7 +393,7 @@ fn add_sample<'a>(
 
 /// Fuzzes adding a bunch of samples to the profile.
 #[test]
-fn fuzz_add_sample() {
+fn test_fuzz_add_sample() {
     bolero::check!()
         .with_generator((
             Vec::<owned_types::ValueType>::gen(),
@@ -409,7 +409,7 @@ fn fuzz_add_sample() {
             let mut samples_without_timestamps: HashMap<(&Vec<Location>, &Vec<Label>), Vec<i64>> =
                 HashMap::new();
             for (timestamp, sample) in samples {
-                add_sample(
+                fuzz_add_sample(
                     timestamp,
                     sample,
                     expected_sample_types,
@@ -567,7 +567,7 @@ fn fuzz_api_function_calls() {
             for operation in operations {
                 match operation {
                     Operation::AddSample(timestamp, sample) => {
-                        add_sample(
+                        fuzz_add_sample(
                             timestamp,
                             sample,
                             sample_types,
diff --git a/profiling/src/internal/profile/mod.rs b/profiling/src/internal/profile/mod.rs
index d61929cd3..300b50e4e 100644
--- a/profiling/src/internal/profile/mod.rs
+++ b/profiling/src/internal/profile/mod.rs
@@ -547,7 +547,6 @@ impl Profile {
 #[cfg(test)]
 mod api_tests {
     use super::*;
-    use std::collections::HashMap;
 
     #[test]
     fn interning() {

From 65e64fa961faa62eed0d78c0a4aa06667184d8fc Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Fri, 31 May 2024 22:52:34 +0900
Subject: [PATCH 42/54] constructors

---
 profiling/src/internal/profile/fuzz_tests.rs | 40 ++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
index 41df2c757..1e7fa86a6 100644
--- a/profiling/src/internal/profile/fuzz_tests.rs
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -26,6 +26,17 @@ pub struct Function {
     pub start_line: i64,
 }
 
+impl Function {
+    pub fn new(name: Box<str>, system_name: Box<str>, filename: Box<str>, start_line: i64) -> Self {
+        Self {
+            name,
+            system_name,
+            filename,
+            start_line,
+        }
+    }
+}
+
 impl<'a> From<&'a Function> for api::Function<'a> {
     fn from(value: &'a Function) -> Self {
         Self {
@@ -98,6 +109,17 @@ pub struct Location {
     pub line: i64,
 }
 
+impl Location {
+    pub fn new(mapping: Mapping, function: Function, address: u64, line: i64) -> Self {
+        Self {
+            mapping,
+            function,
+            address,
+            line,
+        }
+    }
+}
+
 impl<'a> From<&'a Location> for api::Location<'a> {
     fn from(value: &'a Location) -> Self {
         Self {
@@ -131,6 +153,24 @@ pub struct Mapping {
     pub build_id: Box<str>,
 }
 
+impl Mapping {
+    pub fn new(
+        memory_start: u64,
+        memory_limit: u64,
+        file_offset: u64,
+        filename: Box<str>,
+        build_id: Box<str>,
+    ) -> Self {
+        Self {
+            memory_start,
+            memory_limit,
+            file_offset,
+            filename,
+            build_id,
+        }
+    }
+}
+
 impl<'a> From<&'a Mapping> for api::Mapping<'a> {
     fn from(value: &'a Mapping) -> Self {
         Self {

From 301961bebe004d61bf2e329cf4938eea9e3b2475 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Fri, 31 May 2024 22:55:00 +0900
Subject: [PATCH 43/54] use constructors

---
 profiling/src/internal/profile/fuzz_tests.rs | 52 ++++++++++----------
 1 file changed, 25 insertions(+), 27 deletions(-)

diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
index 1e7fa86a6..bab90a074 100644
--- a/profiling/src/internal/profile/fuzz_tests.rs
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -304,33 +304,31 @@ fn assert_samples_eq(
             let function = profile.functions[line.function_id as usize - 1];
             assert!(!location.is_folded);
 
-            let owned_location = Location {
-                mapping: Mapping {
-                    memory_start: mapping.memory_start,
-                    memory_limit: mapping.memory_limit,
-                    file_offset: mapping.file_offset,
-                    filename: profile.string_table[mapping.filename as usize]
-                        .clone()
-                        .into_boxed_str(),
-                    build_id: profile.string_table[mapping.build_id as usize]
-                        .clone()
-                        .into_boxed_str(),
-                },
-                function: Function {
-                    name: profile.string_table[function.name as usize]
-                        .clone()
-                        .into_boxed_str(),
-                    system_name: profile.string_table[function.system_name as usize]
-                        .clone()
-                        .into_boxed_str(),
-                    filename: profile.string_table[function.filename as usize]
-                        .clone()
-                        .into_boxed_str(),
-                    start_line: function.start_line,
-                },
-                address: location.address,
-                line: line.line,
-            };
+            let owned_mapping = Mapping::new(
+                mapping.memory_start,
+                mapping.memory_limit,
+                mapping.file_offset,
+                profile.string_table[mapping.filename as usize]
+                    .clone()
+                    .into_boxed_str(),
+                profile.string_table[mapping.build_id as usize]
+                    .clone()
+                    .into_boxed_str(),
+            );
+            let owned_function = Function::new(
+                profile.string_table[function.name as usize]
+                    .clone()
+                    .into_boxed_str(),
+                profile.string_table[function.system_name as usize]
+                    .clone()
+                    .into_boxed_str(),
+                profile.string_table[function.filename as usize]
+                    .clone()
+                    .into_boxed_str(),
+                function.start_line,
+            );
+            let owned_location =
+                Location::new(owned_mapping, owned_function, location.address, line.line);
 
             owned_locations.push(owned_location);
         }

From ba175c25c1c5cd95a1da02712420efe9f0e79108 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Fri, 31 May 2024 23:15:47 +0900
Subject: [PATCH 44/54] string_table_fetch helper function

---
 profiling/src/internal/profile/fuzz_tests.rs | 32 +++++++++++---------
 profiling/src/pprof/proto.rs                 |  6 ++++
 2 files changed, 24 insertions(+), 14 deletions(-)

diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
index bab90a074..32483b4be 100644
--- a/profiling/src/internal/profile/fuzz_tests.rs
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -271,11 +271,8 @@ fn assert_sample_types_eq(
         .iter()
         .zip(expected_sample_types.iter())
     {
-        assert_eq!(
-            *profile.string_table[typ.r#type as usize],
-            *expected_typ.r#typ
-        );
-        assert_eq!(*profile.string_table[typ.unit as usize], *expected_typ.unit);
+        assert_eq!(*profile.string_table_fetch(typ.r#type), *expected_typ.r#typ);
+        assert_eq!(*profile.string_table_fetch(typ.unit), *expected_typ.unit);
     }
 }
 
@@ -308,21 +305,26 @@ fn assert_samples_eq(
                 mapping.memory_start,
                 mapping.memory_limit,
                 mapping.file_offset,
-                profile.string_table[mapping.filename as usize]
+                profile
+                    .string_table_fetch(mapping.filename)
                     .clone()
                     .into_boxed_str(),
-                profile.string_table[mapping.build_id as usize]
+                profile
+                    .string_table_fetch(mapping.build_id)
                     .clone()
                     .into_boxed_str(),
             );
             let owned_function = Function::new(
-                profile.string_table[function.name as usize]
+                profile
+                    .string_table_fetch(function.name)
                     .clone()
                     .into_boxed_str(),
-                profile.string_table[function.system_name as usize]
+                profile
+                    .string_table_fetch(function.system_name)
                     .clone()
                     .into_boxed_str(),
-                profile.string_table[function.filename as usize]
+                profile
+                    .string_table_fetch(function.filename)
                     .clone()
                     .into_boxed_str(),
                 function.start_line,
@@ -336,7 +338,8 @@ fn assert_samples_eq(
         // Recreate owned_labels from vector of pprof::Label
         let mut owned_labels = Vec::new();
         for label in sample.labels.iter() {
-            let key = profile.string_table[label.key as usize]
+            let key = profile
+                .string_table_fetch(label.key)
                 .clone()
                 .into_boxed_str();
 
@@ -344,7 +347,7 @@ fn assert_samples_eq(
                 // TODO: Check end timestamp label
                 continue;
             } else if *key == *"trace endpoint" {
-                let actual_str = &profile.string_table[label.str as usize];
+                let actual_str = profile.string_table_fetch(label.str);
 
                 let prev_label: &Label = owned_labels
                     .last()
@@ -359,7 +362,7 @@ fn assert_samples_eq(
             }
 
             if label.str != 0 {
-                let str = Box::from(profile.string_table[label.str as usize].as_str());
+                let str = Box::from(profile.string_table_fetch(label.str).as_str());
                 owned_labels.push(Label {
                     key,
                     str: Some(str),
@@ -370,7 +373,8 @@ fn assert_samples_eq(
                 let num = label.num;
                 let num_unit = if label.num_unit != 0 {
                     Some(
-                        profile.string_table[label.num_unit as usize]
+                        profile
+                            .string_table_fetch(label.num_unit)
                             .clone()
                             .into_boxed_str(),
                     )
diff --git a/profiling/src/pprof/proto.rs b/profiling/src/pprof/proto.rs
index 1d21a5f09..a0840d7df 100644
--- a/profiling/src/pprof/proto.rs
+++ b/profiling/src/pprof/proto.rs
@@ -175,6 +175,12 @@ impl Profile {
         samples.sort_unstable();
         samples
     }
+
+    pub fn string_table_fetch(&self, id: i64) -> &String {
+        self.string_table
+            .get(id as usize)
+            .expect("String {id} not found")
+    }
 }
 
 #[cfg(test)]

From 7839872bc967e335e4b08052071dc2870b196676 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Fri, 31 May 2024 23:40:09 +0900
Subject: [PATCH 45/54] also use fuzz_add_sample

---
 profiling/src/internal/profile/fuzz_tests.rs | 24 +++++++-------------
 1 file changed, 8 insertions(+), 16 deletions(-)

diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
index 32483b4be..eb63ea388 100644
--- a/profiling/src/internal/profile/fuzz_tests.rs
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -514,22 +514,14 @@ fn fuzz_add_sample_with_fixed_sample_length() {
                 .collect();
 
             for (timestamp, sample) in samples.iter() {
-                profile
-                    .add_sample(sample.into(), **timestamp)
-                    .expect("Failed to add sample");
-                if timestamp.is_some() {
-                    samples_with_timestamps.push(sample);
-                } else if let Some(existing_values) =
-                    samples_without_timestamps.get_mut(&(&sample.locations, &sample.labels))
-                {
-                    existing_values
-                        .iter_mut()
-                        .zip(sample.values.iter())
-                        .for_each(|(a, b)| *a = a.saturating_add(*b));
-                } else {
-                    samples_without_timestamps
-                        .insert((&sample.locations, &sample.labels), sample.values.clone());
-                }
+                fuzz_add_sample(
+                    timestamp,
+                    sample,
+                    sample_types,
+                    &mut profile,
+                    &mut samples_with_timestamps,
+                    &mut samples_without_timestamps,
+                );
             }
             let serialized_profile =
                 pprof::roundtrip_to_pprof(profile).expect("Failed to roundtrip to pprof");

From c1cba8d118f05ac90d89dde9e8a54fa119db267c Mon Sep 17 00:00:00 2001
From: Levi Morrison <levi.morrison@datadoghq.com>
Date: Fri, 31 May 2024 15:58:22 -0600
Subject: [PATCH 46/54] add fuzz_failure_001 to help debug

---
 profiling/src/internal/profile/fuzz_tests.rs | 62 +++++++++++++++++---
 1 file changed, 55 insertions(+), 7 deletions(-)

diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
index eb63ea388..f0ec7e38b 100644
--- a/profiling/src/internal/profile/fuzz_tests.rs
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -2,13 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use super::*;
-use crate::collections::identifiable::FxIndexMap;
-use crate::internal::{owned_types, Profile, Timestamp};
-use crate::pprof;
 use bolero::TypeGenerator;
 use bolero_generator::{TypeGeneratorWithParams, ValueGenerator};
-use std::collections::{HashMap, HashSet};
-use std::time::SystemTime;
+use std::collections::HashSet;
 
 #[derive(Clone, Debug, Default, Eq, PartialEq, Hash, TypeGenerator)]
 pub struct Function {
@@ -48,7 +44,7 @@ impl<'a> From<&'a Function> for api::Function<'a> {
     }
 }
 
-#[derive(Clone, Debug, Default, TypeGenerator)]
+#[derive(Clone, Debug, Default, Ord, PartialOrd, TypeGenerator)]
 pub struct Label {
     pub key: Box<str>,
 
@@ -390,10 +386,15 @@ fn assert_samples_eq(
             }
         }
 
+        owned_labels.sort();
+
         if let Some(expected_sample) = expected_timestamped_samples.next() {
             assert_eq!(owned_locations, expected_sample.locations);
             assert_eq!(sample.values, expected_sample.values);
-            assert_eq!(owned_labels, expected_sample.labels);
+            // Sort these first?
+            let mut expected_labels = expected_sample.labels.clone();
+            expected_labels.sort();
+            assert_eq!(owned_labels, expected_labels);
         } else {
             let key = (&owned_locations, &owned_labels);
             let expected_values = samples_without_timestamps
@@ -433,6 +434,53 @@ fn fuzz_add_sample<'a>(
     }
 }
 
+#[test]
+fn fuzz_failure_001() {
+    let sample_types = [];
+    let expected_sample_types = &[];
+    let sample = Sample {
+        locations: vec![],
+        values: vec![],
+        labels: vec![
+            Label {
+                key: Box::from("local root span id"),
+                str: None,
+                num: 281474976710656,
+                num_unit: None,
+            },
+            Label {
+                key: Box::from(""),
+                str: Some(Box::from("")),
+                num: 0,
+                num_unit: Some(Box::from("")),
+            },
+        ],
+    };
+    let mut expected_profile = Profile::new(SystemTime::now(), &sample_types, None);
+    let mut samples_with_timestamps = Vec::new();
+    let mut samples_without_timestamps: HashMap<(&Vec<Location>, &Vec<Label>), Vec<i64>> =
+        HashMap::new();
+
+    let timestamp = None;
+    fuzz_add_sample(
+        &timestamp,
+        &sample,
+        expected_sample_types,
+        &mut expected_profile,
+        &mut samples_with_timestamps,
+        &mut samples_without_timestamps,
+    );
+
+    let profile = pprof::roundtrip_to_pprof(expected_profile).unwrap();
+    assert_sample_types_eq(&profile, expected_sample_types);
+    assert_samples_eq(
+        &profile,
+        &samples_with_timestamps,
+        &samples_without_timestamps,
+        &FxIndexMap::default(),
+    );
+}
+
 /// Fuzzes adding a bunch of samples to the profile.
 #[test]
 fn test_fuzz_add_sample() {

From be84229138b6b410c2131ecdddebe9e9b4bf7e9a Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Sat, 1 Jun 2024 10:27:23 +0900
Subject: [PATCH 47/54] resolve comments

---
 profiling/src/internal/profile/fuzz_tests.rs | 47 ++++++--------------
 profiling/src/pprof/proto.rs                 |  4 ++
 2 files changed, 17 insertions(+), 34 deletions(-)

diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
index f0ec7e38b..18b23a568 100644
--- a/profiling/src/internal/profile/fuzz_tests.rs
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -275,7 +275,7 @@ fn assert_sample_types_eq(
 fn assert_samples_eq(
     profile: &pprof::Profile,
     samples_with_timestamps: &[&Sample],
-    samples_without_timestamps: &HashMap<(&Vec<Location>, &Vec<Label>), Vec<i64>>,
+    samples_without_timestamps: &HashMap<(&[Location], &[Label]), Vec<i64>>,
     endpoint_mappings: &FxIndexMap<u64, &String>,
 ) {
     assert_eq!(
@@ -301,28 +301,16 @@ fn assert_samples_eq(
                 mapping.memory_start,
                 mapping.memory_limit,
                 mapping.file_offset,
-                profile
-                    .string_table_fetch(mapping.filename)
-                    .clone()
-                    .into_boxed_str(),
-                profile
-                    .string_table_fetch(mapping.build_id)
-                    .clone()
-                    .into_boxed_str(),
+                profile.string_table_fetch_owned(mapping.filename),
+                profile.string_table_fetch_owned(mapping.build_id),
             );
             let owned_function = Function::new(
                 profile
                     .string_table_fetch(function.name)
                     .clone()
                     .into_boxed_str(),
-                profile
-                    .string_table_fetch(function.system_name)
-                    .clone()
-                    .into_boxed_str(),
-                profile
-                    .string_table_fetch(function.filename)
-                    .clone()
-                    .into_boxed_str(),
+                profile.string_table_fetch_owned(function.system_name),
+                profile.string_table_fetch_owned(function.filename),
                 function.start_line,
             );
             let owned_location =
@@ -334,10 +322,7 @@ fn assert_samples_eq(
         // Recreate owned_labels from vector of pprof::Label
         let mut owned_labels = Vec::new();
         for label in sample.labels.iter() {
-            let key = profile
-                .string_table_fetch(label.key)
-                .clone()
-                .into_boxed_str();
+            let key = profile.string_table_fetch_owned(label.key);
 
             if *key == *"end_timestamp_ns" {
                 // TODO: Check end timestamp label
@@ -368,12 +353,7 @@ fn assert_samples_eq(
             } else {
                 let num = label.num;
                 let num_unit = if label.num_unit != 0 {
-                    Some(
-                        profile
-                            .string_table_fetch(label.num_unit)
-                            .clone()
-                            .into_boxed_str(),
-                    )
+                    Some(profile.string_table_fetch_owned(label.num_unit))
                 } else {
                     None
                 };
@@ -396,7 +376,7 @@ fn assert_samples_eq(
             expected_labels.sort();
             assert_eq!(owned_labels, expected_labels);
         } else {
-            let key = (&owned_locations, &owned_labels);
+            let key: (&[Location], &[Label]) = (&owned_locations, &owned_labels);
             let expected_values = samples_without_timestamps
                 .get(&key)
                 .expect("Value not found for an aggregated sample");
@@ -411,7 +391,7 @@ fn fuzz_add_sample<'a>(
     expected_sample_types: &[owned_types::ValueType],
     profile: &mut Profile,
     samples_with_timestamps: &mut Vec<&'a Sample>,
-    samples_without_timestamps: &mut HashMap<(&'a Vec<Location>, &'a Vec<Label>), Vec<i64>>,
+    samples_without_timestamps: &mut HashMap<(&'a [Location], &'a [Label]), Vec<i64>>,
 ) {
     let r = profile.add_sample(sample.into(), *timestamp);
     if expected_sample_types.len() == sample.values.len() {
@@ -458,8 +438,7 @@ fn fuzz_failure_001() {
     };
     let mut expected_profile = Profile::new(SystemTime::now(), &sample_types, None);
     let mut samples_with_timestamps = Vec::new();
-    let mut samples_without_timestamps: HashMap<(&Vec<Location>, &Vec<Label>), Vec<i64>> =
-        HashMap::new();
+    let mut samples_without_timestamps: HashMap<(&[Location], &[Label]), Vec<i64>> = HashMap::new();
 
     let timestamp = None;
     fuzz_add_sample(
@@ -496,7 +475,7 @@ fn test_fuzz_add_sample() {
                 .collect();
             let mut expected_profile = Profile::new(SystemTime::now(), &sample_types, None);
             let mut samples_with_timestamps = Vec::new();
-            let mut samples_without_timestamps: HashMap<(&Vec<Location>, &Vec<Label>), Vec<i64>> =
+            let mut samples_without_timestamps: HashMap<(&[Location], &[Label]), Vec<i64>> =
                 HashMap::new();
             for (timestamp, sample) in samples {
                 fuzz_add_sample(
@@ -544,7 +523,7 @@ fn fuzz_add_sample_with_fixed_sample_length() {
             let api_sample_types: Vec<_> = sample_types.iter().map(api::ValueType::from).collect();
             let mut profile = Profile::new(SystemTime::now(), &api_sample_types, None);
             let mut samples_with_timestamps = Vec::new();
-            let mut samples_without_timestamps: HashMap<(&Vec<Location>, &Vec<Label>), Vec<i64>> =
+            let mut samples_without_timestamps: HashMap<(&[Location], &[Label]), Vec<i64>> =
                 HashMap::new();
 
             let samples: Vec<(&Option<Timestamp>, Sample)> = samples
@@ -642,7 +621,7 @@ fn fuzz_api_function_calls() {
             let api_sample_types: Vec<_> = sample_types.iter().map(api::ValueType::from).collect();
             let mut profile = Profile::new(SystemTime::now(), &api_sample_types, None);
             let mut samples_with_timestamps: Vec<&Sample> = Vec::new();
-            let mut samples_without_timestamps: HashMap<(&Vec<Location>, &Vec<Label>), Vec<i64>> =
+            let mut samples_without_timestamps: HashMap<(&[Location], &[Label]), Vec<i64>> =
                 HashMap::new();
             let mut endpoint_mappings: FxIndexMap<u64, &String> = FxIndexMap::default();
 
diff --git a/profiling/src/pprof/proto.rs b/profiling/src/pprof/proto.rs
index a0840d7df..19222a4ca 100644
--- a/profiling/src/pprof/proto.rs
+++ b/profiling/src/pprof/proto.rs
@@ -181,6 +181,10 @@ impl Profile {
             .get(id as usize)
             .expect("String {id} not found")
     }
+
+    pub fn string_table_fetch_owned(&self, id: i64) -> Box<str> {
+        self.string_table_fetch(id).clone().into_boxed_str()
+    }
 }
 
 #[cfg(test)]

From 95d2987260ac282d958957979f583168786f2c9f Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Wed, 5 Jun 2024 08:51:40 +0900
Subject: [PATCH 48/54] explain -1

---
 profiling/src/internal/profile/fuzz_tests.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
index 18b23a568..3084a6943 100644
--- a/profiling/src/internal/profile/fuzz_tests.rs
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -290,6 +290,9 @@ fn assert_samples_eq(
         // Recreate owned_locations from vector of pprof::Location
         let mut owned_locations = Vec::new();
         for loc_id in sample.location_ids.iter() {
+            // Subtract 1 because when creating pprof location ids, we use
+            // `small_non_zero_pprof_id()` function which guarantees that the id stored in pprof
+            // is +1 of the index in the vector of Locations in internal::Profile.
             let location = &profile.locations[*loc_id as usize - 1];
             let mapping = &profile.mappings[location.mapping_id as usize - 1];
             assert!(location.lines.len() == 1);

From 17134b85d198a2fb16edd9da39fc8bc3a29a759e Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Mon, 10 Jun 2024 09:45:02 -0400
Subject: [PATCH 49/54] add comment

---
 profiling/src/internal/profile/fuzz_tests.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
index 3084a6943..b0ce6ff78 100644
--- a/profiling/src/internal/profile/fuzz_tests.rs
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -295,6 +295,7 @@ fn assert_samples_eq(
             // is +1 of the index in the vector of Locations in internal::Profile.
             let location = &profile.locations[*loc_id as usize - 1];
             let mapping = &profile.mappings[location.mapping_id as usize - 1];
+            // internal::Location::to_pprof() always creates a single line.
             assert!(location.lines.len() == 1);
             let line = location.lines[0];
             let function = profile.functions[line.function_id as usize - 1];

From 2779220bc6d8767bde05ad22ffa145f4b8cb2b1f Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Mon, 10 Jun 2024 11:32:30 -0400
Subject: [PATCH 50/54] fix failure case

---
 profiling/src/internal/profile/fuzz_tests.rs | 43 ++++----------------
 1 file changed, 7 insertions(+), 36 deletions(-)

diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
index b0ce6ff78..2ca7095f2 100644
--- a/profiling/src/internal/profile/fuzz_tests.rs
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -3,7 +3,6 @@
 
 use super::*;
 use bolero::TypeGenerator;
-use bolero_generator::{TypeGeneratorWithParams, ValueGenerator};
 use std::collections::HashSet;
 
 #[derive(Clone, Debug, Default, Eq, PartialEq, Hash, TypeGenerator)]
@@ -179,7 +178,7 @@ impl<'a> From<&'a Mapping> for api::Mapping<'a> {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, TypeGenerator)]
 pub struct Sample {
     /// The leaf is at locations[0].
     pub locations: Vec<Location>,
@@ -224,34 +223,6 @@ impl std::hash::Hash for Label {
         self.key.hash(state)
     }
 }
-impl TypeGenerator for Sample {
-    fn generate<D: bolero_generator::Driver>(driver: &mut D) -> Option<Self> {
-        let locations = Vec::<Location>::gen_with().generate(driver)?;
-        let values = Vec::<i64>::gen_with().generate(driver)?;
-        let mut labels = std::collections::HashSet::<Label>::gen_with().generate(driver)?;
-
-        // Ensure that the label has "local root span id" key
-        // Generate non-zero num value for the label
-        let num = i64::gen().generate(driver)?;
-        // zero num is considered as invalid, see Profile::validate_sample_labels
-        if num == 0 {
-            return None;
-        }
-
-        labels.insert(Label {
-            key: "local root span id".into(),
-            str: None,
-            num,
-            num_unit: None,
-        });
-        let labels = labels.into_iter().collect();
-        Some(Self {
-            locations,
-            values,
-            labels,
-        })
-    }
-}
 
 fn assert_sample_types_eq(
     profile: &pprof::Profile,
@@ -426,18 +397,18 @@ fn fuzz_failure_001() {
         locations: vec![],
         values: vec![],
         labels: vec![
-            Label {
-                key: Box::from("local root span id"),
-                str: None,
-                num: 281474976710656,
-                num_unit: None,
-            },
             Label {
                 key: Box::from(""),
                 str: Some(Box::from("")),
                 num: 0,
                 num_unit: Some(Box::from("")),
             },
+            Label {
+                key: Box::from("local root span id"),
+                str: None,
+                num: 281474976710656,
+                num_unit: None,
+            },
         ],
     };
     let mut expected_profile = Profile::new(SystemTime::now(), &sample_types, None);

From 244156331976ae446763f6ff7daed6e7a203c9bd Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Mon, 10 Jun 2024 12:26:50 -0400
Subject: [PATCH 51/54] add comments

---
 profiling/src/internal/profile/fuzz_tests.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
index 2ca7095f2..d531a5759 100644
--- a/profiling/src/internal/profile/fuzz_tests.rs
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -272,6 +272,8 @@ fn assert_samples_eq(
             let function = profile.functions[line.function_id as usize - 1];
             assert!(!location.is_folded);
 
+            // TODO: Consider using &str from the string table and make an `api::` mapping
+            // to save allocations.
             let owned_mapping = Mapping::new(
                 mapping.memory_start,
                 mapping.memory_limit,

From 7de94c0128657bf77615179f859dee227f2b716e Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Mon, 10 Jun 2024 12:27:05 -0400
Subject: [PATCH 52/54] revive is_well_formed

---
 profiling/src/internal/profile/fuzz_tests.rs | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
index d531a5759..b872063f7 100644
--- a/profiling/src/internal/profile/fuzz_tests.rs
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -196,6 +196,18 @@ pub struct Sample {
     pub labels: Vec<Label>,
 }
 
+#[cfg(test)]
+impl Sample {
+    /// Checks if the sample is well formed.  Useful in testing.
+    pub fn is_well_formed(&self) -> bool {
+        let labels_are_unique = {
+            let mut uniq = std::collections::HashSet::new();
+            self.labels.iter().map(|l| &l.key).all(|x| uniq.insert(x))
+        };
+        labels_are_unique
+    }
+}
+
 impl<'a> From<&'a Sample> for api::Sample<'a> {
     fn from(value: &'a Sample) -> Self {
         Self {
@@ -306,7 +318,6 @@ fn assert_samples_eq(
                 continue;
             } else if *key == *"trace endpoint" {
                 let actual_str = profile.string_table_fetch(label.str);
-
                 let prev_label: &Label = owned_labels
                     .last()
                     .expect("Previous label to exist for endpoint label");
@@ -314,7 +325,6 @@ fn assert_samples_eq(
                 let expected_str = endpoint_mappings
                     .get(&num)
                     .expect("Endpoint mapping to exist");
-
                 assert_eq!(actual_str, *expected_str);
                 continue;
             }
@@ -371,7 +381,7 @@ fn fuzz_add_sample<'a>(
     samples_without_timestamps: &mut HashMap<(&'a [Location], &'a [Label]), Vec<i64>>,
 ) {
     let r = profile.add_sample(sample.into(), *timestamp);
-    if expected_sample_types.len() == sample.values.len() {
+    if expected_sample_types.len() == sample.values.len() && sample.is_well_formed() {
         assert!(r.is_ok());
         if timestamp.is_some() {
             samples_with_timestamps.push(sample);

From 288ff5cbd3680a96b8c0e142591317701020a6dd Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Mon, 10 Jun 2024 13:23:19 -0400
Subject: [PATCH 53/54] use different default ranges for miri

---
 profiling/src/internal/profile/fuzz_tests.rs | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
index b872063f7..e6a117ed9 100644
--- a/profiling/src/internal/profile/fuzz_tests.rs
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -450,11 +450,20 @@ fn fuzz_failure_001() {
 /// Fuzzes adding a bunch of samples to the profile.
 #[test]
 fn test_fuzz_add_sample() {
+    #[cfg(miri)]
+    let sample_types_gen = Vec::<owned_types::ValueType>::gen().with().len(0..=8usize);
+    #[cfg(not(miri))]
+    let sample_types_gen = Vec::<owned_types::ValueType>::gen();
+
+    #[cfg(miri)]
+    let samples_gen = Vec::<(Option<Timestamp>, Sample)>::gen()
+        .with()
+        .len(0..=8usize);
+    #[cfg(not(miri))]
+    let samples_gen = Vec::<(Option<Timestamp>, Sample)>::gen();
+
     bolero::check!()
-        .with_generator((
-            Vec::<owned_types::ValueType>::gen(),
-            Vec::<(Option<Timestamp>, Sample)>::gen(),
-        ))
+        .with_generator((sample_types_gen, samples_gen))
         .for_each(|(expected_sample_types, samples)| {
             let sample_types: Vec<_> = expected_sample_types
                 .iter()

From 7417cf1eb93bf6974cbc4e86e68b22d85f0012d5 Mon Sep 17 00:00:00 2001
From: Tae Gyun Kim <taegyun.kim@datadoghq.com>
Date: Mon, 10 Jun 2024 13:42:18 -0400
Subject: [PATCH 54/54] sort not needed

---
 profiling/src/internal/profile/fuzz_tests.rs | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/profiling/src/internal/profile/fuzz_tests.rs b/profiling/src/internal/profile/fuzz_tests.rs
index e6a117ed9..de9b8e7b2 100644
--- a/profiling/src/internal/profile/fuzz_tests.rs
+++ b/profiling/src/internal/profile/fuzz_tests.rs
@@ -353,15 +353,10 @@ fn assert_samples_eq(
             }
         }
 
-        owned_labels.sort();
-
         if let Some(expected_sample) = expected_timestamped_samples.next() {
             assert_eq!(owned_locations, expected_sample.locations);
             assert_eq!(sample.values, expected_sample.values);
-            // Sort these first?
-            let mut expected_labels = expected_sample.labels.clone();
-            expected_labels.sort();
-            assert_eq!(owned_labels, expected_labels);
+            assert_eq!(owned_labels, expected_sample.labels);
         } else {
             let key: (&[Location], &[Label]) = (&owned_locations, &owned_labels);
             let expected_values = samples_without_timestamps