feat(profiling): profile asyncio.BoundedSemaphore primitives with Python Lock profiler

Author: vlad-scherbich

ddtrace/profiling/collector/asyncio.py

@@ -11,6 +11,10 @@ class _ProfiledAsyncioSemaphore(_lock._ProfiledLock):
     pass
 
 
+class _ProfiledAsyncioBoundedSemaphore(_lock._ProfiledLock):
+    pass
+
+
 class AsyncioLockCollector(_lock.LockCollector):
     """Record asyncio.Lock usage."""
 
@@ -25,3 +29,11 @@ class AsyncioSemaphoreCollector(_lock.LockCollector):
     PROFILED_LOCK_CLASS = _ProfiledAsyncioSemaphore
     MODULE = asyncio
     PATCHED_LOCK_NAME = "Semaphore"
+
+
+class AsyncioBoundedSemaphoreCollector(_lock.LockCollector):
+    """Record asyncio.BoundedSemaphore usage."""
+
+    PROFILED_LOCK_CLASS = _ProfiledAsyncioBoundedSemaphore
+    MODULE = asyncio
+    PATCHED_LOCK_NAME = "BoundedSemaphore"

ddtrace/profiling/profiler.py

@@ -219,6 +219,7 @@ def start_collector(collector_class: Type[collector.Collector]) -> None:
                 ("threading", lambda _: start_collector(threading.ThreadingBoundedSemaphoreCollector)),
                 ("asyncio", lambda _: start_collector(asyncio.AsyncioLockCollector)),
                 ("asyncio", lambda _: start_collector(asyncio.AsyncioSemaphoreCollector)),
+                ("asyncio", lambda _: start_collector(asyncio.AsyncioBoundedSemaphoreCollector)),
             ]
 
             for module, hook in self._collectors_on_import:

releasenotes/notes/Added-support-for-profiling-of-asyncio.BoundedSemaphore-objects-to-the-Python-Lock-profiler-5bf06391b0b047f1.yaml

@@ -0,0 +1,7 @@
+---
+features:
+  - |
+    profiling: Add support for ``asyncio.BoundedSemaphore`` locking type profiling in Python.
+    Unlike ``threading.BoundedSemaphore``, the asyncio version does not use internal locks,
+    so no internal lock detection is needed.
+

tests/profiling/collector/test_asyncio.py

@@ -11,6 +11,7 @@
 
 from ddtrace import ext
 from ddtrace.internal.datadog.profiling import ddup
+from ddtrace.profiling.collector.asyncio import AsyncioBoundedSemaphoreCollector
 from ddtrace.profiling.collector.asyncio import AsyncioLockCollector
 from ddtrace.profiling.collector.asyncio import AsyncioSemaphoreCollector
 from tests.profiling.collector import pprof_utils
@@ -23,12 +24,16 @@
 
 PY_311_OR_ABOVE = sys.version_info[:2] >= (3, 11)
 
-# Type aliases for collector and lock types
-CollectorType = Union[
+# Type aliases for supported classes
+LockTypeClass = Union[Type[asyncio.Lock], Type[asyncio.Semaphore], Type[asyncio.BoundedSemaphore]]
+LockTypeInst = Union[asyncio.Lock, asyncio.Semaphore, asyncio.BoundedSemaphore]
+
+CollectorTypeClass = Union[
     Type[AsyncioLockCollector],
     Type[AsyncioSemaphoreCollector],
+    Type[AsyncioBoundedSemaphoreCollector],
 ]
-LockType = Union[Type[asyncio.Lock], Type[asyncio.Semaphore]]
+CollectorTypeInst = Union[AsyncioLockCollector, AsyncioSemaphoreCollector, AsyncioBoundedSemaphoreCollector]
 
 
 @pytest.mark.parametrize(
@@ -42,9 +47,13 @@
             AsyncioSemaphoreCollector,
             "AsyncioSemaphoreCollector(status=<ServiceStatus.STOPPED: 'stopped'>, capture_pct=1.0, nframes=64, tracer=None)",  # noqa: E501
         ),
+        (
+            AsyncioBoundedSemaphoreCollector,
+            "AsyncioBoundedSemaphoreCollector(status=<ServiceStatus.STOPPED: 'stopped'>, capture_pct=1.0, nframes=64, tracer=None)",
+        ),
     ],
 )
-def test_collector_repr(collector_class: CollectorType, expected_repr: str) -> None:
+def test_collector_repr(collector_class: CollectorTypeClass, expected_repr: str) -> None:
     test_collector._test_repr(collector_class, expected_repr)
 
 
@@ -59,19 +68,19 @@ class BaseAsyncioLockCollectorTest:
     """
 
     @property
-    def collector_class(self) -> CollectorType:
+    def collector_class(self) -> CollectorTypeClass:
         raise NotImplementedError("Child classes must implement collector_class")
 
     @property
-    def lock_class(self) -> LockType:
+    def lock_class(self) -> LockTypeClass:
         raise NotImplementedError("Child classes must implement lock_class")
 
     @property
     def lock_init_args(self) -> tuple:
         """Arguments to pass to lock constructor. Override for Semaphore-like locks."""
         return ()
 
-    def create_lock(self) -> Union[asyncio.Lock, asyncio.Semaphore]:
+    def create_lock(self) -> LockTypeInst:
         """Create a lock instance with the appropriate arguments."""
         return self.lock_class(*self.lock_init_args)
 
@@ -242,3 +251,33 @@ def lock_class(self):
     @property
     def lock_init_args(self):
         return (2,)  # Initial semaphore value
+
+
+class TestAsyncioBoundedSemaphoreCollector(BaseAsyncioLockCollectorTest):
+    """Test asyncio.BoundedSemaphore profiling."""
+
+    @property
+    def collector_class(self):
+        return AsyncioBoundedSemaphoreCollector
+
+    @property
+    def lock_class(self):
+        return asyncio.BoundedSemaphore
+
+    @property
+    def lock_init_args(self):
+        return (2,)  # Initial semaphore value
+
+    async def test_bounded_behavior_preserved(self):
+        """Test that profiling wrapper preserves BoundedSemaphore's bounded behavior.
+
+        This verifies the wrapper doesn't interfere with BoundedSemaphore's unique characteristic:
+        raising ValueError when releasing beyond the initial value.
+        """
+        with self.collector_class(capture_pct=100):
+            bs = asyncio.BoundedSemaphore(1)
+            await bs.acquire()
+            bs.release()
+            # BoundedSemaphore should raise ValueError when releasing more than initial value
+            with pytest.raises(ValueError, match="BoundedSemaphore released too many times"):
+                bs.release()

tests/profiling/test_profiler.py

@@ -139,6 +139,7 @@ def test_default_collectors():
     else:
         assert any(isinstance(c, asyncio.AsyncioLockCollector) for c in p._profiler._collectors)
         assert any(isinstance(c, asyncio.AsyncioSemaphoreCollector) for c in p._profiler._collectors)
+        assert any(isinstance(c, asyncio.AsyncioBoundedSemaphoreCollector) for c in p._profiler._collectors)
     p.stop(flush=False)