fix(core): use unpatched lock from forksafe module (#15151)

## Description

<!-- Provide an overview of the change and motivation for the change -->
From a recent profiling escalation, we've seen a flamegraph where
forksafe lock is calling into patched profiling lock.
<img width="918" height="329" alt=" "
src="https://github.com/user-attachments/assets/3bff0b94-4ad7-49b1-847f-61812e2f43eb"
/>

The library used in above flamegraph is version 3.17.0.

From the leaf frame
1. [_release
(_lock.py:#155)](https://github.com/DataDog/dd-trace-py/blob/7451e8468236787abefb164407a8bd75dd005501/ddtrace/profiling/collector/_lock.py#L155)
2. [\_\_exit__
(_lock.py:L#206)](https://github.com/DataDog/dd-trace-py/blob/7451e8468236787abefb164407a8bd75dd005501/ddtrace/profiling/collector/_lock.py#L206)
3. [start
(service.py:L#57)](https://github.com/DataDog/dd-trace-py/blob/7451e8468236787abefb164407a8bd75dd005501/ddtrace/internal/service.py#L57)


https://github.com/DataDog/dd-trace-py/blob/7451e8468236787abefb164407a8bd75dd005501/ddtrace/internal/service.py#L57-L61

`self._service_lock` is declared as a `forksafe.Lock()` 


https://github.com/DataDog/dd-trace-py/blob/7451e8468236787abefb164407a8bd75dd005501/ddtrace/internal/service.py#L33

## Testing

<!-- Describe your testing strategy or note what tests are included -->

## Risks

<!-- Note any risks associated with this change, or "None" if no risks
-->

## Additional Notes

<!-- Any other information that would be helpful for reviewers -->

Author: taegyunkim

ddtrace/internal/_unpatched.py

@@ -10,9 +10,13 @@
 # to get a reference to the right threading module.
 import threading as _threading  # noqa
 import gc as _gc  # noqa
-
 import sys
 
+threading_Lock = _threading.Lock
+threading_RLock = _threading.RLock
+threading_Event = _threading.Event
+
+
 previous_loaded_modules = frozenset(sys.modules.keys())
 from subprocess import Popen as unpatched_Popen  # noqa # nosec B404
 from os import close as unpatched_close  # noqa: F401, E402

ddtrace/internal/forksafe.py

@@ -5,12 +5,13 @@
 import functools
 import logging
 import os
-import threading
 import typing
 import weakref
 
 import wrapt
 
+from ddtrace.internal import _unpatched
+
 
 log = logging.getLogger(__name__)
 
@@ -138,13 +139,13 @@ def _reset_object(self):
         self.__wrapped__ = self._self_wrapped_class()
 
 
-def Lock() -> threading.Lock:
-    return ResetObject(threading.Lock)  # type: ignore
+def Lock() -> _unpatched.threading_Lock:
+    return ResetObject(_unpatched.threading_Lock)  # type: ignore
 
 
-def RLock() -> threading.RLock:
-    return ResetObject(threading.RLock)  # type: ignore
+def RLock() -> _unpatched.threading_RLock:
+    return ResetObject(_unpatched.threading_RLock)  # type: ignore
 
 
-def Event() -> threading.Event:
-    return ResetObject(threading.Event)  # type: ignore
+def Event() -> _unpatched.threading_Event:
+    return ResetObject(_unpatched.threading_Event)  # type: ignore

releasenotes/notes/forksafe-lock-06ca188ef798c1f8.yaml

@@ -0,0 +1,4 @@
+---
+fixes:
+  - |
+    core: This fix resolves an issue where forksafe locks used patched threading primitives from the profiling module, causing performance issues. The forksafe module now uses unpatched threading primitives (``Lock``, ``RLock``, ``Event``).

tests/internal/test_forksafe.py

@@ -1,5 +1,6 @@
 from collections import Counter
 import os
+import sys
 
 import pytest
 
@@ -204,6 +205,37 @@ def test_lock_fork():
     assert exit_code == 12
 
 
+@pytest.mark.skipif(sys.version_info >= (3, 14), reason="Profiling is not supported on Python 3.14 yet")
+@pytest.mark.subprocess(
+    env=dict(DD_PROFILING_ENABLED="1"),
+    ddtrace_run=True,
+)
+def test_lock_unpatched():
+    """Check that a forksafe.Lock is not patched when profiling is enabled."""
+
+    from ddtrace.internal import forksafe
+    from ddtrace.profiling import bootstrap
+    from ddtrace.profiling.collector.threading import ThreadingLockCollector
+
+    # When Profiler is started, bootstrap.profiler is set to the Profiler
+    # instance. We explicitly access the Profiler instance and the collector list
+    # to verify that the forksafe.Lock is not using the same class that is
+    # patched by ThreadingLockCollector that's running.
+    profiler = bootstrap.profiler._profiler
+    lock_collector = None
+    for c in profiler._collectors:
+        if isinstance(c, ThreadingLockCollector):
+            lock_collector = c
+            break
+
+    assert lock_collector is not None, "ThreadingLockCollector not found in profiler collectors"
+
+    lock = forksafe.Lock()
+    assert (
+        lock_collector._get_patch_target() is not lock._self_wrapped_class
+    ), "forksafe.Lock is using the same class that is patched by ThreadingLockCollector"
+
+
 def test_rlock_basic():
     # type: (...) -> None
     """Check that a forksafe.RLock implements the correct threading.RLock interface"""