fix(profiling): fix silent suppression of AssertionError exceptions in _ProfiledLock::_acquire (#15089)

https://datadoghq.atlassian.net/browse/PROF-12903

## Description
`_ProfiledLock::_maybe_update_self_name` raises `AssertionError` in two
places when `config.enable_asserts == True`.

However, they're being silently suppressed by the try/catch block in the
caller, `_ProfiledLock::_acquire`, method.

Current estimated impact is low, as it's only ever triggered for
development workflows, but still, worth making it right. This PR fixes
the bug by propagating `AssertionError`'s by the caller.

## Testing
Added two new tests: one for `AssertionError` and another for a
non-`AssertionError` exception.

**PROD**
_Test fails, since the `AssertionError` exception is not propagated_
```
$ ./scripts/ddtest riot -v run --pass-env d667cb4 -- -k test_assertion_error_suppressed_in_acquire
...
FAILED tests/profiling_v2/collector/test_threading.py::TestThreadingLockCollector::test_assertion_error_suppressed_in_acquire - Failed: DID NOT RAISE <class 'AssertionError'>
FAILED tests/profiling_v2/collector/test_threading.py::TestThreadingRLockCollector::test_assertion_error_suppressed_in_acquire - Failed: DID NOT RAISE <class 'AssertionError'>
```
_Highlighted code is for demonstration purposes only - not being merged_
<img width="703" height="735" alt="Screenshot 2025-10-30 at 10 36 28 AM"
src="https://github.com/user-attachments/assets/4c3d8066-3aa2-465e-8386-0f13a3de0cf6"
/>

**BRANCH**
_Test passes_
```
$ ./scripts/ddtest riot -v run --pass-env d667cb4 -- -k test_assertion_error_suppressed_in_acquire
...
tests/profiling_v2/collector/test_threading.py::TestThreadingLockCollector::test_assertion_error_suppressed_in_acquire PASSED
tests/profiling_v2/collector/test_threading.py::TestThreadingRLockCollector::test_assertion_error_suppressed_in_acquire PASSED
```
## Risks

none

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

Author: vlad-scherbich

ddtrace/profiling/collector/_lock.py

@@ -29,6 +29,12 @@
 from ddtrace.trace import Tracer
 
 
+ACQUIRE_RELEASE_CO_NAMES: frozenset[str] = frozenset(["_acquire", "_release"])
+ENTER_EXIT_CO_NAMES: frozenset[str] = frozenset(
+    ["acquire", "release", "__enter__", "__exit__", "__aenter__", "__aexit__"]
+)
+
+
 def _current_thread() -> Tuple[int, str]:
     thread_id: int = _thread.get_ident()
     return thread_id, _threading.get_thread_name(thread_id)
@@ -91,7 +97,12 @@ def _acquire(self, inner_func: Callable[..., Any], *args: Any, **kwargs: Any) ->
             try:
                 self._maybe_update_self_name()
                 self._flush_sample(start, end, is_acquire=True)
+            except AssertionError:
+                if config.enable_asserts:
+                    # AssertionError exceptions need to propagate
+                    raise
             except Exception:
+                # Instrumentation must never crash user code
                 pass  # nosec
 
     def release(self, *args: Any, **kwargs: Any) -> Any:
@@ -202,26 +213,16 @@ def _maybe_update_self_name(self) -> None:
         # 3: caller frame
         if config.enable_asserts:
             frame: FrameType = sys._getframe(1)
-            # TODO: replace dict with list
-            if frame.f_code.co_name not in {"_acquire", "_release"}:
-                raise AssertionError("Unexpected frame %s" % frame.f_code.co_name)
+            if frame.f_code.co_name not in ACQUIRE_RELEASE_CO_NAMES:
+                raise AssertionError(f"Unexpected frame in stack: '{frame.f_code.co_name}'")
+
             frame = sys._getframe(2)
-            if frame.f_code.co_name not in {
-                "acquire",
-                "release",
-                "__enter__",
-                "__exit__",
-                "__aenter__",
-                "__aexit__",
-            }:
-                raise AssertionError("Unexpected frame %s" % frame.f_code.co_name)
-        frame = sys._getframe(3)
+            if frame.f_code.co_name not in ENTER_EXIT_CO_NAMES:
+                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
-        self._self_name = self._find_self_name(frame.f_locals) or self._find_self_name(frame.f_globals)
-
-        if not self._self_name:
-            self._self_name = ""
+        frame = sys._getframe(3)
+        self._self_name = self._find_self_name(frame.f_locals) or self._find_self_name(frame.f_globals) or ""
 
 
 class FunctionWrapper(wrapt.FunctionWrapper):

releasenotes/notes/fixed-silent-suppression-of-AssertionError-exceptions-in-Lock-profiler-20645079ab43b23d.yaml

@@ -0,0 +1,4 @@
+---
+fixes:
+  - |
+    profiling: This fix resolves an issue where AssertionError exceptions were silently suppressed in the `_acquire` method of the Lock profiler (note: this only occurs when assertions are enabled.)

tests/profiling_v2/collector/test_threading.py

@@ -360,6 +360,70 @@ 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