new tests with different config settings

Author: vlad-scherbich

ddtrace/profiling/collector/_lock.py

@@ -238,11 +238,11 @@ def _maybe_update_self_name(self) -> None:
         if config.enable_asserts:
             frame: FrameType = sys._getframe(1)
             if frame.f_code.co_name not in ACQUIRE_RELEASE_CO_NAMES:
-                raise AssertionError("Unexpected frame %s" % frame.f_code.co_name)
+                raise AssertionError(f"Unexpected frame in stack: '{frame.f_code.co_name}'")
 
             frame = sys._getframe(2)
             if frame.f_code.co_name not in ENTER_EXIT_CO_NAMES:
-                raise AssertionError("Unexpected frame %s" % frame.f_code.co_name)
+                raise AssertionError(f"Unexpected frame in stack: '{frame.f_code.co_name}'")
 
         # First, look at the local variables of the caller frame, and then the global variables
         frame = sys._getframe(3)

tests/profiling_v2/collector/test_threading.py

@@ -360,6 +360,67 @@ def validate_and_cleanup() -> None:
     validate_and_cleanup()
 
 
+@pytest.mark.subprocess(env=dict(DD_PROFILING_ENABLE_ASSERTS="true"))
+def test_assertion_error_raised_with_enable_asserts():
+    """Ensure that AssertionError is propagated when config.enable_asserts=True."""
+    import threading
+
+    import mock
+    import pytest
+
+    from ddtrace.internal.datadog.profiling import ddup
+    from ddtrace.profiling.collector.threading import ThreadingLockCollector
+
+    # 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()
+
+    with ThreadingLockCollector(capture_pct=100):
+        lock = threading.Lock()
+
+        # Patch _maybe_update_self_name to raise AssertionError
+        lock._maybe_update_self_name = mock.Mock(side_effect=AssertionError("test: unexpected frame in stack"))
+
+        with pytest.raises(AssertionError):
+            # AssertionError should be propagated when enable_asserts=True
+            lock.acquire()
+
+
+@pytest.mark.subprocess(env=dict(DD_PROFILING_ENABLE_ASSERTS="false"))
+def test_all_exceptions_suppressed_by_default() -> None:
+    """Ensure that exceptions are silently suppressed in the `_acquire` method when config.enable_asserts=False (default)."""
+    import threading
+
+    import mock
+
+    from ddtrace.internal.datadog.profiling import ddup
+    from ddtrace.profiling.collector.threading import ThreadingLockCollector
+
+    # 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()
+
+    with ThreadingLockCollector(capture_pct=100):
+        lock = threading.Lock()
+
+        # Patch _maybe_update_self_name to raise AssertionError
+        lock._maybe_update_self_name = mock.Mock(side_effect=AssertionError("Unexpected frame in stack: 'fubar'"))
+        lock.acquire()
+        lock.release()
+
+        # Patch _maybe_update_self_name to raise RuntimeError
+        lock._maybe_update_self_name = mock.Mock(side_effect=RuntimeError("Some profiling error"))
+        lock.acquire()
+        lock.release()
+
+        # Patch _maybe_update_self_name to raise Exception
+        lock._maybe_update_self_name = mock.Mock(side_effect=Exception("Wut happened?!?!"))
+        lock.acquire()
+        lock.release()
+
+
 class BaseThreadingLockCollectorTest:
     # These should be implemented by child classes
     @property
@@ -979,32 +1040,6 @@ def test_upload_resets_profile(self) -> None:
         with pytest.raises(AssertionError):
             pprof_utils.parse_newest_profile(self.output_filename)
 
-    def test_assertion_exceptions_raised_in_acquire(self) -> None:
-        """Ensure that AssertionError exceptions is propagated in the `_acquire` method."""
-
-        with self.collector_class(capture_pct=100):
-            lock = self.lock_class()
-
-            # Patch _maybe_update_self_name to raise AssertionError
-            lock._maybe_update_self_name = mock.Mock(side_effect=AssertionError("test: unexpected frame in stack"))
-
-            with pytest.raises(AssertionError):
-                # acquire() will propagate AssertionError if _maybe_update_self_name raises it
-                lock.acquire()
-
-    def test_non_assertion_exceptions_suppressed_in_acquire(self) -> None:
-        """Ensure that non - AssertionError exceptions are silently suppressed in the `_acquire` method."""
-
-        with self.collector_class(capture_pct=100):
-            lock = self.lock_class()
-
-            # Patch _maybe_update_self_name to raise RuntimeError
-            lock._maybe_update_self_name = mock.Mock(side_effect=RuntimeError("Some profiling error"))
-
-            # RuntimeError should be caught and suppressed - lock operations should succeed
-            lock.acquire()
-            lock.release()
-
 
 class TestThreadingLockCollector(BaseThreadingLockCollectorTest):
     """Test Lock profiling"""