chore(profiling): fix 'test_semaphore_and_bounded_semaphore_collectors_coexist' test (#15536)

## Description

Fix a segfault in the
test_semaphore_and_bounded_semaphore_collectors_coexist test that
occurred on Python 3.12. The test was missing the required ddup.config()
and ddup.start() initialization before using lock collectors.

This test was introduced in #15375 (unsure how it passed there...), but
it should be working now.

## What Happened
The test used `ThreadingSemaphoreCollector` and
`ThreadingBoundedSemaphoreCollector` without initializing the ddup
module first. When the profiler tried to push sample data via
handle.push_acquire(), it crashed with a segfault because the C
extension's internal state (memory buffers, output file handles) was
uninitialized.

## Changes
* Added ddup initialization to
test_semaphore_and_bounded_semaphore_collectors_coexist (the fix itself)
* Extracted init_ddup() helper into new
tests/profiling/collector/test_utils.py module (drive-by)
* Updated 3 tests to use the shared helper, reducing code duplication
(drive-by)

## Testing
* CI

Author: vlad-scherbich

tests/profiling/collector/test_threading.py

@@ -55,6 +55,7 @@
     ThreadingLockCollector, ThreadingRLockCollector, ThreadingSemaphoreCollector, ThreadingBoundedSemaphoreCollector
 ]
 
+
 # Module-level globals for testing global lock profiling
 _test_global_lock: LockTypeInst
 
@@ -422,18 +423,10 @@ def test_assertion_error_raised_with_enable_asserts():
     import mock
     import pytest
 
-    from ddtrace.internal.datadog.profiling import ddup
     from ddtrace.profiling.collector.threading import ThreadingLockCollector
+    from tests.profiling.collector.test_utils import init_ddup
 
-    # Initialize ddup (required before using collectors)
-    assert ddup.is_available, "ddup is not available"
-    ddup.config(
-        env="test",
-        service="test_asserts",
-        version="1.0",
-        output_filename="/tmp/test_asserts",
-    )
-    ddup.start()
+    init_ddup("test_asserts")
 
     with ThreadingLockCollector(capture_pct=100):
         lock = threading.Lock()
@@ -456,18 +449,10 @@ def test_all_exceptions_suppressed_by_default() -> None:
 
     import mock
 
-    from ddtrace.internal.datadog.profiling import ddup
     from ddtrace.profiling.collector.threading import ThreadingLockCollector
+    from tests.profiling.collector.test_utils import init_ddup
 
-    # Initialize ddup (required before using collectors)
-    assert ddup.is_available, "ddup is not available"
-    ddup.config(
-        env="test",
-        service="test_exceptions",
-        version="1.0",
-        output_filename="/tmp/test_exceptions",
-    )
-    ddup.start()
+    init_ddup("test_exceptions")
 
     with ThreadingLockCollector(capture_pct=100):
         lock = threading.Lock()
@@ -488,6 +473,41 @@ def test_all_exceptions_suppressed_by_default() -> None:
         lock.release()
 
 
+def test_semaphore_and_bounded_semaphore_collectors_coexist() -> None:
+    """Test that Semaphore and BoundedSemaphore collectors can run simultaneously.
+
+    Tests proper patching where inheritance is involved if both parent and child classes are patched,
+    e.g. when BoundedSemaphore's c-tor calls Semaphore c-tor.
+    We expect that the call to Semaphore c-tor goes to the unpatched version, and NOT our patched version.
+    """
+    from tests.profiling.collector.test_utils import init_ddup
+
+    init_ddup("test_semaphore_and_bounded_semaphore_collectors_coexist")
+
+    # Both collectors active at the same time - this triggers the inheritance case
+    with ThreadingSemaphoreCollector(capture_pct=100), ThreadingBoundedSemaphoreCollector(capture_pct=100):
+        sem = threading.Semaphore(2)
+        sem.acquire()
+        sem.release()
+
+        bsem = threading.BoundedSemaphore(3)
+        bsem.acquire()
+        bsem.release()
+
+        # If inheritance delegation failed, these attributes will be missing.
+        wrapped_bsem = bsem.__wrapped__
+        assert hasattr(wrapped_bsem, "_cond"), "BoundedSemaphore._cond not initialized (inheritance bug)"
+        assert hasattr(wrapped_bsem, "_value"), "BoundedSemaphore._value not initialized (inheritance bug)"
+        assert hasattr(wrapped_bsem, "_initial_value"), "BoundedSemaphore._initial_value not initialized"
+
+        # Verify BoundedSemaphore behavior is preserved (i.e. it raises on over-release)
+        bsem2 = threading.BoundedSemaphore(1)
+        bsem2.acquire()
+        bsem2.release()
+        with pytest.raises(ValueError, match="Semaphore released too many times"):
+            bsem2.release()
+
+
 class BaseThreadingLockCollectorTest:
     # These should be implemented by child classes
     @property
@@ -1595,34 +1615,3 @@ def test_bounded_behavior_preserved(self) -> None:
             # This proves our profiling wrapper doesn't break BoundedSemaphore's behavior
             with pytest.raises(ValueError, match="Semaphore released too many times"):
                 sem.release()
-
-
-def test_semaphore_and_bounded_semaphore_collectors_coexist() -> None:
-    """Test that Semaphore and BoundedSemaphore collectors can run simultaneously.
-
-    Tests proper patching where inheritance is involved if both parent and child classes are patched,
-    e.g. when BoundedSemaphore's c-tor calls Semaphore c-tor.
-    We expect that the call to Semaphore c-tor goes to the unpatched version, and NOT our patched version.
-    """
-    # Both collectors active at the same time - this triggers the inheritance case
-    with ThreadingSemaphoreCollector(capture_pct=100), ThreadingBoundedSemaphoreCollector(capture_pct=100):
-        sem = threading.Semaphore(2)
-        sem.acquire()
-        sem.release()
-
-        bsem = threading.BoundedSemaphore(3)
-        bsem.acquire()
-        bsem.release()
-
-        # If inheritance delegation failed, these attributes will be missing.
-        wrapped_bsem = bsem.__wrapped__
-        assert hasattr(wrapped_bsem, "_cond"), "BoundedSemaphore._cond not initialized (inheritance bug)"
-        assert hasattr(wrapped_bsem, "_value"), "BoundedSemaphore._value not initialized (inheritance bug)"
-        assert hasattr(wrapped_bsem, "_initial_value"), "BoundedSemaphore._initial_value not initialized"
-
-        # Verify BoundedSemaphore behavior is preserved (i.e. it raises on over-release)
-        bsem2 = threading.BoundedSemaphore(1)
-        bsem2.acquire()
-        bsem2.release()
-        with pytest.raises(ValueError, match="Semaphore released too many times"):
-            bsem2.release()

tests/profiling/collector/test_utils.py

@@ -0,0 +1,21 @@
+"""Shared utilities for profiling collector tests."""
+
+from ddtrace.internal.datadog.profiling import ddup
+
+
+def init_ddup(test_name: str) -> None:
+    """Initialize ddup for profiling tests.
+
+    Must be called before using any lock collectors.
+
+    Args:
+        test_name: Name of the test, used for service name and output filename.
+    """
+    assert ddup.is_available, "ddup is not available"
+    ddup.config(
+        env="test",
+        service=test_name,
+        version="1.0",
+        output_filename="/tmp/" + test_name,
+    )
+    ddup.start()