chore(di): ensure signals in wrapping context (#12239)

We make sure that the signals queue is always added to the wrapping
context when they signals context are opened.

## Checklist
- [x] PR author has checked that all the criteria below are met
- The PR description includes an overview of the change
- The PR description articulates the motivation for the change
- The change includes tests OR the PR description describes a testing
strategy
- The PR description notes risks associated with the change, if any
- Newly-added code is easy to change
- The change follows the [library release note
guidelines](https://ddtrace.readthedocs.io/en/stable/releasenotes.html)
- The change includes or references documentation updates if necessary
- Backport labels are set (if
[applicable](https://ddtrace.readthedocs.io/en/latest/contributing.html#backporting))

## Reviewer Checklist
- [ ] Reviewer has checked that all the criteria below are met 
- Title is accurate
- All changes are related to the pull request's stated goal
- Avoids breaking
[API](https://ddtrace.readthedocs.io/en/stable/versioning.html#interfaces)
changes
- Testing strategy adequately addresses listed risks
- Newly-added code is easy to change
- Release note makes sense to a user of the library
- If necessary, author has acknowledged and discussed the performance
implications of this PR as reported in the benchmarks PR comment
- Backport labels are set in a manner that is consistent with the
[release branch maintenance
policy](https://ddtrace.readthedocs.io/en/latest/contributing.html#backporting)

---------

Co-authored-by: Yun Kim <[email protected]>
Co-authored-by: Nicole Cybul <[email protected]>
Co-authored-by: Nick Ripley <[email protected]>
Co-authored-by: William Conti <[email protected]>
Co-authored-by: Christophe Papazian <[email protected]>
Co-authored-by: Munir Abdinur <[email protected]>
Co-authored-by: Laplie Anderson <[email protected]>
Co-authored-by: Brett Langdon <[email protected]>

Author: 9 people

ddtrace/debugging/_debugger.py

@@ -160,13 +160,6 @@ def has_probes(self) -> bool:
         return bool(self.probes)
 
     def _open_signals(self) -> None:
-        frame = self.__frame__
-        assert frame is not None  # nosec
-
-        thread = threading.current_thread()
-
-        signal: Optional[Signal] = None
-
         # Group probes on the basis of whether they create new context.
         context_creators: List[Probe] = []
         context_consumers: List[Probe] = []
@@ -175,39 +168,47 @@ def _open_signals(self) -> None:
 
         signals: Deque[Signal] = deque()
 
-        # Trigger the context creators first, so that the new context can be
-        # consumed by the consumers.
-        for probe in chain(context_creators, context_consumers):
-            # Because new context might be created, we need to recompute it
-            # for each probe.
-            trace_context = self._tracer.current_trace_context()
-
-            try:
-                signal = Signal.from_probe(
-                    probe,
-                    frame=frame,
-                    thread=thread,
-                    trace_context=trace_context,
-                    meter=self._probe_meter,
-                )
-            except TypeError:
-                log.error("Unsupported probe type: %s", type(probe))
-                continue
+        try:
+            frame = self.__frame__
+            thread = threading.current_thread()
 
-            try:
-                signal.do_enter()
-            except Exception:
-                log.exception("Failed to enter signal %r", signal)
-                continue
-            signals.append(signal)
+            # Trigger the context creators first, so that the new context can be
+            # consumed by the consumers.
+            for probe in chain(context_creators, context_consumers):
+                try:
+                    signal = Signal.from_probe(
+                        probe,
+                        frame=frame,
+                        thread=thread,
+                        # Because new context might be created, we need to
+                        # recompute it for each probe.
+                        trace_context=self._tracer.current_trace_context(),
+                        meter=self._probe_meter,
+                    )
+                except TypeError:
+                    log.error("Unsupported probe type: %s", type(probe))
+                    continue
 
-        # Save state on the wrapping context
-        self.set("start_time", time.monotonic_ns())
-        self.set("signals", signals)
+                try:
+                    signal.do_enter()
+                except Exception:
+                    log.exception("Failed to enter signal %r", signal)
+                    continue
+                signals.append(signal)
+        finally:
+            # Save state on the wrapping context
+            self.set("start_time", time.monotonic_ns())
+            self.set("signals", signals)
 
     def _close_signals(self, retval=None, exc_info=(None, None, None)) -> None:
         end_time = time.monotonic_ns()
-        signals = cast(Deque[Signal], self.get("signals"))
+
+        try:
+            signals = cast(Deque[Signal], self.get("signals"))
+        except KeyError:
+            log.error("Signal contexts were not opened for function probe over %s", self.__wrapped__)
+            return
+
         while signals:
             # Open probe signals are ordered, with those that have created new
             # tracing context first. We need to finalize them in reverse order,