chore(profiling): clean up code and update Rust dependencies (#4038)

Author: realFlowControl

Cargo.lock

@@ -15,15 +15,12 @@ bench = false # disables cargo build in libtest bench
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-# Avoid ahash 0.8.7 we run into https://github.com/tkaitchuck/aHash/issues/195.
-ahash = { version = "0.8.11" }
 anyhow = { version = "1.0" }
-cfg-if = { version = "1.0" }
 cpu-time = { version = "1.0" }
 chrono = { version = "0.4" }
 crossbeam-channel = { version = "0.5", default-features = false, features = ["std"] }
-dashmap = { version = "6.1" }
-dynasmrt = "2.0"
+dashmap = { version = "6.2.1" }
+dynasmrt = "5.0.0"
 http = { version = "1.4" }
 libdd-alloc = { path = "../libdatadog/libdd-alloc" }
 libdd-profiling = { path = "../libdatadog/libdd-profiling" }
@@ -34,15 +31,15 @@ libc = "0.2"
 # TRACE set to max to support runtime configuration.
 log = { version = "0.4", features = ["max_level_trace", "release_max_level_trace"]}
 serde_json = {version = "1.0"}
-rand = { version = "0.8.5" }
-rand_distr = { version = "0.4.3" }
-rustc-hash = "1.1.0"
+rand = { version = "0.9.4" }
+rand_distr = { version = "0.5.1" }
+rustc-hash = "2.1.3"
 thiserror = "2"
 tracing = { version = "0.1", optional = true }
 uuid = { version = "1.0", features = ["v4"] }
 
 [target.'cfg(target_vendor = "apple")'.dependencies]
-mach2 = "0.5" # version 0.6 requires edition="2024"
+mach2 = "0.6.0"
 
 [dependencies.tracing-subscriber]
 version = "0.3"
@@ -52,7 +49,6 @@ default-features = false
 features = ["env-filter", "fmt", "smallvec", "std"]
 
 [dev-dependencies]
-allocator-api2 = { version = "0.2", default-features = false, features = ["alloc"] }
 criterion = { version = "0.5.1" }
 datadog-php-profiling = { path = ".", features = ["test"] }
 static_assertions = "1"
@@ -78,7 +74,7 @@ tracing-subscriber = ["tracing", "dep:tracing-subscriber"]
 trigger_time_sample = []
 
 [build-dependencies]
-bindgen = { version = "0.69.4" }
+bindgen = { version = "0.72.1" }
 cc = { version = "1.0" }
 
 # profiling release options in root Cargo.toml

profiling/Cargo.toml

@@ -55,8 +55,7 @@ fn main() {
 
     cfg_php_major_version(vernum);
     cfg_php_feature_flags(vernum);
-    cfg_zts();
-    cfg_php_debug();
+    cfg_php_build();
     apple_linker_flags();
 }
 
@@ -407,8 +406,9 @@ fn cfg_php_feature_flags(vernum: u64) {
     }
 }
 
-fn cfg_zts() {
+fn cfg_php_build() {
     println!("cargo::rustc-check-cfg=cfg(php_zts)");
+    println!("cargo::rustc-check-cfg=cfg(php_debug)");
 
     let output = Command::new("php-config")
         .arg("--include-dir")
@@ -426,9 +426,8 @@ fn cfg_zts() {
         .expect("`php-config`'s stdout to be valid utf8")
         .trim();
 
-    // Create a temporary C file to probe ZTS
     let out_dir = env::var("OUT_DIR").unwrap();
-    let probe_path = Path::new(&out_dir).join("zts_probe.c");
+    let probe_path = Path::new(&out_dir).join("php_build_probe.c");
     fs::write(
         &probe_path,
         r#"
@@ -440,70 +439,6 @@ int main() {
 #else
     printf("0");
 #endif
-    return 0;
-}
-"#,
-    )
-    .expect("Failed to write ZTS probe file");
-
-    // Get the C compiler from cc crate
-    let compiler = cc::Build::new().get_compiler();
-
-    // Compile the probe to an executable
-    let probe_exe = Path::new(&out_dir).join("zts_probe");
-    let compile_status = Command::new(compiler.path())
-        .arg(format!("-I{}", include_dir))
-        .arg(&probe_path)
-        .arg("-o")
-        .arg(&probe_exe)
-        .status()
-        .expect("Failed to compile ZTS probe");
-
-    if !compile_status.success() {
-        panic!("Failed to compile ZTS probe");
-    }
-
-    // Run the probe
-    let probe_output = Command::new(&probe_exe)
-        .output()
-        .expect("Failed to run ZTS probe");
-
-    let zts_value = std::str::from_utf8(&probe_output.stdout)
-        .expect("ZTS probe output not UTF-8")
-        .trim();
-
-    if zts_value == "1" {
-        println!("cargo:rustc-cfg=php_zts");
-    }
-}
-
-fn cfg_php_debug() {
-    println!("cargo::rustc-check-cfg=cfg(php_debug)");
-
-    let output = Command::new("php-config")
-        .arg("--include-dir")
-        .output()
-        .expect("Unable to run `php-config`. Is it in your PATH?");
-
-    if !output.status.success() {
-        match String::from_utf8(output.stderr) {
-            Ok(stderr) => panic!("`php-config --include-dir` failed: {stderr}"),
-            Err(err) => panic!("`php-config --include-dir` failed, not utf8: {err}"),
-        }
-    }
-
-    let include_dir = std::str::from_utf8(output.stdout.as_slice())
-        .expect("`php-config`'s stdout to be valid utf8")
-        .trim();
-
-    let out_dir = env::var("OUT_DIR").unwrap();
-    let probe_path = Path::new(&out_dir).join("php_debug_probe.c");
-    fs::write(
-        &probe_path,
-        r#"
-#include "main/php_config.h"
-#include <stdio.h>
-int main() {
 #if ZEND_DEBUG
     printf("1");
 #else
@@ -513,31 +448,41 @@ int main() {
 }
 "#,
     )
-    .expect("Failed to write PHP debug probe file");
+    .expect("Failed to write PHP build probe file");
 
     let compiler = cc::Build::new().get_compiler();
-    let probe_exe = Path::new(&out_dir).join("php_debug_probe");
+    let probe_exe = Path::new(&out_dir).join("php_build_probe");
     let compile_status = Command::new(compiler.path())
         .arg(format!("-I{}", include_dir))
         .arg(&probe_path)
         .arg("-o")
         .arg(&probe_exe)
         .status()
-        .expect("Failed to compile PHP debug probe");
+        .expect("Failed to compile PHP build probe");
 
     if !compile_status.success() {
-        panic!("Failed to compile PHP debug probe");
+        panic!("Failed to compile PHP build probe");
     }
 
     let probe_output = Command::new(&probe_exe)
         .output()
-        .expect("Failed to run PHP debug probe");
+        .expect("Failed to run PHP build probe");
 
-    let debug_value = std::str::from_utf8(&probe_output.stdout)
-        .expect("PHP debug probe output not UTF-8")
+    let probe_value = std::str::from_utf8(&probe_output.stdout)
+        .expect("PHP build probe output not UTF-8")
         .trim();
+    let (zts, debug) = match probe_value {
+        "00" => (false, false),
+        "01" => (false, true),
+        "10" => (true, false),
+        "11" => (true, true),
+        _ => panic!("Unexpected PHP build probe output: {probe_value:?}"),
+    };
 
-    if debug_value == "1" {
+    if zts {
+        println!("cargo:rustc-cfg=php_zts");
+    }
+    if debug {
         println!("cargo:rustc-cfg=php_debug");
     }
 }

profiling/benches/fakeapp/vendor/FakeApp/FakeRoute/src/MatchedRoute.php

@@ -108,9 +108,9 @@ impl AllocationProfilingStats {
             next_sample: 0,
             poisson,
             #[cfg(php_zts)]
-            rng: rand::thread_rng(),
+            rng: rand::rng(),
             #[cfg(not(php_zts))]
-            rng: StdRng::from_entropy(),
+            rng: StdRng::from_os_rng(),
         };
         stats.next_sampling_interval();
         stats

profiling/build.rs

@@ -1324,13 +1324,10 @@ pub(crate) fn minit(module_number: libc::c_int) {
         let mut system_settings = SystemSettings::new();
 
         // Initialize logging before allocation's rinit, as it logs.
-        cfg_if::cfg_if! {
-            if #[cfg(debug_assertions)] {
-                log::set_max_level(system_settings.profiling_log_level);
-            } else {
-                crate::logging::log_init(system_settings.profiling_log_level);
-            }
-        }
+        #[cfg(debug_assertions)]
+        log::set_max_level(system_settings.profiling_log_level);
+        #[cfg(not(debug_assertions))]
+        crate::logging::log_init(system_settings.profiling_log_level);
 
         SystemSettings::log_state(
             (*ptr::addr_of!(SYSTEM_SETTINGS)).state,

profiling/src/allocation/mod.rs

@@ -44,7 +44,7 @@ impl ExceptionProfilingStats {
         let mut stats = ExceptionProfilingStats {
             next_sample: 0,
             poisson,
-            rng: rand::thread_rng(),
+            rng: rand::rng(),
         };
         stats.next_sampling_interval();
         stats

profiling/src/config.rs

@@ -5,10 +5,10 @@ pub mod got_macho;
 
 use crate::profiling::Profiler;
 use crate::{zend, RefCellExt, REQUEST_LOCALS};
-use ahash::{HashMap, HashMapExt};
 use libc::{c_int, c_void, fstat, stat, S_IFMT, S_IFSOCK};
 use rand::rngs::ThreadRng;
 use rand_distr::{Distribution, Poisson};
+use rustc_hash::FxHashMap;
 use std::cell::RefCell;
 use std::mem::MaybeUninit;
 use std::os::unix::io::RawFd;
@@ -408,19 +408,19 @@ static mut ORIG_CLOSE: unsafe extern "C" fn(i32) -> i32 = libc::close;
 unsafe extern "C" fn observed_close(fd: i32) -> i32 {
     let ret = ORIG_CLOSE(fd);
     let _errno_backup = ErrnoBackup::new();
-    let cache = FD_CACHE.get_or_init(|| Mutex::new(HashMap::new()));
+    let cache = FD_CACHE.get_or_init(|| Mutex::new(FxHashMap::default()));
     let mut cache = cache.lock().unwrap();
     cache.remove(&fd);
     ret
 }
 
 /// "Is socket"-cache for `read()`/`write()` calls
-static FD_CACHE: OnceLock<Mutex<HashMap<RawFd, bool>>> = OnceLock::new();
+static FD_CACHE: OnceLock<Mutex<FxHashMap<RawFd, bool>>> = OnceLock::new();
 
 /// Returns `true` if the given `fd` is a socket. It could also be a regular file, directory, pipe,
 /// character or block device, in which case we declare this as file I/O and not socket I/O.
 fn fd_is_socket(fd: RawFd) -> bool {
-    let cache = FD_CACHE.get_or_init(|| Mutex::new(HashMap::new()));
+    let cache = FD_CACHE.get_or_init(|| Mutex::new(FxHashMap::default()));
     if let Some(&is_socket) = cache.lock().unwrap().get(&fd) {
         return is_socket;
     }
@@ -574,7 +574,7 @@ impl IOProfilingStats {
         let mut stats = IOProfilingStats {
             next_sample: 0,
             poisson,
-            rng: rand::thread_rng(),
+            rng: rand::rng(),
         };
         stats.next_sampling_interval();
         stats

profiling/src/exception.rs

@@ -920,27 +920,24 @@ unsafe extern "C" fn minfo(module_ptr: *mut zend::ModuleEntry) {
                 );
 
 
-        cfg_if::cfg_if! {
-            if #[cfg(feature = "io_profiling")] {
-                zend::php_info_print_table_row(
-                    2,
-                    c"I/O Profiling Enabled".as_ptr(),
-                    if system_settings.profiling_io_enabled {
-                        yes
-                    } else if system_settings.profiling_enabled {
-                        no
-                    } else {
-                        no_all
-                    },
-                );
+        #[cfg(feature = "io_profiling")]
+        zend::php_info_print_table_row(
+            2,
+            c"I/O Profiling Enabled".as_ptr(),
+            if system_settings.profiling_io_enabled {
+                yes
+            } else if system_settings.profiling_enabled {
+                no
             } else {
-                zend::php_info_print_table_row(
-                    2,
-                    c"I/O Profiling Enabled".as_ptr(),
-                    c"Not available. The profiler was built without I/O profiling support.".as_ptr()
-                );
-            }
-        }
+                no_all
+            },
+        );
+        #[cfg(not(feature = "io_profiling"))]
+        zend::php_info_print_table_row(
+            2,
+            c"I/O Profiling Enabled".as_ptr(),
+            c"Not available. The profiler was built without I/O profiling support.".as_ptr(),
+        );
 
         zend::php_info_print_table_row(
             2,