feat(profiling): add threading.RLock support to the Lock profiler (re-entrant lock) (#14823)

[PROF-12721]

## Description
This PR adds profiling support for a new kind of synchronization
mechanism: Reentrant Lock. A RLock is a lock that can be acquired **by
the same thread** multiple times without blocking on itself. From the
documentation:
> Once a thread has acquired a reentrant lock, the same thread may
acquire it again without blocking; the thread must release it once for
each time it has acquired it.

This feature was identified as one of the most - low-hanging-fruits,
since `RLock`s are being used extensively in Python world.

### Changes
* added new `ThreadingRLockCollector` class in `threading.py`
* register the new collector in Profiler in `profiler.py`
* current `test_threading.py` module has been updated to reuse existing
tests for both `Lock` and `RLock` primitives (via new inheritance)
* `test_global_locks` test rewritten extensively to support the unit
test code reuse between `Lock` and `RLock` (effectively duplicating the
existing extensive `Lock` unit tests for `RLock` ... without the code
duplication)

## Testing

* added new unit tests
* added new e2e test:
- Reentrant behavior works for multi-level acquisition
- Thread contention handling validated

## Risks

none

## Additional Notes

* [RLock
docs](https://docs.python.org/3/library/threading.html#threading.RLock)


[PROF-12721]:
https://datadoghq.atlassian.net/browse/PROF-12721?atlOrigin=eyJpIjoiNWRkNTljNzYxNjVmNDY3MDlhMDU5Y2ZhYzA5YTRkZjUiLCJwIjoiZ2l0aHViLWNvbS1KU1cifQ

---------

Co-authored-by: Taegyun Kim <[email protected]>

Author: vlad-scherbich

ddtrace/profiling/collector/threading.py

@@ -14,6 +14,10 @@ class _ProfiledThreadingLock(_lock._ProfiledLock):
     pass
 
 
+class _ProfiledThreadingRLock(_lock._ProfiledLock):
+    pass
+
+
 class ThreadingLockCollector(_lock.LockCollector):
     """Record threading.Lock usage."""
 
@@ -29,6 +33,21 @@ def _set_patch_target(
         threading.Lock = value
 
 
+class ThreadingRLockCollector(_lock.LockCollector):
+    """Record threading.RLock usage."""
+
+    PROFILED_LOCK_CLASS = _ProfiledThreadingRLock
+
+    def _get_patch_target(self) -> typing.Type[threading.RLock]:
+        return threading.RLock
+
+    def _set_patch_target(
+        self,
+        value: typing.Any,
+    ) -> None:
+        threading.RLock = value
+
+
 # Also patch threading.Thread so echion can track thread lifetimes
 def init_stack_v2() -> None:
     if config.stack.v2_enabled and stack_v2.is_available:

ddtrace/profiling/profiler.py

@@ -29,6 +29,8 @@
 from ddtrace.settings.profiling import config_str
 
 
+# TODO(vlad): add type annotations
+
 LOG = logging.getLogger(__name__)
 
 
@@ -223,6 +225,7 @@ def start_collector(collector_class: Type) -> None:
 
             self._collectors_on_import = [
                 ("threading", lambda _: start_collector(threading.ThreadingLockCollector)),
+                ("threading", lambda _: start_collector(threading.ThreadingRLockCollector)),
                 ("asyncio", lambda _: start_collector(asyncio.AsyncioLockCollector)),
             ]
 

releasenotes/notes/feat-profiling-rlock-support-e8607e68252647.yaml

@@ -0,0 +1,4 @@
+---
+features:
+  - |
+    profiling: Add support for ``threading.RLock`` (reentrant lock) profiling. The Lock profiler now tracks both ``threading.Lock`` and ``threading.RLock`` usage, providing comprehensive lock contention visibility for Python applications.