add support for profiling threading.Semaphore objects in Lock profiler

Author: vlad-scherbich

.gitignore

@@ -201,3 +201,5 @@ tests/appsec/iast/fixtures/taint_sinks/not_exists.txt
 
 # Rust build artifacts
 src/native/target*
+
+src/native/Cargo.lock

ddtrace/profiling/collector/_lock.py

@@ -52,6 +52,7 @@ class _ProfiledLock:
         "init_location",
         "acquired_time",
         "name",
+        "is_internal",
     )
 
     def __init__(
@@ -60,6 +61,7 @@ def __init__(
         tracer: Optional[Tracer],
         max_nframes: int,
         capture_sampler: collector.CaptureSampler,
+        is_internal: bool = False,
     ) -> None:
         self.__wrapped__: Any = wrapped
         self.tracer: Optional[Tracer] = tracer
@@ -71,6 +73,9 @@ def __init__(
         self.init_location: str = f"{os.path.basename(code.co_filename)}:{frame.f_lineno}"
         self.acquired_time: int = 0
         self.name: Optional[str] = None
+        # If True, this lock is internal to another sync primitive (e.g., Lock inside Semaphore)
+        # and should not generate profile samples to avoid double-counting
+        self.is_internal: bool = is_internal
 
     ### DUNDER methods ###
 
@@ -161,6 +166,11 @@ def _flush_sample(self, start: int, end: int, is_acquire: bool) -> None:
             end: End timestamp in nanoseconds
             is_acquire: True for acquire operations, False for release operations
         """
+        # Skip profiling for internal locks (e.g., Lock inside Semaphore/Condition)
+        # to avoid double-counting when multiple collectors are active
+        if self.is_internal:
+            return
+
         handle: ddup.SampleHandle = ddup.SampleHandle()
 
         handle.push_monotonic_ns(end)
@@ -262,6 +272,8 @@ class LockCollector(collector.CaptureSamplerCollector):
     """Record lock usage."""
 
     PROFILED_LOCK_CLASS: Type[Any]
+    PATCH_MODULE: Any  # e.g., threading module
+    PATCH_ATTR_NAME: str  # e.g., "Lock", "RLock", "Semaphore"
 
     def __init__(
         self,
@@ -275,11 +287,11 @@ def __init__(
         self.tracer: Optional[Tracer] = tracer
         self._original_lock: Any = None
 
-    @abc.abstractmethod
-    def _get_patch_target(self) -> Callable[..., Any]: ...
+    def _get_patch_target(self) -> Callable[..., Any]:
+        return getattr(self.PATCH_MODULE, self.PATCH_ATTR_NAME)
 
-    @abc.abstractmethod
-    def _set_patch_target(self, value: Any) -> None: ...
+    def _set_patch_target(self, value: Any) -> None:
+        setattr(self.PATCH_MODULE, self.PATCH_ATTR_NAME, value)
 
     def _start_service(self) -> None:
         """Start collecting lock usage."""
@@ -297,12 +309,30 @@ def patch(self) -> None:
         original_lock: Any = self._original_lock  # Capture non-None value
 
         def _profiled_allocate_lock(*args: Any, **kwargs: Any) -> _ProfiledLock:
-            """Simple wrapper that returns profiled locks."""
+            """Simple wrapper that returns profiled locks.
+
+            Detects if the lock is being created from within threading.py stdlib
+            (i.e., internal to Semaphore/Condition) to avoid double-counting.
+            """
+            import threading as threading_module
+
+            # Check if caller is from threading.py (internal lock)
+            is_internal: bool = False
+            try:
+                # Frame 0: _profiled_allocate_lock
+                # Frame 1: _LockAllocatorWrapper.__call__
+                # Frame 2: actual caller (threading.Lock() call site)
+                caller_filename = sys._getframe(2).f_code.co_filename
+                is_internal = bool(threading_module.__file__) and caller_filename == threading_module.__file__
+            except (ValueError, AttributeError):
+                pass
+
             return self.PROFILED_LOCK_CLASS(
                 wrapped=original_lock(*args, **kwargs),
                 tracer=self.tracer,
                 max_nframes=self.nframes,
                 capture_sampler=self._capture_sampler,
+                is_internal=is_internal,
             )
 
         self._set_patch_target(_LockAllocatorWrapper(_profiled_allocate_lock))

ddtrace/profiling/collector/threading.py

@@ -18,34 +18,32 @@ class _ProfiledThreadingRLock(_lock._ProfiledLock):
     pass
 
 
+class _ProfiledThreadingSemaphore(_lock._ProfiledLock):
+    pass
+
+
 class ThreadingLockCollector(_lock.LockCollector):
     """Record threading.Lock usage."""
 
     PROFILED_LOCK_CLASS = _ProfiledThreadingLock
-
-    def _get_patch_target(self) -> typing.Type[threading.Lock]:
-        return threading.Lock
-
-    def _set_patch_target(
-        self,
-        value: typing.Any,
-    ) -> None:
-        threading.Lock = value
+    PATCH_MODULE = threading
+    PATCH_ATTR_NAME = "Lock"
 
 
 class ThreadingRLockCollector(_lock.LockCollector):
     """Record threading.RLock usage."""
 
     PROFILED_LOCK_CLASS = _ProfiledThreadingRLock
+    PATCH_MODULE = threading
+    PATCH_ATTR_NAME = "RLock"
+
 
-    def _get_patch_target(self) -> typing.Type[threading.RLock]:
-        return threading.RLock
+class ThreadingSemaphoreCollector(_lock.LockCollector):
+    """Record threading.Semaphore usage."""
 
-    def _set_patch_target(
-        self,
-        value: typing.Any,
-    ) -> None:
-        threading.RLock = value
+    PROFILED_LOCK_CLASS = _ProfiledThreadingSemaphore
+    PATCH_MODULE = threading
+    PATCH_ATTR_NAME = "Semaphore"
 
 
 # Also patch threading.Thread so echion can track thread lifetimes

ddtrace/profiling/profiler.py

@@ -220,6 +220,7 @@ def start_collector(collector_class: Type) -> None:
             self._collectors_on_import = [
                 ("threading", lambda _: start_collector(threading.ThreadingLockCollector)),
                 ("threading", lambda _: start_collector(threading.ThreadingRLockCollector)),
+                ("threading", lambda _: start_collector(threading.ThreadingSemaphoreCollector)),
                 ("asyncio", lambda _: start_collector(asyncio.AsyncioLockCollector)),
             ]
 

releasenotes/notes/Added-support-for-profiling-of-'threading.Semaphore'-objects-to-the-Python-Lock-profiler-aa46b9a5b01ccd3d.yaml

@@ -0,0 +1,7 @@
+---
+features:
+  - |
+    profiling: Add support for ``threading.Semaphore`` locking type profiling in Python. 
+    The Lock profiler now detects "internal" ``threading.Lock`` primitives, i.e. those that are part of implementation of higher-level locking types (such as ``threading.Semaphore``). 
+    Doing so prevents double-counting samples for Semaphore objects, which are implemented with using Condition, which itself uses Lock.
+    The internal lock, while still being patched due to the profiler design, is designated as internal (`self.is_internal == True`), which prevents it from being logged.