fix(ci): skip thread counting test (#1841)

# What does this PR do?
`test_count_active_threads` run on centos7 are [flaking](https://github.com/DataDog/libdatadog/actions/runs/23868297465/job/69593217671?pr=1839) as such:
```
stdout ───

    running 1 test

    running 1 test

    thread 'test_utils::tests::test_count_active_threads' (70243) panicked at libdd-common/src/test_utils.rs:564:13:
    Expected thread count to return to 2 or 3 after join, got 4
    note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
    test test_utils::tests::test_count_active_threads ... FAILED

    failures:

    failures:
        test_utils::tests::test_count_active_threads

    test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 112 filtered out; finished in 0.05s

  stderr ───

    thread 'test_utils::tests::test_count_active_threads' (70241) panicked at /usr/local/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rusty-fork-0.3.1/src/fork_test.rs:135:9:
    child exited unsuccessfully with exit status: 70
    note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
```

This is because some platforms, such as CentOS, spawn helper threads

# Motivation

Its been extremely flaky over the past two months

# Additional Notes

This test test a helper that is used for another test. The actual thread counting functionality seems sound, but the testing of thread counting with hard assertions on the # of threads is flaky because it is dependent on platform and sync state

# How to test the change?

Describe here in detail how the change can be validated.


Co-authored-by: edmund.kump <edmund.kump@datadoghq.com>

Author: gyuheon0h

Cargo.lock

@@ -89,7 +89,6 @@ multer = "3.1"
 bytes = "1.11.1"
 rand = "0.8"
 tempfile = "3.8"
-rusty-fork = "0.3"
 tokio = { version = "1.23", features = ["rt", "macros", "time"] }
 
 [features]

libdd-common/Cargo.toml

@@ -419,7 +419,6 @@ async fn parse_multipart(boundary: String, body: Vec<u8>) -> anyhow::Result<Vec<
 #[cfg(test)]
 mod tests {
     use super::*;
-    use rusty_fork::rusty_fork_test;
 
     #[test]
     fn test_temp_file_guard_and_path_generation() {
@@ -516,58 +515,55 @@ mod tests {
         assert_eq!(parsed.multipart_parts[0].content, b"value");
     }
 
-    // This test must run in its own process to get accurate thread counts,
-    // since the test runner and other parallel tests spawn threads.
-    rusty_fork_test! {
-        #[test]
-        #[cfg_attr(miri, ignore)]
-        fn test_count_active_threads() {
-            use crate::test_utils::count_active_threads;
-
-            let initial_count = count_active_threads().expect("Failed to count threads");
-            assert!(
-                initial_count >= 1,
-                "Expected at least 1 thread, got {}",
-                initial_count
-            );
-
-            // Spawn some threads and verify the count increases
-            use std::sync::{Arc, Barrier};
-            let barrier = Arc::new(Barrier::new(6)); // 5 spawned threads + main thread
-
-            let handles: Vec<_> = (0..5)
-                .map(|_| {
-                    let barrier = Arc::clone(&barrier);
-                    std::thread::spawn(move || {
-                        barrier.wait();
-                        std::thread::sleep(std::time::Duration::from_millis(50));
-                    })
+    // Skipping this test because it is flaky on CentOS, due to the helper threads that are spawned
+    #[test]
+    #[ignore]
+    fn test_count_active_threads() {
+        use crate::test_utils::count_active_threads;
+
+        let initial_count = count_active_threads().expect("Failed to count threads");
+        assert!(
+            initial_count >= 1,
+            "Expected at least 1 thread, got {}",
+            initial_count
+        );
+
+        // Spawn some threads and verify the count increases
+        use std::sync::{Arc, Barrier};
+        let barrier = Arc::new(Barrier::new(6)); // 5 spawned threads + main thread
+
+        let handles: Vec<_> = (0..5)
+            .map(|_| {
+                let barrier = Arc::clone(&barrier);
+                std::thread::spawn(move || {
+                    barrier.wait();
+                    std::thread::sleep(std::time::Duration::from_millis(50));
                 })
-                .collect();
-
-            barrier.wait();
-            let count_with_threads = count_active_threads().expect("Failed to count threads");
-            assert!(
-                count_with_threads >= initial_count + 5,
-                "Expected at least {} threads (initial: {}, with 5 spawned: {})",
-                initial_count + 5,
-                initial_count,
-                count_with_threads
-            );
-
-            for handle in handles {
-                handle.join().expect("Thread should join successfully");
-            }
+            })
+            .collect();
+
+        barrier.wait();
+        let count_with_threads = count_active_threads().expect("Failed to count threads");
+        assert!(
+            count_with_threads >= initial_count + 5,
+            "Expected at least {} threads (initial: {}, with 5 spawned: {})",
+            initial_count + 5,
+            initial_count,
+            count_with_threads
+        );
 
-            let count_after_join = count_active_threads().expect("Failed to count threads");
-            // Allow up to 1 extra: some platforms (e.g. CentOS 7) lazily spawn a helper thread
-            assert!(
-                count_after_join <= initial_count + 1,
-                "Expected thread count to return to {} or {} after join, got {}",
-                initial_count,
-                initial_count + 1,
-                count_after_join
-            );
+        for handle in handles {
+            handle.join().expect("Thread should join successfully");
         }
+
+        let count_after_join = count_active_threads().expect("Failed to count threads");
+        // Allow up to 1 extra: some platforms (e.g. CentOS 7) lazily spawn a helper thread
+        assert!(
+            count_after_join <= initial_count + 1,
+            "Expected thread count to return to {} or {} after join, got {}",
+            initial_count,
+            initial_count + 1,
+            count_after_join
+        );
     }
 }