diff --git a/Cargo.lock b/Cargo.lock
index 7ec39965652..c747a35e7a5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -544,7 +544,16 @@ version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
 dependencies = [
- "bit-vec",
+ "bit-vec 0.6.3",
+]
+
+[[package]]
+name = "bit-set"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
+dependencies = [
+ "bit-vec 0.8.0",
 ]
 
 [[package]]
@@ -553,6 +562,12 @@ version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
 
+[[package]]
+name = "bit-vec"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+
 [[package]]
 name = "bit_field"
 version = "0.10.2"
@@ -1608,6 +1623,7 @@ dependencies = [
  "log",
  "once_cell",
  "perfcnt",
+ "proptest",
  "rand 0.8.5",
  "rand_distr",
  "rustc-hash 1.1.0",
@@ -3363,7 +3379,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "55cb077ad656299f160924eb2912aa147d7339ea7d69e1b5517326fdcec3c1ca"
 dependencies = [
  "ascii-canvas",
- "bit-set",
+ "bit-set 0.5.3",
  "ena",
  "itertools 0.11.0",
  "lalrpop-util",
@@ -4254,6 +4270,8 @@ version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14cae93065090804185d3b75f0bf93b8eeda30c7a9b4a33d3bdb3988d6229e50"
 dependencies = [
+ "bit-set 0.8.0",
+ "bit-vec 0.8.0",
  "bitflags 2.8.0",
  "lazy_static",
  "num-traits",
@@ -4261,6 +4279,8 @@ dependencies = [
  "rand_chacha 0.3.1",
  "rand_xorshift",
  "regex-syntax 0.8.5",
+ "rusty-fork",
+ "tempfile",
  "unarray",
 ]
 
@@ -4373,6 +4393,12 @@ version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7dc55d7dec32ecaf61e0bd90b3d2392d721a28b95cfd23c3e176eccefbeab2f2"
 
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
 [[package]]
 name = "quinn"
 version = "0.11.7"
@@ -4916,6 +4942,18 @@ version = "1.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f7c45b9784283f1b2e7fb61b42047c2fd678ef0960d4f6f1eba131594cc369d4"
 
+[[package]]
+name = "rusty-fork"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb3dcc6e454c328bb824492db107ab7c0ae8fcffe4ad210136ef014458c1bc4f"
+dependencies = [
+ "fnv",
+ "quick-error",
+ "tempfile",
+ "wait-timeout",
+]
+
 [[package]]
 name = "ruzstd"
 version = "0.3.1"
@@ -6205,6 +6243,15 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
+[[package]]
+name = "wait-timeout"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11"
+dependencies = [
+ "libc 0.2.173",
+]
+
 [[package]]
 name = "walkdir"
 version = "2.5.0"
diff --git a/profiling/Cargo.toml b/profiling/Cargo.toml
index 788f3c2d4a8..698f7feab99 100644
--- a/profiling/Cargo.toml
+++ b/profiling/Cargo.toml
@@ -48,6 +48,7 @@ features = ["env-filter", "fmt", "smallvec", "std"]
 allocator-api2 = { version = "0.2", default-features = false, features = ["alloc"] }
 criterion = { version = "0.5.1" }
 datadog-php-profiling = { path = ".", features = ["test"] }
+proptest = { version = "1" }
 
 [target.'cfg(target_arch = "x86_64")'.dev-dependencies]
 criterion-perf-events = "0.4.0"
diff --git a/profiling/src/bitset.rs b/profiling/src/bitset.rs
new file mode 100644
index 00000000000..ac7178016a2
--- /dev/null
+++ b/profiling/src/bitset.rs
@@ -0,0 +1,239 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause
+
+use std::hash::{Hash, Hasher};
+
+/// Very simple bitset which doesn't allocate, and doesn't change after it has
+/// been created.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(transparent)]
+pub struct BitSet {
+    bits: u32,
+}
+
+impl Hash for BitSet {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        let bits = self.bits;
+        bits.count_ones().hash(state);
+        bits.hash(state);
+    }
+}
+
+impl BitSet {
+    pub const MAX: usize = u32::BITS as usize;
+
+    /// Creates a new bitset from the provided number.
+    pub const fn new(bits: u32) -> Self {
+        Self { bits }
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.bits.count_ones() as usize
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.bits == 0
+    }
+
+    #[inline]
+    pub fn contains(&self, bit: usize) -> bool {
+        if bit < 32 {
+            let mask = 1u32 << bit;
+            let masked = self.bits & mask;
+            masked != 0
+        } else {
+            false
+        }
+    }
+
+    pub fn iter(&self) -> BitSetIter {
+        BitSetIter::new(self)
+    }
+}
+
+impl FromIterator<usize> for BitSet {
+    /// Creates a new bitset from the iterator.
+    ///
+    /// # Panics
+    ///
+    /// Panics if an item is out of the range of the bitset e.g. [`u32::MAX`].
+    fn from_iter<I: IntoIterator<Item = usize>>(iter: I) -> BitSet {
+        let mut bits = 0;
+        let mut insert = |bit| {
+            // todo: add non-panic API
+            assert!(bit < BitSet::MAX);
+            bits |= 1u32 << bit;
+        };
+        for bit in iter {
+            insert(bit);
+        }
+        BitSet { bits }
+    }
+}
+
+pub struct BitSetIter {
+    bitset: u32,
+    offset: u32,
+    end: u32,
+}
+
+impl BitSetIter {
+    pub fn new(bitset: &BitSet) -> BitSetIter {
+        let bitset = bitset.bits;
+        let offset = 0;
+        let end = {
+            let num_bits = u32::BITS;
+            let leading_zeros = bitset.leading_zeros();
+            num_bits - leading_zeros
+        };
+        BitSetIter {
+            bitset,
+            offset,
+            end,
+        }
+    }
+}
+
+impl Iterator for BitSetIter {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while self.offset != self.end {
+            let offset = self.offset;
+            self.offset += 1;
+            let mask = 1 << offset;
+            let masked = self.bitset & mask;
+            if masked != 0 {
+                return Some(offset as usize);
+            }
+        }
+        None
+    }
+}
+
+impl ExactSizeIterator for BitSetIter {
+    fn len(&self) -> usize {
+        if self.offset < self.end {
+            let shifted = self.bitset >> self.offset;
+            shifted.count_ones() as usize
+        } else {
+            0
+        }
+    }
+}
+
+impl IntoIterator for BitSet {
+    type Item = usize;
+    type IntoIter = BitSetIter;
+    fn into_iter(self) -> Self::IntoIter {
+        BitSetIter::new(&self)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use proptest::prelude::*;
+    use proptest::test_runner::{RngAlgorithm, TestRng};
+    use std::collections::HashSet;
+
+    #[test]
+    fn bitset_full() {
+        let bitset = BitSet::new(u32::MAX);
+        assert_eq!(bitset.len(), BitSet::MAX);
+        assert!(!bitset.is_empty());
+
+        for i in 0..BitSet::MAX {
+            assert!(bitset.contains(i));
+        }
+
+        for (offset, bit) in bitset.iter().enumerate() {
+            assert_eq!(bit, offset);
+        }
+
+        let mut iter = bitset.iter();
+        let mut len = BitSet::MAX;
+        assert_eq!(len, iter.len());
+
+        while let Some(_) = iter.next() {
+            len -= 1;
+            assert_eq!(len, iter.len());
+        }
+    }
+
+    #[test]
+    fn bitset_empty() {
+        let bitset = BitSet::new(0);
+        assert_eq!(0, bitset.len());
+        assert!(bitset.is_empty());
+        for i in 0..BitSet::MAX {
+            assert!(!bitset.contains(i));
+        }
+
+        let mut iter = bitset.iter();
+        let len = 0;
+        assert_eq!(len, iter.len());
+        assert_eq!(None, iter.next());
+    }
+
+    // There's nothing special about 27, just testing a single possible number.
+    #[test]
+    fn bitset_27() {
+        let bitset = BitSet::new(1 << 27);
+        assert_eq!(1, bitset.len());
+        assert!(!bitset.is_empty());
+        assert!(bitset.contains(27));
+
+        let mut iter = bitset.iter();
+        let len = 1;
+        assert_eq!(len, iter.len());
+        assert_eq!(Some(27), iter.next());
+    }
+
+    static IOTA: [usize; BitSet::MAX] = [
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+        25, 26, 27, 28, 29, 30, 31,
+    ];
+
+    proptest! {
+        #[test]
+        fn bitset_acts_like_a_special_hashset(
+            oracle in proptest::sample::subsequence(&IOTA, 1..IOTA.len())
+                .prop_map(HashSet::<usize>::from_iter),
+        ) {
+            let bitset1 = BitSet::from_iter(oracle.iter().cloned());
+            prop_assert_eq!(bitset1.len(), oracle.len());
+
+            // Items in the oracle exist in the bitset.
+            for item in oracle.iter() {
+                prop_assert!(bitset1.contains(*item));
+            }
+
+            // Test the other way around to check the iterator implementation.
+            let mut i = 0;
+            for item in bitset1.iter() {
+                prop_assert!(oracle.contains(&item));
+                i += 1;
+            }
+            // Make sure the iterator ran as many times as we expected.
+            prop_assert_eq!(i, oracle.len(),
+                "BitSet's iterator didn't have the expected number of iterations"
+            );
+
+            // Like regular sets, insertion order doesn't matter in bitsets.
+            let mut shuffled = oracle.iter().copied().collect::<Vec<_>>();
+            let mut rng = TestRng::deterministic_rng(RngAlgorithm::ChaCha);
+            use rand::seq::SliceRandom;
+            shuffled.shuffle(&mut rng);
+            let bitset2 = BitSet::from_iter(shuffled.iter().cloned());
+
+            prop_assert_eq!(
+                bitset1, bitset2,
+                "Insertion order unexpectedly mattered, diff in binary: {:b} vs {:b}",
+                bitset1.bits, bitset2.bits
+            );
+        }
+    }
+}
diff --git a/profiling/src/inlinevec.rs b/profiling/src/inlinevec.rs
new file mode 100644
index 00000000000..380645dab16
--- /dev/null
+++ b/profiling/src/inlinevec.rs
@@ -0,0 +1,255 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause
+
+use core::slice::Iter;
+use std::hash::{Hash, Hasher};
+use std::mem::{ManuallyDrop, MaybeUninit};
+use std::ops::{Deref, Range};
+
+pub struct InlineVec<T, const N: usize> {
+    // This is intended to be on the stack, so large lengths don't make sense.
+    // Picking u8 also ensures no wasted bytes if you use small types for T.
+    len: u8,
+    values: [MaybeUninit<T>; N],
+}
+
+const fn assert_capacity(n: usize) {
+    if n > u8::MAX as usize {
+        panic!("InlineVec only supports up to u8::MAX capacities");
+    }
+}
+
+impl<T, const N: usize> Default for InlineVec<T, N> {
+    fn default() -> Self {
+        InlineVec::new()
+    }
+}
+
+impl<T, const N: usize> InlineVec<T, N> {
+    pub const fn new() -> Self {
+        assert_capacity(N);
+        Self {
+            len: 0,
+            // SAFETY: a MaybeUninit<[MaybeUninit<T>; N]> is the same as an
+            //                       [MaybeUninit<T>; N] when len=0.
+            values: unsafe { MaybeUninit::uninit().assume_init() },
+        }
+    }
+
+    /// # Safety
+    /// There must be unused capacity when called.
+    const unsafe fn push_unchecked(&mut self, value: T) {
+        self.as_mut_ptr().add(self.len()).write(value);
+        self.len += 1;
+    }
+
+    pub const fn from<const M: usize>(values: [T; M]) -> Self {
+        if N > u8::MAX as usize {
+            panic!("InlineVec only supports up to u8::MAX capacities");
+        }
+        if M > N {
+            panic!("InlineVec::new requires an array no larger than the underlying capacity");
+        }
+
+        // Steal the guts out of the array.
+        let mut vec = Self::new();
+        let src = values.as_ptr();
+        let dst = vec.values.as_mut_ptr().cast();
+        // SAFETY: can't be overlapping, we've stack-allocated dst.
+        unsafe { core::ptr::copy_nonoverlapping(src, dst, M) };
+        core::mem::forget(values);
+        vec.len = M as u8;
+        vec
+    }
+
+    pub const fn as_slice(&self) -> &[T] {
+        // SAFETY: the first N items are initialized.
+        unsafe { core::slice::from_raw_parts(self.as_ptr(), self.len()) }
+    }
+
+    // Not const yet, see Rust issue 137737.
+    pub fn iter(&self) -> Iter<'_, T> {
+        self.as_slice().iter()
+    }
+
+    pub const fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    pub const fn len(&self) -> usize {
+        self.len as usize
+    }
+
+    pub const fn as_ptr(&self) -> *const T {
+        self.values.as_ptr().cast()
+    }
+
+    pub const fn as_mut_ptr(&mut self) -> *mut T {
+        self.values.as_mut_ptr().cast()
+    }
+
+    pub const fn try_push(&mut self, value: T) -> Result<(), T> {
+        if self.len as usize != N {
+            // SAFETY: we've ensured there is unused capacity first.
+            unsafe { self.push_unchecked(value) };
+            Ok(())
+        } else {
+            Err(value)
+        }
+    }
+}
+
+impl<T, const N: usize> Deref for InlineVec<T, N> {
+    type Target = [T];
+
+    fn deref(&self) -> &Self::Target {
+        self.as_slice()
+    }
+}
+
+impl<T: core::fmt::Debug, const N: usize> core::fmt::Debug for InlineVec<T, N> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        self.deref().fmt(f)
+    }
+}
+
+impl<T: Clone, const N: usize> Clone for InlineVec<T, N> {
+    fn clone(&self) -> Self {
+        let mut cloned = Self::new();
+        cloned.clone_from(self);
+        cloned
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        if core::mem::needs_drop::<T>() {
+            let base = self.as_mut_ptr();
+            for i in 0..self.len() {
+                // SAFETY: have exclusive access from &mut self, and we're
+                // doing pointer math within bounds.
+                unsafe { base.add(i).drop_in_place() }
+            }
+        }
+        self.len = 0;
+        for item in source.iter() {
+            // SAFETY: N=N, so there's room, and we've cleared the vec already.
+            unsafe { self.push_unchecked(item.clone()) }
+        }
+    }
+}
+
+impl<T: Copy, const N: usize> Copy for InlineVec<T, N> {}
+
+pub struct InlineVecIter<T, const N: usize> {
+    start: usize,
+    vec: ManuallyDrop<InlineVec<T, N>>,
+}
+
+impl<T, const N: usize> InlineVecIter<T, N> {
+    fn live_range(&self) -> Range<usize> {
+        self.start..self.vec.len()
+    }
+}
+
+impl<T, const N: usize> Drop for InlineVecIter<T, N> {
+    fn drop(&mut self) {
+        if core::mem::needs_drop::<T>() {
+            let base = self.vec.as_mut_ptr();
+            for i in self.live_range() {
+                unsafe { base.add(i).drop_in_place() }
+            }
+        }
+    }
+}
+
+impl<T, const N: usize> From<InlineVec<T, N>> for InlineVecIter<T, N> {
+    fn from(vec: InlineVec<T, N>) -> Self {
+        Self {
+            start: 0,
+            vec: ManuallyDrop::new(vec),
+        }
+    }
+}
+
+impl<T, const N: usize> Iterator for InlineVecIter<T, N> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let live_range = self.live_range();
+        if !live_range.is_empty() {
+            let item = unsafe { self.vec.as_mut_ptr().add(live_range.start).read() };
+            self.start += 1;
+            Some(item)
+        } else {
+            None
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.live_range().len();
+        (len, Some(len))
+    }
+
+    fn count(self) -> usize {
+        self.live_range().len()
+    }
+}
+
+impl<T, const N: usize> ExactSizeIterator for InlineVecIter<T, N> {
+    fn len(&self) -> usize {
+        self.live_range().len()
+    }
+}
+
+impl<T, const N: usize> IntoIterator for InlineVec<T, N> {
+    type Item = T;
+    type IntoIter = InlineVecIter<T, N>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        InlineVecIter::from(self)
+    }
+}
+
+//
+// impl<T, const N: usize> From<InlineVec<T, N>> for ArrayVec<T, N> {
+//     fn from(vec: InlineVec<T, N>) -> Self {
+//         ArrayVec::from_iter(InlineVecIter::from(vec))
+//     }
+// }
+
+unsafe impl<T: Send, const N: usize> Send for InlineVec<T, N> {}
+unsafe impl<T: Sync, const N: usize> Sync for InlineVec<T, N> {}
+
+impl<T: Hash, const N: usize> Hash for InlineVec<T, N> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.deref().hash(state)
+    }
+}
+
+impl<T: PartialEq, const N: usize> PartialEq for InlineVec<T, N> {
+    fn eq(&self, other: &Self) -> bool {
+        self.deref().eq(other.deref())
+    }
+}
+
+impl<T: Eq, const N: usize> Eq for InlineVec<T, N> {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const TEST_INLINE_VEC: InlineVec<bool, 2> = {
+        let mut vec = InlineVec::from([false]);
+        if vec.try_push(true).is_err() {
+            panic!("expected to be able push another item into the vec")
+        }
+        vec
+    };
+
+    #[test]
+    fn test_inlinevec_const() {
+        assert_eq!(TEST_INLINE_VEC.as_slice(), &[false, true]);
+
+        let vec: Vec<_> = TEST_INLINE_VEC.iter().copied().collect();
+        assert_eq!(vec.as_slice(), &[false, true]);
+    }
+}
diff --git a/profiling/src/lib.rs b/profiling/src/lib.rs
index eb2f30820cf..3efe728dbab 100644
--- a/profiling/src/lib.rs
+++ b/profiling/src/lib.rs
@@ -1,12 +1,16 @@
 pub mod bindings;
+pub mod bitset;
 pub mod capi;
+pub mod inlinevec;
+pub mod profiling;
+
 mod clocks;
 mod config;
 mod logging;
-pub mod profiling;
 mod pthread;
 mod sapi;
 mod thin_str;
+mod vec_ext;
 mod wall_time;
 
 #[cfg(php_run_time_cache)]
@@ -23,7 +27,6 @@ mod exception;
 
 #[cfg(feature = "timeline")]
 mod timeline;
-mod vec_ext;
 
 use crate::config::{SystemSettings, INITIAL_SYSTEM_SETTINGS};
 use crate::zend::datadog_sapi_globals_request_info;
diff --git a/profiling/src/profiling/mod.rs b/profiling/src/profiling/mod.rs
index 39f1a205e98..be0f173c9ca 100644
--- a/profiling/src/profiling/mod.rs
+++ b/profiling/src/profiling/mod.rs
@@ -1,20 +1,16 @@
 mod interrupts;
-mod sample_type_filter;
+mod samples;
 pub mod stack_walking;
 mod thread_utils;
 mod uploader;
 
 pub use interrupts::*;
-pub use sample_type_filter::*;
+pub use samples::*;
 pub use stack_walking::*;
+
 use thread_utils::get_current_thread_name;
 use uploader::*;
 
-#[cfg(all(php_has_fibers, not(test)))]
-use crate::bindings::ddog_php_prof_get_active_fiber;
-#[cfg(all(php_has_fibers, test))]
-use crate::bindings::ddog_php_prof_get_active_fiber_test as ddog_php_prof_get_active_fiber;
-
 use crate::bindings::{datadog_php_profiling_get_profiling_context, zend_execute_data};
 use crate::config::SystemSettings;
 use crate::{Clocks, CLOCKS, TAGS};
@@ -37,6 +33,11 @@ use std::sync::{Arc, Barrier};
 use std::thread::JoinHandle;
 use std::time::{Duration, Instant, SystemTime};
 
+#[cfg(all(php_has_fibers, not(test)))]
+use crate::bindings::ddog_php_prof_get_active_fiber;
+#[cfg(all(php_has_fibers, test))]
+use crate::bindings::ddog_php_prof_get_active_fiber_test as ddog_php_prof_get_active_fiber;
+
 #[cfg(feature = "timeline")]
 use core::{ptr, str};
 #[cfg(feature = "timeline")]
@@ -53,6 +54,9 @@ use crate::io::{
     SOCKET_WRITE_SIZE_PROFILING_INTERVAL, SOCKET_WRITE_TIME_PROFILING_INTERVAL,
 };
 
+#[cfg(feature = "exception_profiling")]
+use crate::exception::EXCEPTION_PROFILING_INTERVAL;
+
 #[cfg(any(
     feature = "allocation_profiling",
     feature = "exception_profiling",
@@ -60,9 +64,6 @@ use crate::io::{
 ))]
 use datadog_profiling::api::UpscalingInfo;
 
-#[cfg(feature = "exception_profiling")]
-use crate::exception::EXCEPTION_PROFILING_INTERVAL;
-
 const UPLOAD_PERIOD: Duration = Duration::from_secs(67);
 
 pub const NO_TIMESTAMP: i64 = 0;
@@ -75,37 +76,6 @@ const UPLOAD_CHANNEL_CAPACITY: usize = 8;
 /// minit, and is destroyed on mshutdown.
 static mut PROFILER: OnceCell<Profiler> = OnceCell::new();
 
-/// Order this array this way:
-///  1. Always enabled types.
-///  2. On by default types.
-///  3. Off by default types.
-#[derive(Default, Debug)]
-pub struct SampleValues {
-    interrupt_count: i64,
-    wall_time: i64,
-    cpu_time: i64,
-    alloc_samples: i64,
-    alloc_size: i64,
-    timeline: i64,
-    exception: i64,
-    socket_read_time: i64,
-    socket_read_time_samples: i64,
-    socket_write_time: i64,
-    socket_write_time_samples: i64,
-    file_read_time: i64,
-    file_read_time_samples: i64,
-    file_write_time: i64,
-    file_write_time_samples: i64,
-    socket_read_size: i64,
-    socket_read_size_samples: i64,
-    socket_write_size: i64,
-    socket_write_size_samples: i64,
-    file_read_size: i64,
-    file_read_size_samples: i64,
-    file_write_size: i64,
-    file_write_size_samples: i64,
-}
-
 const WALL_TIME_PERIOD: Duration = Duration::from_millis(10);
 const WALL_TIME_PERIOD_TYPE: ValueType = ValueType {
     r#type: "wall-time",
@@ -159,6 +129,8 @@ impl<'a> From<&'a Label> for ApiLabel<'a> {
     }
 }
 
+// todo: use this alias when libdatadog 21 is released.
+// pub type ValueType = datadog_profiling::api::ValueType<'static>;
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 pub struct ValueType {
     pub r#type: &'static str,
@@ -180,7 +152,7 @@ impl ValueType {
 /// Apache per-dir settings use different service name, etc.
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub struct ProfileIndex {
-    pub sample_types: Vec<ValueType>,
+    pub enabled_profiles: EnabledProfiles,
     pub tags: Arc<Vec<Tag>>,
 }
 
@@ -188,7 +160,10 @@ pub struct ProfileIndex {
 pub struct SampleData {
     pub frames: Vec<ZendFrame>,
     pub labels: Vec<Label>,
-    pub sample_values: Vec<i64>,
+    pub sample_values: SampleValues,
+    // It's 3 because there's one "main" profile type plus optionally the
+    // CPU and Wall samples
+    // pub sample_values: InlineVec<SampleValue, 3>,
     pub timestamp: i64,
 }
 
@@ -204,6 +179,10 @@ pub struct LocalRootSpanResourceMessage {
     pub resource: String,
 }
 
+// Allow large enum variant for now, because we're avoiding an allocation on
+// a hot path. The correct fix is probably to take some kind of
+// `InlineVec<SampleValue>` where `SampleValue` is an enum per profile type.
+#[allow(clippy::large_enum_variant)]
 #[derive(Debug)]
 pub enum ProfilerMessage {
     Cancel,
@@ -241,7 +220,7 @@ pub struct Profiler {
     time_collector_handle: JoinHandle<()>,
     uploader_handle: JoinHandle<()>,
     should_join: AtomicBool,
-    sample_types_filter: SampleTypeFilter,
+    enabled_profiles: EnabledProfiles,
     system_settings: AtomicPtr<SystemSettings>,
 }
 
@@ -292,8 +271,8 @@ impl TimeCollector {
     fn create_profile(message: &SampleMessage, started_at: SystemTime) -> InternalProfile {
         let sample_types: Vec<ApiValueType> = message
             .key
-            .sample_types
-            .iter()
+            .enabled_profiles
+            .enabled_sample_types()
             .map(|sample_type| ApiValueType {
                 r#type: sample_type.r#type,
                 unit: sample_type.unit,
@@ -516,27 +495,34 @@ impl TimeCollector {
         profiles: &mut HashMap<ProfileIndex, InternalProfile>,
         started_at: &WallTime,
     ) {
-        if message.key.sample_types.is_empty() {
+        if message.key.enabled_profiles.num_enabled_profiles() == 0 {
             // profiling disabled, this should not happen!
             warn!("A sample with no sample types was recorded in the profiler. Please report this to Datadog.");
             return;
         }
 
-        let profile: &mut InternalProfile = if let Some(value) = profiles.get_mut(&message.key) {
-            value
-        } else {
-            profiles.insert(
-                message.key.clone(),
-                Self::create_profile(&message, started_at.systemtime),
-            );
-            profiles
-                .get_mut(&message.key)
-                .expect("entry to exist; just inserted it")
-        };
+        if profiles.try_reserve(1).is_err() {
+            debug!("out of memory: couldn't create a new profile");
+        }
+        let profile = profiles
+            .entry(message.key.clone())
+            .or_insert_with(|| Self::create_profile(&message, started_at.systemtime));
 
         let mut locations = Vec::with_capacity(message.value.frames.len());
 
-        let values = message.value.sample_values;
+        let values = {
+            let iter = message
+                .key
+                .enabled_profiles
+                .filter(&message.value.sample_values);
+            let mut values = Vec::new();
+            if values.try_reserve_exact(iter.len()).is_err() {
+                debug!("out of memory: sample dropped");
+                return;
+            }
+            values.extend(iter);
+            values
+        };
         let labels: Vec<ApiLabel> = message.value.labels.iter().map(ApiLabel::from).collect();
 
         for frame in &message.value.frames {
@@ -708,7 +694,7 @@ impl Profiler {
             Utc::now(),
         );
 
-        let sample_types_filter = SampleTypeFilter::new(system_settings);
+        let enabled_profiles = EnabledProfiles::new(system_settings);
         Profiler {
             fork_barrier,
             interrupt_manager,
@@ -723,7 +709,7 @@ impl Profiler {
                 trace!("thread {DDPROF_UPLOAD} complete, shutting down");
             }),
             should_join: AtomicBool::new(true),
-            sample_types_filter,
+            enabled_profiles,
             system_settings: AtomicPtr::new(system_settings),
         }
     }
@@ -1525,7 +1511,7 @@ impl Profiler {
     fn prepare_sample_message(
         &self,
         frames: Vec<ZendFrame>,
-        samples: SampleValues,
+        sample_values: SampleValues,
         labels: Vec<Label>,
         timestamp: i64,
     ) -> SampleMessage {
@@ -1534,13 +1520,15 @@ impl Profiler {
         //  1. Nobody should be calling this when it's disabled anyway.
         //  2. It would require tracking more state and/or spending CPU on
         //     something that shouldn't be done anyway (see #1).
-        let sample_types = self.sample_types_filter.sample_types();
-        let sample_values = self.sample_types_filter.filter(samples);
+        let enabled_profiles = self.enabled_profiles.clone();
 
         let tags = TAGS.with_borrow(Arc::clone);
 
         SampleMessage {
-            key: ProfileIndex { sample_types, tags },
+            key: ProfileIndex {
+                enabled_profiles,
+                tags,
+            },
             value: SampleData {
                 frames,
                 labels,
@@ -1633,8 +1621,9 @@ mod tests {
 
         let message: SampleMessage = profiler.prepare_sample_message(frames, samples, labels, 900);
 
+        let enabled_profiles = profiler.enabled_profiles;
         assert_eq!(
-            message.key.sample_types,
+            enabled_profiles.enabled_sample_types().collect::<Vec<_>>(),
             vec![
                 ValueType::new("sample", "count"),
                 ValueType::new("wall-time", "nanoseconds"),
@@ -1642,7 +1631,10 @@ mod tests {
                 ValueType::new("timeline", "nanoseconds"),
             ]
         );
-        assert_eq!(message.value.sample_values, vec![10, 20, 30, 60]);
+        let sample_values = enabled_profiles
+            .filter(&message.value.sample_values)
+            .collect::<Vec<_>>();
+        assert_eq!(sample_values, vec![10, 20, 30, 60]);
         assert_eq!(message.value.timestamp, 900);
     }
 }
diff --git a/profiling/src/profiling/sample_type_filter.rs b/profiling/src/profiling/sample_type_filter.rs
deleted file mode 100644
index 2dc9483938c..00000000000
--- a/profiling/src/profiling/sample_type_filter.rs
+++ /dev/null
@@ -1,294 +0,0 @@
-use crate::config::SystemSettings;
-use crate::profiling::{SampleValues, ValueType};
-
-const MAX_SAMPLE_TYPES: usize = 23;
-
-pub struct SampleTypeFilter {
-    sample_types: Vec<ValueType>,
-    sample_types_mask: [bool; MAX_SAMPLE_TYPES],
-}
-
-impl SampleTypeFilter {
-    pub fn new(system_settings: &SystemSettings) -> Self {
-        // Lay this out in the same order as SampleValues.
-        static SAMPLE_TYPES: &[ValueType; MAX_SAMPLE_TYPES] = &[
-            ValueType::new("sample", "count"),
-            ValueType::new("wall-time", "nanoseconds"),
-            ValueType::new("cpu-time", "nanoseconds"),
-            ValueType::new("alloc-samples", "count"),
-            ValueType::new("alloc-size", "bytes"),
-            ValueType::new("timeline", "nanoseconds"),
-            ValueType::new("exception-samples", "count"),
-            ValueType::new("socket-read-time", "nanoseconds"),
-            ValueType::new("socket-read-time-samples", "count"),
-            ValueType::new("socket-write-time", "nanoseconds"),
-            ValueType::new("socket-write-time-samples", "count"),
-            ValueType::new("file-io-read-time", "nanoseconds"),
-            ValueType::new("file-io-read-time-samples", "count"),
-            ValueType::new("file-io-write-time", "nanoseconds"),
-            ValueType::new("file-io-write-time-samples", "count"),
-            ValueType::new("socket-read-size", "bytes"),
-            ValueType::new("socket-read-size-samples", "count"),
-            ValueType::new("socket-write-size", "bytes"),
-            ValueType::new("socket-write-size-samples", "count"),
-            ValueType::new("file-io-read-size", "bytes"),
-            ValueType::new("file-io-read-size-samples", "count"),
-            ValueType::new("file-io-write-size", "bytes"),
-            ValueType::new("file-io-write-size-samples", "count"),
-        ];
-
-        let mut sample_types = Vec::with_capacity(SAMPLE_TYPES.len());
-        let mut sample_types_mask = [false; MAX_SAMPLE_TYPES];
-
-        if system_settings.profiling_enabled {
-            // sample, wall-time, cpu-time
-            let len = 2 + system_settings.profiling_experimental_cpu_time_enabled as usize;
-            sample_types.extend_from_slice(&SAMPLE_TYPES[0..len]);
-            sample_types_mask[0] = true;
-            sample_types_mask[1] = true;
-            sample_types_mask[2] = system_settings.profiling_experimental_cpu_time_enabled;
-
-            // alloc-samples, alloc-size
-            if system_settings.profiling_allocation_enabled {
-                sample_types.extend_from_slice(&SAMPLE_TYPES[3..5]);
-                sample_types_mask[3] = true;
-                sample_types_mask[4] = true;
-            }
-
-            #[cfg(feature = "timeline")]
-            if system_settings.profiling_timeline_enabled {
-                sample_types.push(SAMPLE_TYPES[5]);
-                sample_types_mask[5] = true;
-            }
-
-            #[cfg(feature = "exception_profiling")]
-            if system_settings.profiling_exception_enabled {
-                sample_types.push(SAMPLE_TYPES[6]);
-                sample_types_mask[6] = true;
-            }
-
-            #[cfg(feature = "io_profiling")]
-            if system_settings.profiling_io_enabled {
-                sample_types.push(SAMPLE_TYPES[7]);
-                sample_types_mask[7] = true;
-                sample_types.push(SAMPLE_TYPES[8]);
-                sample_types_mask[8] = true;
-                sample_types.push(SAMPLE_TYPES[9]);
-                sample_types_mask[9] = true;
-                sample_types.push(SAMPLE_TYPES[10]);
-                sample_types_mask[10] = true;
-                sample_types.push(SAMPLE_TYPES[11]);
-                sample_types_mask[11] = true;
-                sample_types.push(SAMPLE_TYPES[12]);
-                sample_types_mask[12] = true;
-                sample_types.push(SAMPLE_TYPES[13]);
-                sample_types_mask[13] = true;
-                sample_types.push(SAMPLE_TYPES[14]);
-                sample_types_mask[14] = true;
-                sample_types.push(SAMPLE_TYPES[15]);
-                sample_types_mask[15] = true;
-                sample_types.push(SAMPLE_TYPES[16]);
-                sample_types_mask[16] = true;
-                sample_types.push(SAMPLE_TYPES[17]);
-                sample_types_mask[17] = true;
-                sample_types.push(SAMPLE_TYPES[18]);
-                sample_types_mask[18] = true;
-                sample_types.push(SAMPLE_TYPES[19]);
-                sample_types_mask[19] = true;
-                sample_types.push(SAMPLE_TYPES[20]);
-                sample_types_mask[20] = true;
-                sample_types.push(SAMPLE_TYPES[21]);
-                sample_types_mask[21] = true;
-                sample_types.push(SAMPLE_TYPES[22]);
-                sample_types_mask[22] = true;
-            }
-        }
-
-        Self {
-            sample_types,
-            sample_types_mask,
-        }
-    }
-
-    pub fn sample_types(&self) -> Vec<ValueType> {
-        self.sample_types.clone()
-    }
-
-    pub fn filter(&self, sample_values: SampleValues) -> Vec<i64> {
-        let mut output = Vec::new();
-        output.reserve_exact(self.sample_types.len());
-
-        // Lay this out in the same order as SampleValues.
-        // Allows us to slice the SampleValues as if they were an array.
-        let values: [i64; MAX_SAMPLE_TYPES] = [
-            sample_values.interrupt_count,
-            sample_values.wall_time,
-            sample_values.cpu_time,
-            sample_values.alloc_samples,
-            sample_values.alloc_size,
-            sample_values.timeline,
-            sample_values.exception,
-            sample_values.socket_read_time,
-            sample_values.socket_read_time_samples,
-            sample_values.socket_write_time,
-            sample_values.socket_write_time_samples,
-            sample_values.file_read_time,
-            sample_values.file_read_time_samples,
-            sample_values.file_write_time,
-            sample_values.file_write_time_samples,
-            sample_values.socket_read_size,
-            sample_values.socket_read_size_samples,
-            sample_values.socket_write_size,
-            sample_values.socket_write_size_samples,
-            sample_values.file_read_size,
-            sample_values.file_read_size_samples,
-            sample_values.file_write_size,
-            sample_values.file_write_size_samples,
-        ];
-
-        for (value, enabled) in values.into_iter().zip(self.sample_types_mask.iter()) {
-            if *enabled {
-                output.push(value);
-            }
-        }
-
-        output
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::profiling::tests::{get_samples, get_system_settings};
-
-    #[test]
-    fn filter_with_profiling_disabled() {
-        let mut settings = get_system_settings();
-
-        settings.profiling_enabled = false;
-        settings.profiling_allocation_enabled = false;
-        settings.profiling_experimental_cpu_time_enabled = false;
-
-        let sample_type_filter = SampleTypeFilter::new(&settings);
-        let values = sample_type_filter.filter(get_samples());
-        let types = sample_type_filter.sample_types();
-
-        assert_eq!(types, Vec::<ValueType>::new());
-        assert_eq!(values, Vec::<i64>::new());
-    }
-
-    #[test]
-    fn filter_with_profiling_enabled() {
-        let mut settings = get_system_settings();
-
-        settings.profiling_enabled = true;
-        settings.profiling_allocation_enabled = false;
-        settings.profiling_experimental_cpu_time_enabled = false;
-
-        let sample_type_filter = SampleTypeFilter::new(&settings);
-        let values = sample_type_filter.filter(get_samples());
-        let types = sample_type_filter.sample_types();
-
-        assert_eq!(
-            types,
-            vec![
-                ValueType::new("sample", "count"),
-                ValueType::new("wall-time", "nanoseconds"),
-            ]
-        );
-        assert_eq!(values, vec![10, 20]);
-    }
-
-    #[test]
-    fn filter_with_cpu_time() {
-        let mut settings = get_system_settings();
-        settings.profiling_enabled = true;
-        settings.profiling_allocation_enabled = false;
-        settings.profiling_experimental_cpu_time_enabled = true;
-
-        let sample_type_filter = SampleTypeFilter::new(&settings);
-        let values = sample_type_filter.filter(get_samples());
-        let types = sample_type_filter.sample_types();
-
-        assert_eq!(
-            types,
-            vec![
-                ValueType::new("sample", "count"),
-                ValueType::new("wall-time", "nanoseconds"),
-                ValueType::new("cpu-time", "nanoseconds"),
-            ]
-        );
-        assert_eq!(values, vec![10, 20, 30]);
-    }
-
-    #[test]
-    fn filter_with_allocations() {
-        let mut settings = get_system_settings();
-        settings.profiling_enabled = true;
-        settings.profiling_allocation_enabled = true;
-        settings.profiling_experimental_cpu_time_enabled = false;
-
-        let sample_type_filter = SampleTypeFilter::new(&settings);
-        let values = sample_type_filter.filter(get_samples());
-        let types = sample_type_filter.sample_types();
-
-        assert_eq!(
-            types,
-            vec![
-                ValueType::new("sample", "count"),
-                ValueType::new("wall-time", "nanoseconds"),
-                ValueType::new("alloc-samples", "count"),
-                ValueType::new("alloc-size", "bytes"),
-            ]
-        );
-        assert_eq!(values, vec![10, 20, 40, 50]);
-    }
-
-    #[test]
-    fn filter_with_allocations_and_cpu_time() {
-        let mut settings = get_system_settings();
-        settings.profiling_enabled = true;
-        settings.profiling_allocation_enabled = true;
-        settings.profiling_experimental_cpu_time_enabled = true;
-
-        let sample_type_filter = SampleTypeFilter::new(&settings);
-        let values = sample_type_filter.filter(get_samples());
-        let types = sample_type_filter.sample_types();
-
-        assert_eq!(
-            types,
-            vec![
-                ValueType::new("sample", "count"),
-                ValueType::new("wall-time", "nanoseconds"),
-                ValueType::new("cpu-time", "nanoseconds"),
-                ValueType::new("alloc-samples", "count"),
-                ValueType::new("alloc-size", "bytes"),
-            ]
-        );
-        assert_eq!(values, vec![10, 20, 30, 40, 50]);
-    }
-
-    #[test]
-    #[cfg(feature = "exception_profiling")]
-    fn filter_with_cpu_time_and_exceptions() {
-        let mut settings = get_system_settings();
-        settings.profiling_enabled = true;
-        settings.profiling_experimental_cpu_time_enabled = true;
-        settings.profiling_exception_enabled = true;
-
-        let sample_type_filter = SampleTypeFilter::new(&settings);
-        let values = sample_type_filter.filter(get_samples());
-        let types = sample_type_filter.sample_types();
-
-        assert_eq!(
-            types,
-            vec![
-                ValueType::new("sample", "count"),
-                ValueType::new("wall-time", "nanoseconds"),
-                ValueType::new("cpu-time", "nanoseconds"),
-                ValueType::new("exception-samples", "count"),
-            ]
-        );
-        assert_eq!(values, vec![10, 20, 30, 70]);
-    }
-}
diff --git a/profiling/src/profiling/samples.rs b/profiling/src/profiling/samples.rs
new file mode 100644
index 00000000000..d59da7e85c6
--- /dev/null
+++ b/profiling/src/profiling/samples.rs
@@ -0,0 +1,573 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause
+
+use crate::bitset::BitSet;
+use crate::config::SystemSettings;
+use crate::inlinevec::InlineVec;
+use crate::profiling::ValueType;
+use std::hash::{Hash, Hasher};
+
+pub const MAX_SAMPLE_TYPES_PER_PROFILE: usize = 2;
+pub const MAX_SAMPLE_VALUES: usize = 23;
+pub const NUM_PROFILE_TYPES: usize = 13;
+
+pub type ProfileType = InlineVec<ValueType, MAX_SAMPLE_TYPES_PER_PROFILE>;
+
+/// The profile types in PHP. The [`SampleValue`] enum must have its variants
+/// in the same order as they come in this list.
+pub const PROFILE_TYPES: [ProfileType; NUM_PROFILE_TYPES] = [
+    SAMPLE_TYPE_WALL_TIME,
+    SAMPLE_TYPE_CPU_TIME,
+    SAMPLE_TYPE_ALLOC,
+    SAMPLE_TYPE_TIMELINE,
+    SAMPLE_TYPE_EXCEPTION,
+    SAMPLE_TYPE_SOCKET_READ_TIME,
+    SAMPLE_TYPE_SOCKET_WRITE_TIME,
+    SAMPLE_TYPE_FILE_IO_READ_TIME,
+    SAMPLE_TYPE_FILE_IO_WRITE_TIME,
+    SAMPLE_TYPE_SOCKET_READ_SIZE,
+    SAMPLE_TYPE_SOCKET_WRITE_SIZE,
+    SAMPLE_TYPE_FILE_IO_READ_SIZE,
+    SAMPLE_TYPE_FILE_IO_WRITE_SIZE,
+];
+
+/// Historically, this was ordered this way:
+///  1. Always enabled types.
+///  2. On by default types.
+///  3. Off by default types.
+///
+/// But this doesn't really matter anymore, because the number of sample types
+/// has grown and the optimizations used don't work well anymore.
+#[derive(Default, Debug)]
+#[repr(C)]
+pub struct SampleValues {
+    pub interrupt_count: i64,
+    pub wall_time: i64,
+    pub cpu_time: i64,
+    pub alloc_samples: i64,
+    pub alloc_size: i64,
+    pub timeline: i64,
+    pub exception: i64,
+    pub socket_read_time: i64,
+    pub socket_read_time_samples: i64,
+    pub socket_write_time: i64,
+    pub socket_write_time_samples: i64,
+    pub file_read_time: i64,
+    pub file_read_time_samples: i64,
+    pub file_write_time: i64,
+    pub file_write_time_samples: i64,
+    pub socket_read_size: i64,
+    pub socket_read_size_samples: i64,
+    pub socket_write_size: i64,
+    pub socket_write_size_samples: i64,
+    pub file_read_size: i64,
+    pub file_read_size_samples: i64,
+    pub file_write_size: i64,
+    pub file_write_size_samples: i64,
+}
+
+/// The sample values for a given profile type.
+///
+/// The repr(u8) is valid even though this holds data larger than u8; see the
+/// documentation on primitive representations:
+/// https://doc.rust-lang.org/reference/type-layout.html#primitive-representations
+///
+/// If the order of the enum is changed, or if variants are added or removed,
+/// then [`PROFILE_TYPES`] needs to be changed (or vice versa).
+#[repr(u8)]
+pub enum SampleValue {
+    WallTime { nanoseconds: i64, count: i64 },
+    CpuTime { nanoseconds: i64 },
+    Alloc { bytes: i64, count: i64 },
+    Timeline { nanoseconds: i64 },
+    Exception { count: i64 },
+    FileIoReadTime { nanoseconds: i64, count: i64 },
+    FileIoWriteTime { nanoseconds: i64, count: i64 },
+    FileIoReadSize { bytes: i64, count: i64 },
+    FileIoWriteSize { bytes: i64, count: i64 },
+    SocketReadTime { nanoseconds: i64, count: i64 },
+    SocketWriteTime { nanoseconds: i64, count: i64 },
+    SocketReadSize { bytes: i64, count: i64 },
+    SocketWriteSize { bytes: i64, count: i64 },
+}
+
+/// Tracks which profile types are enabled. Since there are 1 or 2 sample
+/// types per profile, it also keeps a bitset for which sample types and
+/// values are in-use. So for 13 profiles, there may be 13-26 sample types.
+#[derive(Clone, Debug)]
+pub struct EnabledProfiles {
+    /// Tracks which profile types are enabled.
+    profiles: BitSet,
+    /// Tracks which sample types/values are enabled. This is the same
+    /// information as the other bitset, just formatted for a different use
+    /// case. This means this field isn't used in Eq + Hash.
+    samples: BitSet,
+}
+
+impl SampleValues {
+    pub fn as_array(&self) -> [&i64; MAX_SAMPLE_VALUES] {
+        // Use the same order as the members.
+        [
+            &self.interrupt_count,
+            &self.wall_time,
+            &self.cpu_time,
+            &self.alloc_samples,
+            &self.alloc_size,
+            &self.timeline,
+            &self.exception,
+            &self.socket_read_time,
+            &self.socket_read_time_samples,
+            &self.socket_write_time,
+            &self.socket_write_time_samples,
+            &self.file_read_time,
+            &self.file_read_time_samples,
+            &self.file_write_time,
+            &self.file_write_time_samples,
+            &self.socket_read_size,
+            &self.socket_read_size_samples,
+            &self.socket_write_size,
+            &self.socket_write_size_samples,
+            &self.file_read_size,
+            &self.file_read_size_samples,
+            &self.file_write_size,
+            &self.file_write_size_samples,
+        ]
+    }
+}
+
+impl Eq for EnabledProfiles {}
+impl PartialEq for EnabledProfiles {
+    fn eq(&self, other: &Self) -> bool {
+        self.profiles == other.profiles
+    }
+}
+impl Hash for EnabledProfiles {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.profiles.hash(state);
+    }
+}
+
+impl EnabledProfiles {
+    pub fn new(config: &SystemSettings) -> EnabledProfiles {
+        let wall_time = config.profiling_enabled;
+        let cpu_time = config.profiling_experimental_cpu_time_enabled;
+        let alloc = config.profiling_allocation_enabled;
+        let timeline = config.profiling_timeline_enabled;
+        let exception = config.profiling_exception_enabled;
+        let io_profiling = cfg!(feature = "io_profiling") && config.profiling_io_enabled;
+
+        // This implementation is tied to the order PROFILE_TYPES is defined.
+        let profiles_mask = [
+            wall_time,
+            cpu_time,
+            alloc,
+            timeline,
+            exception,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+        ];
+
+        let profiles = BitSet::from_iter(
+            profiles_mask
+                .into_iter()
+                .enumerate()
+                .filter_map(|(offset, enabled)| enabled.then_some(offset)),
+        );
+
+        // This implementation is tied to the order of SampleValues.
+        let samples_mask: [bool; MAX_SAMPLE_VALUES] = [
+            wall_time,
+            wall_time,
+            cpu_time,
+            alloc,
+            alloc,
+            timeline,
+            exception,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+            io_profiling,
+        ];
+
+        let samples = BitSet::from_iter(
+            samples_mask
+                .into_iter()
+                .enumerate()
+                .filter_map(|(offset, enabled)| enabled.then_some(offset)),
+        );
+
+        EnabledProfiles { profiles, samples }
+    }
+}
+
+impl EnabledProfiles {
+    /// Returns the number of profiles that are enabled.
+    #[inline]
+    pub fn num_enabled_profiles(&self) -> usize {
+        self.profiles.len()
+    }
+
+    /// Returns the number of sample types that are enabled. This could be
+    /// used to reserve space in a container before using [`Self::filter`].
+    #[inline]
+    pub fn num_enabled_sample_types(&self) -> usize {
+        self.samples.len()
+    }
+
+    pub fn filter<'a>(
+        &self,
+        sample_values: &'a SampleValues,
+    ) -> SampleIter<impl Iterator<Item = i64> + 'a> {
+        let bitset = self.samples;
+        let len = bitset.len();
+        let iter =
+            sample_values
+                .as_array()
+                .into_iter()
+                .enumerate()
+                .filter_map(move |(index, value)| {
+                    if bitset.contains(index) {
+                        Some(*value)
+                    } else {
+                        None
+                    }
+                });
+        SampleIter { len, iter }
+    }
+
+    pub fn enabled_profile_types(&self) -> SampleIter<impl Iterator<Item = ProfileType> + '_> {
+        let len = self.num_enabled_profiles();
+        let iter = PROFILE_TYPES
+            .iter()
+            .enumerate()
+            .filter_map(|(offset, profile_type)| {
+                self.profiles.contains(offset).then_some(*profile_type)
+            });
+        SampleIter { len, iter }
+    }
+
+    pub fn enabled_sample_types(&self) -> SampleIter<impl Iterator<Item = ValueType> + '_> {
+        let len = self.num_enabled_sample_types();
+        let iter = self.enabled_profile_types().flatten();
+        SampleIter { len, iter }
+    }
+}
+
+const SAMPLE_TYPE_WALL_TIME: ProfileType = ProfileType::from([
+    ValueType {
+        r#type: "sample", // todo: rename "wall-time-sample"
+        unit: "count",
+    },
+    ValueType {
+        r#type: "wall-time",
+        unit: "nanoseconds",
+    },
+]);
+
+const SAMPLE_TYPE_CPU_TIME: ProfileType = ProfileType::from([ValueType {
+    r#type: "cpu-time",
+    unit: "nanoseconds",
+}]);
+
+const SAMPLE_TYPE_ALLOC: ProfileType = ProfileType::from([
+    ValueType {
+        r#type: "alloc-samples",
+        unit: "count",
+    },
+    ValueType {
+        r#type: "alloc-size",
+        unit: "bytes",
+    },
+]);
+
+const SAMPLE_TYPE_TIMELINE: ProfileType = ProfileType::from([ValueType {
+    r#type: "timeline",
+    unit: "nanoseconds",
+}]);
+
+const SAMPLE_TYPE_EXCEPTION: ProfileType = ProfileType::from([ValueType {
+    r#type: "exception-samples",
+    unit: "count",
+}]);
+
+const SAMPLE_TYPE_SOCKET_READ_TIME: ProfileType = ProfileType::from([
+    ValueType {
+        r#type: "socket-read-time",
+        unit: "nanoseconds",
+    },
+    ValueType {
+        r#type: "socket-read-time-samples",
+        unit: "count",
+    },
+]);
+
+const SAMPLE_TYPE_SOCKET_WRITE_TIME: ProfileType = ProfileType::from([
+    ValueType {
+        r#type: "socket-write-time",
+        unit: "nanoseconds",
+    },
+    ValueType {
+        r#type: "socket-write-time-samples",
+        unit: "count",
+    },
+]);
+
+const SAMPLE_TYPE_FILE_IO_READ_TIME: ProfileType = ProfileType::from([
+    ValueType {
+        r#type: "file-io-read-time",
+        unit: "nanoseconds",
+    },
+    ValueType {
+        r#type: "file-io-read-time-samples",
+        unit: "count",
+    },
+]);
+
+const SAMPLE_TYPE_FILE_IO_WRITE_TIME: ProfileType = ProfileType::from([
+    ValueType {
+        r#type: "file-io-write-time",
+        unit: "nanoseconds",
+    },
+    ValueType {
+        r#type: "file-io-write-time-samples",
+        unit: "count",
+    },
+]);
+
+const SAMPLE_TYPE_SOCKET_READ_SIZE: ProfileType = ProfileType::from([
+    ValueType {
+        r#type: "socket-read-size",
+        unit: "bytes",
+    },
+    ValueType {
+        r#type: "socket-read-size-samples",
+        unit: "count",
+    },
+]);
+
+const SAMPLE_TYPE_SOCKET_WRITE_SIZE: ProfileType = ProfileType::from([
+    ValueType {
+        r#type: "socket-write-size",
+        unit: "bytes",
+    },
+    ValueType {
+        r#type: "socket-write-size-samples",
+        unit: "count",
+    },
+]);
+
+const SAMPLE_TYPE_FILE_IO_READ_SIZE: ProfileType = ProfileType::from([
+    ValueType {
+        r#type: "file-io-read-size",
+        unit: "bytes",
+    },
+    ValueType {
+        r#type: "file-io-read-size-samples",
+        unit: "count",
+    },
+]);
+
+const SAMPLE_TYPE_FILE_IO_WRITE_SIZE: ProfileType = ProfileType::from([
+    ValueType {
+        r#type: "file-io-write-size",
+        unit: "bytes",
+    },
+    ValueType {
+        r#type: "file-io-write-size-samples",
+        unit: "count",
+    },
+]);
+
+impl SampleValue {
+    pub fn discriminant(&self) -> usize {
+        // SAFETY: SampleValue uses a primitive representation.
+        let r#repr = unsafe { *(self as *const Self as *const u8) };
+        r#repr as usize
+    }
+
+    pub fn sample_types(&self) -> ProfileType {
+        let discriminant = self.discriminant();
+        PROFILE_TYPES[discriminant]
+    }
+}
+
+pub struct SampleIter<I: Iterator> {
+    len: usize,
+    iter: I,
+}
+
+impl<I: Iterator> Iterator for SampleIter<I> {
+    type Item = I::Item;
+    fn next(&mut self) -> Option<Self::Item> {
+        let next = self.iter.next();
+        if next.is_some() {
+            self.len -= 1;
+        }
+        next
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len();
+        (len, Some(len))
+    }
+}
+
+impl<I: Iterator> ExactSizeIterator for SampleIter<I> {
+    fn len(&self) -> usize {
+        self.len
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::profiling::tests::{get_samples, get_system_settings};
+
+    #[test]
+    fn with_profiling_disabled() {
+        let mut settings = get_system_settings();
+
+        settings.profiling_enabled = false;
+        settings.profiling_allocation_enabled = false;
+        settings.profiling_experimental_cpu_time_enabled = false;
+
+        let enabled_profiles = EnabledProfiles::new(&settings);
+        let values = enabled_profiles.filter(&get_samples()).collect::<Vec<_>>();
+        let types = enabled_profiles.enabled_sample_types().collect::<Vec<_>>();
+
+        assert_eq!(types, Vec::<ValueType>::new());
+        assert_eq!(values, Vec::<i64>::new());
+    }
+
+    #[test]
+    fn with_profiling_enabled() {
+        let mut settings = get_system_settings();
+
+        settings.profiling_enabled = true;
+        settings.profiling_allocation_enabled = false;
+        settings.profiling_experimental_cpu_time_enabled = false;
+
+        let enabled_profiles = EnabledProfiles::new(&settings);
+        let values = enabled_profiles.filter(&get_samples()).collect::<Vec<_>>();
+        let types = enabled_profiles.enabled_sample_types().collect::<Vec<_>>();
+
+        assert_eq!(
+            types,
+            vec![
+                ValueType::new("sample", "count"),
+                ValueType::new("wall-time", "nanoseconds"),
+            ]
+        );
+        assert_eq!(values, vec![10, 20]);
+    }
+
+    #[test]
+    fn with_cpu_time() {
+        let mut settings = get_system_settings();
+        settings.profiling_enabled = true;
+        settings.profiling_allocation_enabled = false;
+        settings.profiling_experimental_cpu_time_enabled = true;
+
+        let enabled_profiles = EnabledProfiles::new(&settings);
+        let values = enabled_profiles.filter(&get_samples()).collect::<Vec<_>>();
+        let types = enabled_profiles.enabled_sample_types().collect::<Vec<_>>();
+
+        assert_eq!(
+            types,
+            vec![
+                ValueType::new("sample", "count"),
+                ValueType::new("wall-time", "nanoseconds"),
+                ValueType::new("cpu-time", "nanoseconds"),
+            ]
+        );
+        assert_eq!(values, vec![10, 20, 30]);
+    }
+
+    #[test]
+    fn filter_with_allocations() {
+        let mut settings = get_system_settings();
+        settings.profiling_enabled = true;
+        settings.profiling_allocation_enabled = true;
+        settings.profiling_experimental_cpu_time_enabled = false;
+
+        let enabled_profiles = EnabledProfiles::new(&settings);
+        let values = enabled_profiles.filter(&get_samples()).collect::<Vec<_>>();
+        let types = enabled_profiles.enabled_sample_types().collect::<Vec<_>>();
+
+        assert_eq!(
+            types,
+            vec![
+                ValueType::new("sample", "count"),
+                ValueType::new("wall-time", "nanoseconds"),
+                ValueType::new("alloc-samples", "count"),
+                ValueType::new("alloc-size", "bytes"),
+            ]
+        );
+        assert_eq!(values, vec![10, 20, 40, 50]);
+    }
+
+    #[test]
+    fn with_allocations_and_cpu_time() {
+        let mut settings = get_system_settings();
+        settings.profiling_enabled = true;
+        settings.profiling_allocation_enabled = true;
+        settings.profiling_experimental_cpu_time_enabled = true;
+
+        let enabled_profiles = EnabledProfiles::new(&settings);
+        let values = enabled_profiles.filter(&get_samples()).collect::<Vec<_>>();
+        let types = enabled_profiles.enabled_sample_types().collect::<Vec<_>>();
+
+        assert_eq!(
+            types,
+            vec![
+                ValueType::new("sample", "count"),
+                ValueType::new("wall-time", "nanoseconds"),
+                ValueType::new("cpu-time", "nanoseconds"),
+                ValueType::new("alloc-samples", "count"),
+                ValueType::new("alloc-size", "bytes"),
+            ]
+        );
+        assert_eq!(values, vec![10, 20, 30, 40, 50]);
+    }
+
+    #[test]
+    fn with_cpu_time_and_exceptions() {
+        let mut settings = get_system_settings();
+        settings.profiling_enabled = true;
+        settings.profiling_experimental_cpu_time_enabled = true;
+        settings.profiling_exception_enabled = true;
+
+        let enabled_profiles = EnabledProfiles::new(&settings);
+        let values = enabled_profiles.filter(&get_samples()).collect::<Vec<_>>();
+        let types = enabled_profiles.enabled_sample_types().collect::<Vec<_>>();
+
+        assert_eq!(
+            types,
+            vec![
+                ValueType::new("sample", "count"),
+                ValueType::new("wall-time", "nanoseconds"),
+                ValueType::new("cpu-time", "nanoseconds"),
+                ValueType::new("exception-samples", "count"),
+            ]
+        );
+        assert_eq!(values, vec![10, 20, 30, 70]);
+    }
+}