diff --git a/Cargo.lock b/Cargo.lock
index c79063463eb..589e0516690 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1483,6 +1483,7 @@ dependencies = [
  "crossbeam-channel",
  "datadog-alloc",
  "datadog-profiling",
+ "datadog-thin-str",
  "ddcommon 10.0.0",
  "env_logger 0.11.3",
  "indexmap 2.2.6",
@@ -1653,6 +1654,15 @@ dependencies = [
  "syn 2.0.71",
 ]
 
+[[package]]
+name = "datadog-thin-str"
+version = "1.0.0"
+dependencies = [
+ "allocator-api2",
+ "naughty-strings",
+ "tagged-pointer",
+]
+
 [[package]]
 name = "datadog-trace-normalization"
 version = "0.0.1"
@@ -3327,6 +3337,15 @@ version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a"
 
+[[package]]
+name = "naughty-strings"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77f60b021f91344453a569296aced9b149bdf75ac182cfc4631f6b55a5aa590f"
+dependencies = [
+ "serde_json",
+]
+
 [[package]]
 name = "new_debug_unreachable"
 version = "1.0.6"
@@ -5057,6 +5076,12 @@ dependencies = [
  "libc 0.2.159",
 ]
 
+[[package]]
+name = "tagged-pointer"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3538c399a85621c9b74ac21001d7e1dd81867ebd076724f047b1227e722de4a7"
+
 [[package]]
 name = "tarpc"
 version = "0.31.0"
diff --git a/profiling/Cargo.toml b/profiling/Cargo.toml
index 2f0794e1864..59b94e06e6c 100644
--- a/profiling/Cargo.toml
+++ b/profiling/Cargo.toml
@@ -21,6 +21,7 @@ chrono = { version = "0.4" }
 crossbeam-channel = { version = "0.5", default-features = false, features = ["std"] }
 datadog-alloc = { git = "https://github.com/DataDog/libdatadog", tag = "v10.0.0" }
 datadog-profiling = { git = "https://github.com/DataDog/libdatadog", tag = "v10.0.0" }
+datadog-thin-str = { version = "1", path = "../thin-str", features = ["std"] }
 ddcommon = { git = "https://github.com/DataDog/libdatadog", tag = "v10.0.0" }
 env_logger = { version = "0.11", default-features = false }
 indexmap = { version = "2.2" }
@@ -46,6 +47,10 @@ perfcnt = "0.8.0"
 name = "stack_walking"
 harness = false
 
+[[bench]]
+name = "concatenation"
+harness = false
+
 [features]
 default = ["allocation_profiling", "timeline", "exception_profiling"]
 allocation_profiling = []
diff --git a/profiling/benches/concatenation.rs b/profiling/benches/concatenation.rs
new file mode 100644
index 00000000000..5d9e4c22da4
--- /dev/null
+++ b/profiling/benches/concatenation.rs
@@ -0,0 +1,83 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+
+#[allow(unused)]
+fn extract_function_name_v1(module_name: &[u8], class_name: &[u8], method_name: &[u8]) -> Vec<u8> {
+    let mut buffer = Vec::<u8>::new();
+
+    if !module_name.is_empty() {
+        buffer.extend_from_slice(module_name);
+        buffer.push(b'|');
+    }
+
+    if !class_name.is_empty() {
+        buffer.extend_from_slice(class_name);
+        buffer.extend_from_slice(b"::");
+    }
+    buffer.extend_from_slice(method_name);
+    buffer
+}
+
+#[allow(unused)]
+fn extract_function_name_v2(module_name: &[u8], class_name: &[u8], method_name: &[u8]) -> Vec<u8> {
+    let opt_module_separator: &[u8] = if module_name.is_empty() { b"" } else { b"|" };
+    let opt_class_separator: &[u8] = if class_name.is_empty() { b"" } else { b"::" };
+    let cap = module_name.len()
+        + opt_module_separator.len()
+        + class_name.len()
+        + opt_class_separator.len()
+        + method_name.len();
+    let mut buffer = Vec::<u8>::with_capacity(cap);
+
+    buffer.extend_from_slice(module_name);
+    buffer.extend_from_slice(opt_module_separator);
+    buffer.extend_from_slice(class_name);
+    buffer.extend_from_slice(opt_class_separator);
+    buffer.extend_from_slice(method_name);
+    buffer
+}
+
+fn bench_concatenation_userland(c: &mut Criterion) {
+    c.bench_function("bench_concatenation_userland", |b| {
+        b.iter(|| {
+            for _ in 1..=100 {
+                _ = std::hint::black_box(extract_function_name_v2(
+                    b"",
+                    b"Twig\\Template",
+                    b"displayWithErrorHandling",
+                ))
+            }
+        });
+    });
+}
+
+fn bench_concatenation_internal1(c: &mut Criterion) {
+    c.bench_function("bench_concatenation_internal1", |b| {
+        b.iter(|| {
+            for _ in 1..=100 {
+                _ = std::hint::black_box(extract_function_name_v2(
+                    b"dom",
+                    b"DOMDocumentFragment",
+                    b"__construct",
+                ))
+            }
+        });
+    });
+}
+
+fn bench_concatenation_internal2(c: &mut Criterion) {
+    c.bench_function("bench_concatenation_internal2", |b| {
+        b.iter(|| {
+            for _ in 1..=100 {
+                _ = std::hint::black_box(extract_function_name_v2(b"standard", b"", b"file"))
+            }
+        });
+    });
+}
+
+criterion_group!(
+    benches,
+    bench_concatenation_userland,
+    bench_concatenation_internal1,
+    bench_concatenation_internal2,
+);
+criterion_main!(benches);
diff --git a/profiling/src/lib.rs b/profiling/src/lib.rs
index 3b3db288a02..b663a670a7b 100644
--- a/profiling/src/lib.rs
+++ b/profiling/src/lib.rs
@@ -6,8 +6,8 @@ mod logging;
 mod pcntl;
 pub mod profiling;
 mod sapi;
-mod thin_str;
 mod wall_time;
+mod well_known;
 
 #[cfg(php_run_time_cache)]
 mod string_set;
@@ -313,7 +313,7 @@ extern "C" fn minit(_type: c_int, module_number: c_int) -> ZendResult {
     };
 
     /* Currently, the engine is always copying this struct. Every time a new
-     * PHP version is released, we should double check zend_register_extension
+     * PHP version is released, we should double-check zend_register_extension
      * to ensure the address is not mutated nor stored. Well, hopefully we
      * catch it _before_ a release.
      */
diff --git a/profiling/src/profiling/mod.rs b/profiling/src/profiling/mod.rs
index 7685e0cc52f..43d6a424909 100644
--- a/profiling/src/profiling/mod.rs
+++ b/profiling/src/profiling/mod.rs
@@ -17,6 +17,7 @@ use crate::bindings::ddog_php_prof_get_active_fiber_test as ddog_php_prof_get_ac
 
 use crate::bindings::{datadog_php_profiling_get_profiling_context, zend_execute_data};
 use crate::config::SystemSettings;
+use crate::well_known::WellKnown;
 use crate::{CLOCKS, TAGS};
 use chrono::Utc;
 use core::{ptr, str};
@@ -26,6 +27,7 @@ use datadog_profiling::api::{
 };
 use datadog_profiling::exporter::Tag;
 use datadog_profiling::internal::Profile as InternalProfile;
+use datadog_thin_str::ThinString;
 use log::{debug, info, trace, warn};
 use once_cell::sync::OnceCell;
 use std::borrow::Cow;
@@ -49,6 +51,9 @@ use datadog_profiling::api::UpscalingInfo;
 
 #[cfg(feature = "exception_profiling")]
 use crate::exception::EXCEPTION_PROFILING_INTERVAL;
+#[cfg(feature = "timeline")]
+use crate::timeline::IncludeType;
+use crate::timeline::State;
 
 const UPLOAD_PERIOD: Duration = Duration::from_secs(67);
 
@@ -514,9 +519,6 @@ pub enum UploadMessage {
     Upload(Box<UploadRequest>),
 }
 
-#[cfg(feature = "timeline")]
-const COW_EVAL: Cow<str> = Cow::Borrowed("[eval]");
-
 const DDPROF_TIME: &str = "ddprof_time";
 const DDPROF_UPLOAD: &str = "ddprof_upload";
 
@@ -901,20 +903,23 @@ impl Profiler {
     }
 
     #[cfg(feature = "timeline")]
-    const TIMELINE_COMPILE_FILE_LABELS: &'static [Label] = &[Label {
-        key: "event",
-        value: LabelValue::Str(Cow::Borrowed("compilation")),
-    }];
+    pub fn timeline_compile_file_labels(extra_labels: usize) -> Vec<Label> {
+        let mut labels = Profiler::common_labels(extra_labels + 1);
+        labels.push(Label {
+            key: "event",
+            value: LabelValue::Str(WellKnown::Compilation.into()),
+        });
+        labels
+    }
 
     #[cfg(feature = "timeline")]
-    pub fn collect_compile_string(&self, now: i64, duration: i64, filename: String, line: u32) {
-        let mut labels = Profiler::common_labels(Self::TIMELINE_COMPILE_FILE_LABELS.len());
-        labels.extend_from_slice(Self::TIMELINE_COMPILE_FILE_LABELS);
+    pub fn collect_compile_string(&self, now: i64, duration: i64, filename: ThinString, line: u32) {
+        let labels = Self::timeline_compile_file_labels(0);
         let n_labels = labels.len();
 
         match self.prepare_and_send_message(
             vec![ZendFrame {
-                function: COW_EVAL,
+                function: WellKnown::BracketedEval.into(),
                 file: Some(filename),
                 line,
             }],
@@ -942,20 +947,19 @@ impl Profiler {
         now: i64,
         duration: i64,
         filename: String,
-        include_type: &str,
+        include_type: IncludeType,
     ) {
-        let mut labels = Profiler::common_labels(Self::TIMELINE_COMPILE_FILE_LABELS.len() + 1);
-        labels.extend_from_slice(Self::TIMELINE_COMPILE_FILE_LABELS);
+        let mut labels = Self::timeline_compile_file_labels(1);
         labels.push(Label {
             key: "filename",
-            value: LabelValue::Str(Cow::from(filename)),
+            value: LabelValue::Str(Cow::Owned(filename)),
         });
 
         let n_labels = labels.len();
 
         match self.prepare_and_send_message(
             vec![ZendFrame {
-                function: format!("[{include_type}]").into(),
+                function: include_type.to_bracketed_thin_string(),
                 file: None,
                 line: 0,
             }],
@@ -979,19 +983,19 @@ impl Profiler {
 
     /// This function will collect a thread start or stop timeline event
     #[cfg(all(feature = "timeline", php_zts))]
-    pub fn collect_thread_start_end(&self, now: i64, event: &'static str) {
-        let mut labels = Profiler::common_labels(1);
-
+    pub fn collect_thread_start_end(&self, now: i64, state: State) {
+        let mut labels = Self::timeline_compile_file_labels(1);
         labels.push(Label {
             key: "event",
-            value: LabelValue::Str(std::borrow::Cow::Borrowed(event)),
+            value: LabelValue::Str(state.to_cow_str()),
         });
 
+        let event = state.to_cow_str();
         let n_labels = labels.len();
 
         match self.prepare_and_send_message(
             vec![ZendFrame {
-                function: format!("[{event}]").into(),
+                function: state.to_bracketed_thin_string(),
                 file: None,
                 line: 0,
             }],
@@ -1013,23 +1017,23 @@ impl Profiler {
 
     /// This function can be called to collect any fatal errors
     #[cfg(feature = "timeline")]
-    pub fn collect_fatal(&self, now: i64, file: String, line: u32, message: String) {
+    pub fn collect_fatal(&self, now: i64, file: ThinString, line: u32, message: String) {
         let mut labels = Profiler::common_labels(2);
 
         labels.push(Label {
             key: "event",
-            value: LabelValue::Str("fatal".into()),
+            value: LabelValue::Str(WellKnown::Fatal.into()),
         });
         labels.push(Label {
             key: "message",
-            value: LabelValue::Str(message.into()),
+            value: LabelValue::Str(Cow::Owned(message)),
         });
 
         let n_labels = labels.len();
 
         match self.prepare_and_send_message(
             vec![ZendFrame {
-                function: "[fatal]".into(),
+                function: WellKnown::BracketedFatal.into(),
                 file: Some(file),
                 line,
             }],
@@ -1056,7 +1060,7 @@ impl Profiler {
     pub(crate) fn collect_opcache_restart(
         &self,
         now: i64,
-        file: String,
+        file: ThinString,
         line: u32,
         reason: &'static str,
     ) {
@@ -1064,7 +1068,7 @@ impl Profiler {
 
         labels.push(Label {
             key: "event",
-            value: LabelValue::Str("opcache_restart".into()),
+            value: LabelValue::Str(WellKnown::OpcacheRestart.into()),
         });
         labels.push(Label {
             key: "reason",
@@ -1097,19 +1101,19 @@ impl Profiler {
 
     /// This function can be called to collect any kind of inactivity that is happening
     #[cfg(feature = "timeline")]
-    pub fn collect_idle(&self, now: i64, duration: i64, reason: &'static str) {
+    pub fn collect_idle(&self, now: i64, duration: i64, state: State) {
         let mut labels = Profiler::common_labels(1);
 
         labels.push(Label {
             key: "event",
-            value: LabelValue::Str(reason.into()),
+            value: LabelValue::Str(state.to_cow_str()),
         });
 
         let n_labels = labels.len();
 
         match self.prepare_and_send_message(
             vec![ZendFrame {
-                function: "[idle]".into(),
+                function: WellKnown::BracketedIdle.into(),
                 file: None,
                 line: 0,
             }],
@@ -1136,7 +1140,7 @@ impl Profiler {
         &self,
         now: i64,
         duration: i64,
-        reason: &'static str,
+        reason: WellKnown,
         collected: i64,
         #[cfg(php_gc_status)] runs: i64,
     ) {
@@ -1144,12 +1148,12 @@ impl Profiler {
 
         labels.push(Label {
             key: "event",
-            value: LabelValue::Str(Cow::Borrowed("gc")),
+            value: LabelValue::Str(WellKnown::BracketedGc.into()),
         });
 
         labels.push(Label {
             key: "gc reason",
-            value: LabelValue::Str(Cow::from(reason)),
+            value: LabelValue::Str(reason.into()),
         });
 
         #[cfg(php_gc_status)]
@@ -1165,7 +1169,7 @@ impl Profiler {
 
         match self.prepare_and_send_message(
             vec![ZendFrame {
-                function: "[gc]".into(),
+                function: WellKnown::BracketedGc.into(),
                 file: None,
                 line: 0,
             }],
@@ -1177,10 +1181,16 @@ impl Profiler {
             now,
         ) {
             Ok(_) => {
-                trace!("Sent event 'gc' with {n_labels} labels and reason {reason} to profiler.")
+                trace!(
+                    "Sent event 'gc' with {n_labels} labels and reason {} to profiler.",
+                    ThinString::from(reason).as_ref(),
+                )
             }
             Err(err) => {
-                warn!("Failed to send event 'gc' with {n_labels} and reason {reason} labels to profiler: {err}")
+                warn!(
+                    "Failed to send event 'gc' with {n_labels} and reason {} labels to profiler: {err}",
+                    ThinString::from(reason).as_ref(),
+                )
             }
         }
     }
@@ -1193,7 +1203,7 @@ impl Profiler {
         let mut labels = Vec::with_capacity(5 + n_extra_labels);
         labels.push(Label {
             key: "thread id",
-            value: LabelValue::Num(unsafe { libc::pthread_self() as i64 }, "id".into()),
+            value: LabelValue::Num(unsafe { libc::pthread_self() as i64 }, Some("id")),
         });
 
         labels.push(Label {
@@ -1230,10 +1240,11 @@ impl Profiler {
             // there's nothing changing that value in all of fibers
             // afterwards, from start to destruction of the fiber itself.
             let func = unsafe { &*fiber.fci_cache.function_handler };
-            if let Some(functionname) = extract_function_name(func) {
+            if let Some(buffer) = extract_function_name_into_buffer(func) {
+                let functionname = String::from_utf8_lossy(buffer.as_slice()).into_owned();
                 labels.push(Label {
                     key: "fiber",
-                    value: LabelValue::Str(functionname.into()),
+                    value: LabelValue::Str(Cow::Owned(functionname)),
                 });
             }
         }
@@ -1287,12 +1298,16 @@ mod tests {
     use super::*;
     use crate::config::AgentEndpoint;
     use datadog_profiling::exporter::Uri;
+    use datadog_thin_str::ConstStorage;
     use log::LevelFilter;
 
     fn get_frames() -> Vec<ZendFrame> {
+        static FOOBAR: ConstStorage<8> = ConstStorage::from_str("foobar()");
+        static FOOBAR_PHP: ConstStorage<10> = ConstStorage::from_str("foobar.php");
+
         vec![ZendFrame {
-            function: "foobar()".into(),
-            file: Some("foobar.php".into()),
+            function: ThinString::from(&FOOBAR),
+            file: Some(ThinString::from(&FOOBAR_PHP)),
             line: 42,
         }]
     }
diff --git a/profiling/src/profiling/stack_walking.rs b/profiling/src/profiling/stack_walking.rs
index 38e1e6b5751..3695d9a6c07 100644
--- a/profiling/src/profiling/stack_walking.rs
+++ b/profiling/src/profiling/stack_walking.rs
@@ -1,23 +1,24 @@
 use crate::bindings::{zai_str_from_zstr, zend_execute_data, zend_function};
-use std::borrow::Cow;
+use crate::well_known::WellKnown;
+use datadog_alloc::Global;
+use datadog_thin_str::ThinString;
+use std::ops::Deref;
 use std::str::Utf8Error;
 
 #[cfg(php_frameless)]
 use crate::bindings::zend_flf_functions;
+
 #[cfg(php_frameless)]
 use crate::bindings::{
     ZEND_FRAMELESS_ICALL_0, ZEND_FRAMELESS_ICALL_1, ZEND_FRAMELESS_ICALL_2, ZEND_FRAMELESS_ICALL_3,
 };
 
-const COW_PHP_OPEN_TAG: Cow<str> = Cow::Borrowed("<?php");
-const COW_TRUNCATED: Cow<str> = Cow::Borrowed("[truncated]");
-
 #[derive(Default, Debug)]
 pub struct ZendFrame {
     // Most tools don't like frames that don't have function names, so use a
     // fake name if you need to like "<?php".
-    pub function: Cow<'static, str>,
-    pub file: Option<String>,
+    pub function: ThinString,
+    pub file: Option<ThinString>,
     pub line: u32, // use 0 for no line info
 }
 
@@ -30,7 +31,13 @@ pub struct ZendFrame {
 /// Namespaces are part of the class_name or function_name respectively.
 /// Closures and anonymous classes get reformatted by the backend (or maybe
 /// frontend, either way it's not our concern, at least not right now).
-pub fn extract_function_name(func: &zend_function) -> Option<String> {
+pub fn extract_function_name(func: &zend_function) -> Option<ThinString> {
+    let buffer = extract_function_name_into_buffer(func)?;
+    let lossy = String::from_utf8_lossy(buffer.as_slice());
+    Some(ThinString::from_str_in(&lossy, Global))
+}
+
+pub fn extract_function_name_into_buffer(func: &zend_function) -> Option<Vec<u8>> {
     let method_name: &[u8] = func.name().unwrap_or(b"");
 
     /* The top of the stack seems to reasonably often not have a function, but
@@ -42,32 +49,37 @@ pub fn extract_function_name(func: &zend_function) -> Option<String> {
         return None;
     }
 
-    let mut buffer = Vec::<u8>::new();
-
     // User functions do not have a "module". Maybe one day use composer info?
     let module_name = func.module_name().unwrap_or(b"");
-    if !module_name.is_empty() {
-        buffer.extend_from_slice(module_name);
-        buffer.push(b'|');
-    }
-
     let class_name = func.scope_name().unwrap_or(b"");
-    if !class_name.is_empty() {
-        buffer.extend_from_slice(class_name);
-        buffer.extend_from_slice(b"::");
-    }
-
+    let opt_module_separator: &[u8] = if module_name.is_empty() { b"" } else { b"|" };
+    let opt_class_separator: &[u8] = if class_name.is_empty() { b"" } else { b"::" };
+
+    // Precalculating the allocation size and removing the conditionals was
+    // shown to be faster in criterion benchmarks.
+    let cap = module_name.len()
+        + opt_module_separator.len()
+        + class_name.len()
+        + opt_class_separator.len()
+        + method_name.len();
+    let mut buffer = Vec::<u8>::with_capacity(cap);
+
+    buffer.extend_from_slice(module_name);
+    buffer.extend_from_slice(opt_module_separator);
+    buffer.extend_from_slice(class_name);
+    buffer.extend_from_slice(opt_class_separator);
     buffer.extend_from_slice(method_name);
 
-    Some(String::from_utf8_lossy(buffer.as_slice()).into_owned())
+    Some(buffer)
 }
 
-unsafe fn extract_file_and_line(execute_data: &zend_execute_data) -> (Option<String>, u32) {
+unsafe fn extract_file_and_line(execute_data: &zend_execute_data) -> (Option<ThinString>, u32) {
     // This should be Some, just being cautious.
     match execute_data.func.as_ref() {
         Some(func) if !func.is_internal() => {
             // Safety: zai_str_from_zstr will return a valid ZaiStr.
-            let file = zai_str_from_zstr(func.op_array.filename.as_mut()).into_string();
+            let file_lossy = zai_str_from_zstr(func.op_array.filename.as_mut()).into_string_lossy();
+            let file = ThinString::from_str_in(file_lossy.deref(), Global);
             let lineno = match execute_data.opline.as_ref() {
                 Some(opline) => opline.lineno,
                 None => 0,
@@ -82,9 +94,10 @@ unsafe fn extract_file_and_line(execute_data: &zend_execute_data) -> (Option<Str
 mod detail {
     use super::*;
     use crate::string_set::StringSet;
-    use crate::thin_str::ThinStr;
+    use datadog_thin_str::{ThinHeader, ThinStr};
     use log::{debug, trace};
     use std::cell::RefCell;
+    use std::ops::Deref;
     use std::ptr::NonNull;
 
     struct StringCache<'a> {
@@ -95,34 +108,37 @@ mod detail {
         string_set: &'a mut StringSet,
     }
 
+    #[repr(usize)]
+    enum CacheSlot {
+        Function = 0,
+        Filename = 1,
+    }
+
     impl<'a> StringCache<'a> {
         /// Makes a copy of the string in the cache slot. If there isn't a
         /// string in the slot currently, then create one by calling the
         /// provided function, store it in the string cache and cache slot,
         /// and return it.
-        fn get_or_insert<F>(&mut self, slot: usize, f: F) -> Option<String>
+        fn get_or_insert<F>(&mut self, slot: CacheSlot, f: F) -> Option<ThinString>
         where
-            F: FnOnce() -> Option<String>,
+            F: FnOnce() -> Option<ThinString>,
         {
-            debug_assert!(slot < self.cache_slots.len());
-            let cached = unsafe { self.cache_slots.get_unchecked_mut(slot) };
+            // SAFETY: the slot is in-bounds from CacheSlot -> usize conv.
+            let cached = unsafe { self.cache_slots.get_unchecked_mut(slot as usize) };
 
-            let ptr = *cached as *mut u8;
+            let ptr = *cached as *mut ThinHeader;
             match NonNull::new(ptr) {
                 Some(non_null) => {
-                    // SAFETY: transmuting ThinStr from its repr.
-                    let thin_str: ThinStr = unsafe { core::mem::transmute(non_null) };
                     // SAFETY: the string set is only reset between requests,
-                    // so this ThinStr points into the same string set that
-                    // created it.
-                    let str = unsafe { self.string_set.get_thin_str(thin_str) };
-                    Some(str.to_string())
+                    // so this ThinStr points into the same string set arena
+                    // that created it.
+                    let thin_str: ThinStr = unsafe { ThinStr::from_header(non_null) };
+                    Some(ThinString::from_str_in(thin_str.deref(), Global))
                 }
                 None => {
                     let string = f()?;
                     let thin_str = self.string_set.insert(&string);
-                    // SAFETY: transmuting ThinStr into its repr.
-                    let non_null: NonNull<u8> = unsafe { core::mem::transmute(thin_str) };
+                    let non_null = thin_str.header_ptr();
                     *cached = non_null.as_ptr() as usize;
                     Some(string)
                 }
@@ -221,7 +237,7 @@ mod detail {
                                     &**zend_flf_functions.offset(opline.extended_value as isize)
                                 };
                                 samples.push(ZendFrame {
-                                    function: extract_function_name(func).map(Cow::Owned).unwrap(),
+                                    function: extract_function_name(func).unwrap(),
                                     file: None,
                                     line: 0,
                                 });
@@ -240,7 +256,7 @@ mod detail {
                          */
                         if samples.len() == max_depth - 1 {
                             samples.push(ZendFrame {
-                                function: COW_TRUNCATED,
+                                function: ThinString::from(WellKnown::BracketedTruncated),
                                 file: None,
                                 line: 0,
                             });
@@ -292,7 +308,7 @@ mod detail {
                     let mut stats = cell.borrow_mut();
                     stats.not_applicable += 1;
                 });
-                let function = extract_function_name(func).map(Cow::Owned);
+                let function = extract_function_name(func);
                 let (file, line) = extract_file_and_line(execute_data);
                 (function, file, line)
             }
@@ -300,7 +316,7 @@ mod detail {
 
         if function.is_some() || file.is_some() {
             Some(ZendFrame {
-                function: function.unwrap_or(COW_PHP_OPEN_TAG),
+                function: function.unwrap_or(WellKnown::PhpOpenTag.into()),
                 file,
                 line,
             })
@@ -312,16 +328,17 @@ mod detail {
     fn handle_function_cache_slot(
         func: &zend_function,
         string_cache: &mut StringCache,
-    ) -> Option<Cow<'static, str>> {
-        let fname = string_cache.get_or_insert(0, || extract_function_name(func))?;
-        Some(Cow::Owned(fname))
+    ) -> Option<ThinString> {
+        let fname =
+            string_cache.get_or_insert(CacheSlot::Function, || extract_function_name(func))?;
+        Some(ThinString::from_str_in(&fname, Global))
     }
 
     unsafe fn handle_file_cache_slot(
         execute_data: &zend_execute_data,
         string_cache: &mut StringCache,
-    ) -> (Option<String>, u32) {
-        let option = string_cache.get_or_insert(1, || -> Option<String> {
+    ) -> (Option<ThinString>, u32) {
+        let option = string_cache.get_or_insert(CacheSlot::Filename, || -> Option<ThinString> {
             unsafe {
                 // Safety: if we have cache slots, we definitely have a func.
                 let func = &*execute_data.func;
@@ -330,7 +347,9 @@ mod detail {
                 };
 
                 // SAFETY: calling C function with correct args.
-                let file = zai_str_from_zstr(func.op_array.filename.as_mut()).into_string();
+                let file_lossy =
+                    zai_str_from_zstr(func.op_array.filename.as_mut()).into_string_lossy();
+                let file = ThinString::from_str_in(file_lossy.deref(), Global);
                 Some(file)
             }
         });
@@ -341,7 +360,7 @@ mod detail {
                     Some(opline) => opline.lineno,
                     None => 0,
                 };
-                (Some(filename), lineno)
+                (Some(ThinString::from_str_in(&filename, Global)), lineno)
             }
             None => (None, 0),
         }
@@ -380,7 +399,7 @@ mod detail {
                  */
                 if samples.len() == max_depth - 1 {
                     samples.push(ZendFrame {
-                        function: COW_TRUNCATED,
+                        function: WellKnown::BracketedTruncated.into(),
                         file: None,
                         line: 0,
                     });
@@ -401,7 +420,7 @@ mod detail {
             // Only create a new frame if there's file or function info.
             if file.is_some() || function.is_some() {
                 // If there's no function name, use a fake name.
-                let function = function.map(Cow::Owned).unwrap_or(COW_PHP_OPEN_TAG);
+                let function = function.unwrap_or(WellKnown::PhpOpenTag.into());
                 return Some(ZendFrame {
                     function,
                     file,
@@ -415,6 +434,17 @@ mod detail {
 
 pub use detail::*;
 
+#[cfg(test)]
+mod size_tests {
+    use super::*;
+    use core::mem::size_of;
+
+    #[test]
+    fn test_frame_size() {
+        assert_eq!(size_of::<ZendFrame>(), size_of::<usize>() * 3);
+    }
+}
+
 #[cfg(all(test, stack_walking_tests))]
 mod tests {
     use super::*;
diff --git a/profiling/src/string_set.rs b/profiling/src/string_set.rs
index 5a8a89fa01d..bf3c146ef4a 100644
--- a/profiling/src/string_set.rs
+++ b/profiling/src/string_set.rs
@@ -1,7 +1,6 @@
-use crate::thin_str::ThinStr;
 use core::hash;
-use core::ops::Deref;
 use datadog_alloc::{ChainAllocator, VirtualAllocator};
+use datadog_thin_str::*;
 
 type Hasher = hash::BuildHasherDefault<rustc_hash::FxHasher>;
 type HashSet<K> = std::collections::HashSet<K, Hasher>;
@@ -77,13 +76,15 @@ impl StringSet {
                 // No match. Make a new string in the arena, and fudge its
                 // lifetime to appease the borrow checker.
                 let new_str = {
-                    let s = ThinStr::try_from_str_in(str, &self.arena)
+                    let owned = ThinString::try_from_str_in(str, &self.arena)
                         .expect("allocation for StringSet::insert to succeed");
 
+                    let borrowed = owned.as_thin_str();
+
                     // SAFETY: all references to this value get re-narrowed to
                     // the lifetime of the string set. The string set will
                     // keep the arena alive, making the access safe.
-                    unsafe { core::mem::transmute::<ThinStr<'_>, ThinStr<'static>>(s) }
+                    unsafe { core::mem::transmute::<ThinStr<'_>, ThinStr<'static>>(borrowed) }
                 };
 
                 // Add it to the set.
@@ -101,16 +102,4 @@ impl StringSet {
     pub fn arena_used_bytes(&self) -> usize {
         self.arena.used_bytes()
     }
-
-    /// Creates a `&str` from the `thin_str`, binding it to the lifetime of
-    /// the set.
-    ///
-    /// # Safety
-    /// The `thin_str` must live in this string set.
-    #[inline]
-    pub unsafe fn get_thin_str(&self, thin_str: ThinStr) -> &str {
-        // todo: debug_assert it exists in the memory region?
-        // SAFETY: see function's safety conditions.
-        unsafe { core::mem::transmute(thin_str.deref()) }
-    }
 }
diff --git a/profiling/src/thin_str.rs b/profiling/src/thin_str.rs
deleted file mode 100644
index 01fd8a2f8cb..00000000000
--- a/profiling/src/thin_str.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-use datadog_alloc::{AllocError, Allocator, ChainAllocator};
-use std::alloc::Layout;
-use std::borrow::Borrow;
-use std::hash;
-use std::marker::PhantomData;
-use std::ops::Deref;
-use std::ptr::NonNull;
-
-/// A struct which acts like a thin &str. It does this by storing the size
-/// of the string just before the bytes of the string.
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub struct ThinStr<'a> {
-    thin_ptr: ThinPtr,
-
-    /// Since [ThinStr] doesn't hold a reference but acts like one, indicate
-    /// this to the compiler with phantom data. This takes up no space.
-    _marker: PhantomData<&'a str>,
-}
-
-pub trait ArenaAllocator: Allocator {}
-
-impl<A: Allocator + Clone> ArenaAllocator for ChainAllocator<A> {}
-
-impl ThinStr<'static> {
-    pub fn new() -> ThinStr<'static> {
-        Self {
-            thin_ptr: EMPTY_INLINE_STRING.as_thin_ptr(),
-            _marker: PhantomData,
-        }
-    }
-}
-
-impl Default for ThinStr<'static> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<'a> ThinStr<'a> {
-    // todo: move ArenaAllocator trait to `datadog_alloc` as a marker trait
-    //       (meaning, remove the associated method and leave that in prof)?
-    #[allow(dead_code)]
-    pub fn try_from_str_in(str: &str, arena: &'a impl ArenaAllocator) -> Result<Self, AllocError> {
-        let thin_ptr = ThinPtr::try_from_str_in(str, arena)?;
-        let _marker = PhantomData;
-        Ok(Self { thin_ptr, _marker })
-    }
-
-    /// Gets the layout of a ThinStr, such as to deallocate it.
-    #[allow(unused)]
-    #[inline]
-    pub fn layout(&self) -> Layout {
-        self.thin_ptr.layout()
-    }
-}
-
-impl<'a> Deref for ThinStr<'a> {
-    type Target = str;
-
-    fn deref(&self) -> &Self::Target {
-        let slice = {
-            let len = self.thin_ptr.len();
-            let data = self.thin_ptr.data().as_ptr();
-
-            // SAFETY: bytes are never handed out as mut, so const slices are
-            // not going to break aliasing rules, and this is the correct
-            // lifetime for the data.
-            unsafe { core::slice::from_raw_parts(data, len) }
-        };
-
-        // SAFETY: since this is a copy of a valid utf-8 string, then it must
-        // also be valid utf-8.
-        unsafe { core::str::from_utf8_unchecked(slice) }
-    }
-}
-
-impl<'a> hash::Hash for ThinStr<'a> {
-    fn hash<H: hash::Hasher>(&self, state: &mut H) {
-        self.deref().hash(state)
-    }
-}
-
-impl<'a> PartialEq for ThinStr<'a> {
-    fn eq(&self, other: &Self) -> bool {
-        self.deref().eq(other.deref())
-    }
-}
-
-impl<'a> Eq for ThinStr<'a> {}
-
-impl<'a> Borrow<str> for ThinStr<'a> {
-    fn borrow(&self) -> &str {
-        self.deref()
-    }
-}
-
-#[derive(Clone, Copy)]
-struct ThinPtr {
-    /// Points to the beginning of a struct which looks like this:
-    /// ```
-    /// #[repr(C)]
-    /// struct InlineString {
-    ///     /// Stores the len of `data`.
-    ///     size: [u8; core::mem::size_of::<usize>()],
-    ///     data: [u8],
-    /// }
-    /// ```
-    size_ptr: NonNull<u8>,
-}
-
-impl ThinPtr {
-    /// Reads the size prefix to get the length of the string.
-    const fn len(self) -> usize {
-        // SAFETY: ThinStr points to the size prefix of the string.
-        let size = unsafe { self.size_ptr.cast::<[u8; USIZE_WIDTH]>().as_ptr().read() };
-        usize::from_ne_bytes(size)
-    }
-
-    /// Returns a pointer to the string data (not to the header).
-    const fn data(self) -> NonNull<u8> {
-        // SAFETY: ThinStr points to the size prefix of the string, and the
-        // string data is located immediately after without padding.
-        let ptr = unsafe { self.size_ptr.as_ptr().add(USIZE_WIDTH) };
-
-        // SAFETY: derived from a NonNull, so it's also NonNull.
-        unsafe { NonNull::new_unchecked(ptr) }
-    }
-
-    /// Gets the layout of a ThinStr, such as to deallocate it.
-    #[allow(unused)]
-    #[inline]
-    fn layout(self) -> Layout {
-        let len = self.len();
-        // SAFETY: since this object exists, its layout must be valid.
-        unsafe { Layout::from_size_align_unchecked(len + USIZE_WIDTH, 1) }
-    }
-
-    fn try_from_str_in(str: &str, arena: &impl Allocator) -> Result<Self, AllocError> {
-        let inline_size = str.len() + USIZE_WIDTH;
-
-        let layout = match Layout::from_size_align(inline_size, 1) {
-            Ok(l) => l,
-            Err(_) => return Err(AllocError),
-        };
-        let allocation = arena.allocate(layout)?.cast::<u8>().as_ptr();
-
-        let size = allocation.cast::<[u8; USIZE_WIDTH]>();
-        // SAFETY: writing into uninitialized new allocation at correct place.
-        unsafe { size.write(str.len().to_ne_bytes()) };
-
-        // SAFETY: the data pointer is just after the header, and the
-        // allocation is at least that long.
-        let data = unsafe { allocation.add(USIZE_WIDTH) };
-
-        // SAFETY: the allocation is big enough, locations are distinct, and
-        // the alignment is 1 (so it's always aligned), and the memory is safe
-        // for writing.
-        unsafe { core::ptr::copy_nonoverlapping(str.as_bytes().as_ptr(), data, str.len()) };
-
-        let size_ptr = unsafe { NonNull::new_unchecked(allocation) };
-        Ok(ThinPtr { size_ptr })
-    }
-}
-
-#[repr(C)]
-struct StaticInlineString<const N: usize> {
-    /// Stores the len of `data`.
-    size: [u8; core::mem::size_of::<usize>()],
-    data: [u8; N],
-}
-
-impl<const N: usize> StaticInlineString<N> {
-    fn as_thin_ptr(&self) -> ThinPtr {
-        let ptr = core::ptr::addr_of!(EMPTY_INLINE_STRING).cast::<u8>();
-        // SAFETY: derived from static address, and ThinStr does not allow
-        // modifications, so the mut-cast is also fine.
-        let size_ptr = unsafe { NonNull::new_unchecked(ptr.cast_mut()) };
-        ThinPtr { size_ptr }
-    }
-}
-
-const USIZE_WIDTH: usize = core::mem::size_of::<usize>();
-
-static EMPTY_INLINE_STRING: StaticInlineString<0> = StaticInlineString::<0> {
-    size: [0; USIZE_WIDTH],
-    data: [],
-};
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use datadog_alloc::Global;
-    use datadog_profiling::collections::string_table::wordpress_test_data;
-
-    // Not really, please manually de-allocate strings when done with them.
-    impl ArenaAllocator for Global {}
-
-    #[test]
-    fn test_allocation_and_deallocation() {
-        let alloc = Global;
-
-        let mut thin_strs: Vec<ThinStr> = wordpress_test_data::WORDPRESS_STRINGS
-            .iter()
-            .map(|str| {
-                let thin_str = ThinStr::try_from_str_in(str, &alloc).unwrap();
-                let actual = thin_str.deref();
-                assert_eq!(*str, actual);
-                thin_str
-            })
-            .collect();
-
-        // This could detect out-of-bounds writes.
-        for (thin_str, str) in thin_strs.iter().zip(wordpress_test_data::WORDPRESS_STRINGS) {
-            let actual = thin_str.deref();
-            assert_eq!(str, actual);
-        }
-
-        for thin_str in thin_strs.drain(..) {
-            unsafe { alloc.deallocate(thin_str.thin_ptr.size_ptr, thin_str.layout()) };
-        }
-    }
-}
diff --git a/profiling/src/timeline.rs b/profiling/src/timeline.rs
index efbbd9a1f4b..ef29023020b 100644
--- a/profiling/src/timeline.rs
+++ b/profiling/src/timeline.rs
@@ -1,19 +1,63 @@
 use crate::profiling::Profiler;
+use crate::well_known::WellKnown;
 use crate::zend::{
     self, zai_str_from_zstr, zend_execute_data, zend_get_executed_filename_ex, zval,
     InternalFunctionHandler,
 };
 use crate::REQUEST_LOCALS;
+use datadog_alloc::Global;
+use datadog_thin_str::ThinString;
 use ddcommon::cstr;
 use libc::c_char;
 use log::{error, trace};
+use std::borrow::Cow;
 #[cfg(php_zts)]
 use std::cell::Cell;
 use std::cell::RefCell;
-use std::ptr;
-use std::time::Instant;
-use std::time::SystemTime;
-use std::time::UNIX_EPOCH;
+use std::ops::Deref;
+use std::time::{Instant, SystemTime, UNIX_EPOCH};
+use std::{fmt, ptr};
+
+#[derive(Copy, Clone, Debug)]
+pub enum IncludeType {
+    Include,
+    Require,
+    Unknown,
+}
+
+impl IncludeType {
+    pub fn to_thin_string(self) -> ThinString {
+        match self {
+            IncludeType::Include => WellKnown::Include.into(),
+            IncludeType::Require => WellKnown::Require.into(),
+            IncludeType::Unknown => WellKnown::Unknown.into(),
+        }
+    }
+
+    pub fn to_bracketed_thin_string(self) -> ThinString {
+        match self {
+            IncludeType::Include => WellKnown::BracketedInclude.into(),
+            IncludeType::Require => WellKnown::BracketedRequire.into(),
+            IncludeType::Unknown => WellKnown::BracketedUnknownIncludeType.into(),
+        }
+    }
+}
+
+impl From<u32> for IncludeType {
+    fn from(value: u32) -> Self {
+        match value {
+            zend::ZEND_INCLUDE => IncludeType::Include,
+            zend::ZEND_REQUIRE => IncludeType::Require,
+            _ => IncludeType::Unknown,
+        }
+    }
+}
+
+impl fmt::Display for IncludeType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.to_thin_string().deref())
+    }
+}
 
 /// The engine's original (or neighbouring extensions) `gc_collect_cycles()` function
 static mut PREV_GC_COLLECT_CYCLES: Option<zend::VmGcCollectCyclesFn> = None;
@@ -36,7 +80,8 @@ thread_local! {
     static IS_NEW_THREAD: Cell<bool> = const { Cell::new(false) };
 }
 
-enum State {
+#[derive(Copy, Clone)]
+pub enum State {
     Idle,
     Sleeping,
     Select,
@@ -47,15 +92,37 @@ enum State {
 }
 
 impl State {
-    fn as_str(&self) -> &'static str {
+    fn to_other<T: From<WellKnown>>(self) -> T {
         match self {
-            State::Idle => "idle",
-            State::Sleeping => "sleeping",
-            State::Select => "select",
+            State::Idle => WellKnown::Idle.into(),
+            State::Sleeping => WellKnown::Sleeping.into(),
+            State::Select => WellKnown::Select.into(),
+
             #[cfg(php_zts)]
-            State::ThreadStart => "thread start",
+            State::ThreadStart => WellKnown::ThreadStart.into(),
             #[cfg(php_zts)]
-            State::ThreadStop => "thread stop",
+            State::ThreadStop => WellKnown::ThreadStop.into(),
+        }
+    }
+
+    pub fn to_cow_str(self) -> Cow<'static, str> {
+        self.to_other()
+    }
+
+    pub fn to_thin_string(self) -> ThinString {
+        self.to_other()
+    }
+
+    pub fn to_bracketed_thin_string(self) -> ThinString {
+        match self {
+            State::Idle => WellKnown::BracketedIdle.into(),
+            State::Sleeping => WellKnown::BracketedSleeping.into(),
+            State::Select => WellKnown::BracketedSelect.into(),
+
+            #[cfg(php_zts)]
+            State::ThreadStart => WellKnown::BracketedThreadStart.into(),
+            #[cfg(php_zts)]
+            State::ThreadStop => WellKnown::BracketedThreadStop.into(),
         }
     }
 }
@@ -99,7 +166,7 @@ fn sleeping_fn(
         // Safety: `unwrap` can be unchecked, as we checked for `is_err()`
         let now = unsafe { now.unwrap_unchecked().as_nanos() } as i64;
         let duration = duration.as_nanos() as i64;
-        profiler.collect_idle(now, duration, state.as_str());
+        profiler.collect_idle(now, duration, state);
     }
 }
 
@@ -208,13 +275,13 @@ unsafe extern "C" fn ddog_php_prof_zend_error_observer(
     #[cfg(not(zend_error_observer_80))]
     let filename_str = unsafe { zai_str_from_zstr(file.as_mut()) };
 
-    let filename = filename_str.to_string_lossy().into_owned();
+    let filename = ThinString::from_str_in(filename_str.to_string_lossy().as_ref(), Global);
 
     let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
     if let Some(profiler) = Profiler::get() {
         let now = now.as_nanos() as i64;
         profiler.collect_fatal(now, filename, line, unsafe {
-            zend::zai_str_from_zstr(message.as_mut()).into_string()
+            zai_str_from_zstr(message.as_mut()).into_string()
         });
     }
 }
@@ -241,8 +308,12 @@ unsafe extern "C" fn ddog_php_prof_zend_accel_schedule_restart_hook(reason: i32)
         if let Some(profiler) = Profiler::get() {
             let now = now.as_nanos() as i64;
             let file = unsafe {
-                zend::zai_str_from_zstr(zend::zend_get_executed_filename_ex().as_mut())
-                    .into_string()
+                // If this has to make a lossy String, then we'll get an extra
+                // copy (once to String, then another to ThinString). I don't
+                // expect this to be hit often, nor a nice way around it.
+                let name =
+                    zai_str_from_zstr(zend_get_executed_filename_ex().as_mut()).into_string_lossy();
+                ThinString::from_str_in(name.as_ref(), Global)
             };
             profiler.collect_opcache_restart(
                 now,
@@ -411,7 +482,7 @@ pub unsafe fn timeline_rinit() {
                         .unwrap()
                         .as_nanos() as i64,
                     idle_since.elapsed().as_nanos() as i64,
-                    State::Idle.as_str(),
+                    State::Idle,
                 );
             }
         });
@@ -440,7 +511,7 @@ pub unsafe fn timeline_rinit() {
                         .duration_since(UNIX_EPOCH)
                         .unwrap()
                         .as_nanos() as i64,
-                    State::ThreadStart.as_str(),
+                    State::ThreadStart,
                 );
             }
         });
@@ -499,7 +570,7 @@ pub(crate) unsafe fn timeline_mshutdown() {
                         .unwrap()
                         .as_nanos() as i64,
                     idle_since.elapsed().as_nanos() as i64,
-                    "idle",
+                    State::Idle,
                 );
             }
         });
@@ -537,7 +608,7 @@ pub(crate) fn timeline_gshutdown() {
                     .duration_since(UNIX_EPOCH)
                     .unwrap()
                     .as_nanos() as i64,
-                State::ThreadStop.as_str(),
+                State::ThreadStop,
             );
         }
     });
@@ -583,7 +654,9 @@ unsafe extern "C" fn ddog_php_prof_compile_string(
             return op_array;
         }
 
-        let filename = zai_str_from_zstr(zend_get_executed_filename_ex().as_mut()).into_string();
+        let filename_lossy =
+            zai_str_from_zstr(zend_get_executed_filename_ex().as_mut()).into_string_lossy();
+        let filename = ThinString::from_str_in(&filename_lossy, Global);
 
         let line = zend::zend_get_executed_lineno();
 
@@ -639,22 +712,19 @@ unsafe extern "C" fn ddog_php_prof_compile_file(
             return op_array;
         }
 
-        let include_type = match r#type as u32 {
-            zend::ZEND_INCLUDE => "include", // `include_once()` and `include_once()`
-            zend::ZEND_REQUIRE => "require", // `require()` and `require_once()`
-            _default => "",
-        };
+        let include_type = IncludeType::from(r#type as u32);
 
         // Extract the filename from the returned op_array.
         // We could also extract from the handle, but those filenames might be different from
         // the one in the `op_array`: In the handle we get what `include()` was called with,
         // for example "/var/www/html/../vendor/foo/bar.php" while during stack walking we get
         // "/var/html/vendor/foo/bar.php". This makes sure it is the exact same string we'd
-        // collect in stack walking and therefore we are fully utilizing the pprof string table
+        // collect in stack walking, and therefore we are fully utilizing the pprof string table.
         let filename = zai_str_from_zstr((*op_array).filename.as_mut()).into_string();
 
         trace!(
-            "Compile file \"{filename}\" with include type \"{include_type}\" took {} nanoseconds",
+            "Compile file \"{filename}\" with include type \"{}\" took {} nanoseconds",
+            include_type.to_thin_string().deref(),
             duration.as_nanos(),
         );
 
@@ -677,12 +747,12 @@ unsafe extern "C" fn ddog_php_prof_compile_file(
 /// a `gc_collect_cycles` function at the top of the call stack, it is because
 /// of a userland call  to `gc_collect_cycles()`, otherwise the engine decided
 /// to run it.
-unsafe fn gc_reason() -> &'static str {
+unsafe fn gc_reason() -> WellKnown {
     let execute_data = zend::ddog_php_prof_get_current_execute_data();
     let fname = || execute_data.as_ref()?.func.as_ref()?.name();
     match fname() {
-        Some(name) if name == b"gc_collect_cycles" => "induced",
-        _ => "engine",
+        Some(name) if name == b"gc_collect_cycles" => WellKnown::Induced,
+        _ => WellKnown::Engine,
     }
 }
 
@@ -724,7 +794,8 @@ unsafe extern "C" fn ddog_php_prof_gc_collect_cycles() -> i32 {
         let status = status.assume_init();
 
         trace!(
-            "Garbage collection with reason \"{reason}\" took {} nanoseconds",
+            "Garbage collection with reason \"{}\" took {} nanoseconds",
+            ThinString::from(reason).deref(),
             duration.as_nanos()
         );
 
diff --git a/profiling/src/well_known.rs b/profiling/src/well_known.rs
new file mode 100644
index 00000000000..81aefc97b42
--- /dev/null
+++ b/profiling/src/well_known.rs
@@ -0,0 +1,174 @@
+use datadog_alloc::Global;
+use std::borrow::Cow;
+
+use datadog_thin_str::{ConstStorage, ThinString};
+
+#[derive(Copy, Clone)]
+pub enum WellKnown {
+    Empty,
+
+    BracketedEval,
+    BracketedFatal,
+    BracketedGc,
+    BracketedIdle,
+    BracketedInclude,
+    BracketedRequire,
+    BracketedSelect,
+    BracketedSleeping,
+    BracketedTruncated,
+    BracketedUnknownIncludeType,
+
+    Compilation,
+    Engine,
+    Fatal,
+    Idle,
+    Include,
+    Induced,
+    OpcacheRestart,
+    PhpOpenTag,
+    Require,
+    Select,
+    Sleeping,
+    Unknown,
+
+    #[cfg(php_zts)]
+    BracketedThreadStart,
+    #[cfg(php_zts)]
+    BracketedThreadStop,
+    #[cfg(php_zts)]
+    ThreadStart,
+    #[cfg(php_zts)]
+    ThreadStop,
+}
+
+impl From<WellKnown> for Cow<'static, str> {
+    fn from(well_known: WellKnown) -> Self {
+        let str: &'static str = match well_known {
+            WellKnown::Empty => inline_strings::EMPTY.as_ref(),
+
+            WellKnown::BracketedEval => inline_strings::BRACKETED_EVAL.as_ref(),
+            WellKnown::BracketedFatal => inline_strings::BRACKETED_FATAL.as_ref(),
+            WellKnown::BracketedGc => inline_strings::BRACKETED_GC.as_ref(),
+            WellKnown::BracketedIdle => inline_strings::BRACKETED_IDLE.as_ref(),
+            WellKnown::BracketedInclude => inline_strings::BRACKETED_INCLUDE.as_ref(),
+            WellKnown::BracketedRequire => inline_strings::BRACKETED_REQUIRE.as_ref(),
+            WellKnown::BracketedSelect => inline_strings::BRACKETED_SELECT.as_ref(),
+            WellKnown::BracketedSleeping => inline_strings::BRACKETED_SLEEPING.as_ref(),
+            WellKnown::BracketedTruncated => inline_strings::BRACKETED_TRUNCATED.as_ref(),
+            WellKnown::BracketedUnknownIncludeType => {
+                inline_strings::BRACKETED_UNKNOWN_INCLUDE_TYPE.as_ref()
+            }
+
+            WellKnown::Compilation => inline_strings::COMPILATION.as_ref(),
+            WellKnown::Engine => inline_strings::ENGINE.as_ref(),
+            WellKnown::Fatal => inline_strings::FATAL.as_ref(),
+            WellKnown::Idle => inline_strings::IDLE.as_ref(),
+            WellKnown::Include => inline_strings::INCLUDE.as_ref(),
+            WellKnown::Induced => inline_strings::INDUCED.as_ref(),
+            WellKnown::OpcacheRestart => inline_strings::OPCACHE_RESTART.as_ref(),
+            WellKnown::PhpOpenTag => inline_strings::PHP_OPEN_TAG.as_ref(),
+            WellKnown::Require => inline_strings::REQUIRE.as_ref(),
+            WellKnown::Select => inline_strings::SELECT.as_ref(),
+            WellKnown::Sleeping => inline_strings::SLEEPING.as_ref(),
+            WellKnown::Unknown => inline_strings::UNKNOWN.as_ref(),
+
+            #[cfg(php_zts)]
+            WellKnown::BracketedThreadStart => inline_strings::BRACKETED_THREAD_START.as_ref(),
+            #[cfg(php_zts)]
+            WellKnown::BracketedThreadStop => inline_strings::BRACKETED_THREAD_STOP.as_ref(),
+            #[cfg(php_zts)]
+            WellKnown::ThreadStart => inline_strings::THREAD_START.as_ref(),
+            #[cfg(php_zts)]
+            WellKnown::ThreadStop => inline_strings::THREAD_STOP.as_ref(),
+        };
+        Cow::Borrowed(str)
+    }
+}
+
+impl From<WellKnown> for ThinString<Global> {
+    fn from(well_known: WellKnown) -> Self {
+        match well_known {
+            WellKnown::Empty => ThinString::from(&inline_strings::EMPTY),
+
+            WellKnown::BracketedEval => ThinString::from(&inline_strings::BRACKETED_EVAL),
+            WellKnown::BracketedFatal => ThinString::from(&inline_strings::BRACKETED_FATAL),
+            WellKnown::BracketedGc => ThinString::from(&inline_strings::BRACKETED_GC),
+            WellKnown::BracketedIdle => ThinString::from(&inline_strings::BRACKETED_IDLE),
+            WellKnown::BracketedInclude => ThinString::from(&inline_strings::BRACKETED_INCLUDE),
+            WellKnown::BracketedRequire => ThinString::from(&inline_strings::BRACKETED_REQUIRE),
+            WellKnown::BracketedSelect => ThinString::from(&inline_strings::BRACKETED_SELECT),
+            WellKnown::BracketedSleeping => ThinString::from(&inline_strings::BRACKETED_SLEEPING),
+            WellKnown::BracketedTruncated => ThinString::from(&inline_strings::BRACKETED_TRUNCATED),
+            WellKnown::BracketedUnknownIncludeType => {
+                ThinString::from(&inline_strings::BRACKETED_UNKNOWN_INCLUDE_TYPE)
+            }
+
+            WellKnown::Compilation => ThinString::from(&inline_strings::COMPILATION),
+            WellKnown::Engine => ThinString::from(&inline_strings::ENGINE),
+            WellKnown::Fatal => ThinString::from(&inline_strings::FATAL),
+            WellKnown::Idle => ThinString::from(&inline_strings::IDLE),
+            WellKnown::Include => ThinString::from(&inline_strings::INCLUDE),
+            WellKnown::Induced => ThinString::from(&inline_strings::INDUCED),
+            WellKnown::OpcacheRestart => ThinString::from(&inline_strings::OPCACHE_RESTART),
+            WellKnown::PhpOpenTag => ThinString::from(&inline_strings::PHP_OPEN_TAG),
+            WellKnown::Require => ThinString::from(&inline_strings::REQUIRE),
+            WellKnown::Select => ThinString::from(&inline_strings::SELECT),
+            WellKnown::Sleeping => ThinString::from(&inline_strings::SLEEPING),
+            WellKnown::Unknown => ThinString::from(&inline_strings::UNKNOWN),
+
+            #[cfg(php_zts)]
+            WellKnown::BracketedThreadStart => {
+                ThinString::from(&inline_strings::BRACKETED_THREAD_START)
+            }
+            #[cfg(php_zts)]
+            WellKnown::BracketedThreadStop => {
+                ThinString::from(&inline_strings::BRACKETED_THREAD_STOP)
+            }
+            #[cfg(php_zts)]
+            WellKnown::ThreadStart => ThinString::from(&inline_strings::THREAD_START),
+            #[cfg(php_zts)]
+            WellKnown::ThreadStop => ThinString::from(&inline_strings::THREAD_STOP),
+        }
+    }
+}
+
+mod inline_strings {
+    use super::*;
+
+    pub static EMPTY: ConstStorage<0> = ConstStorage::from_str("");
+
+    pub static BRACKETED_EVAL: ConstStorage<6> = ConstStorage::from_str("[eval]");
+    pub static BRACKETED_FATAL: ConstStorage<7> = ConstStorage::from_str("[fatal]");
+    pub static BRACKETED_GC: ConstStorage<4> = ConstStorage::from_str("[gc]");
+    pub static BRACKETED_IDLE: ConstStorage<6> = ConstStorage::from_str("[idle]");
+    pub static BRACKETED_INCLUDE: ConstStorage<9> = ConstStorage::from_str("[include]");
+    pub static BRACKETED_REQUIRE: ConstStorage<9> = ConstStorage::from_str("[require]");
+    pub static BRACKETED_SELECT: ConstStorage<8> = ConstStorage::from_str("[select]");
+    pub static BRACKETED_SLEEPING: ConstStorage<10> = ConstStorage::from_str("[sleeping]");
+    pub static BRACKETED_TRUNCATED: ConstStorage<11> = ConstStorage::from_str("[truncated]");
+    pub static BRACKETED_UNKNOWN_INCLUDE_TYPE: ConstStorage<22> =
+        ConstStorage::from_str("[unknown include type]");
+
+    pub static COMPILATION: ConstStorage<11> = ConstStorage::from_str("compilation");
+    pub static ENGINE: ConstStorage<6> = ConstStorage::from_str("engine");
+    pub static FATAL: ConstStorage<5> = ConstStorage::from_str("fatal");
+    pub static IDLE: ConstStorage<4> = ConstStorage::from_str("idle");
+    pub static INCLUDE: ConstStorage<7> = ConstStorage::from_str("include");
+    pub static INDUCED: ConstStorage<7> = ConstStorage::from_str("induced");
+    // todo: use space instead to match "thread start"?
+    pub static OPCACHE_RESTART: ConstStorage<15> = ConstStorage::from_str("opcache_restart");
+    pub static PHP_OPEN_TAG: ConstStorage<5> = ConstStorage::from_str("<?php");
+    pub static REQUIRE: ConstStorage<7> = ConstStorage::from_str("require");
+    pub static SELECT: ConstStorage<6> = ConstStorage::from_str("select");
+    pub static SLEEPING: ConstStorage<8> = ConstStorage::from_str("sleeping");
+    pub static UNKNOWN: ConstStorage<7> = ConstStorage::from_str("unknown");
+
+    #[cfg(php_zts)]
+    pub static BRACKETED_THREAD_START: ConstStorage<14> = ConstStorage::from_str("[thread start]");
+    #[cfg(php_zts)]
+    pub static BRACKETED_THREAD_STOP: ConstStorage<13> = ConstStorage::from_str("[thread stop]");
+    #[cfg(php_zts)]
+    pub static THREAD_START: ConstStorage<12> = ConstStorage::from_str("thread start");
+    #[cfg(php_zts)]
+    pub static THREAD_STOP: ConstStorage<11> = ConstStorage::from_str("thread stop");
+}