refactor(debugger): use single dispatch on probes (#11596)

We refactor the debugger code to use a single dispatch function solution
instead of a battery of instance check branches.

## 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)

Author: P403n1x87

ddtrace/debugging/_debugger.py

@@ -31,26 +31,15 @@
 from ddtrace.debugging._probe.model import FunctionProbe
 from ddtrace.debugging._probe.model import LineLocationMixin
 from ddtrace.debugging._probe.model import LineProbe
-from ddtrace.debugging._probe.model import LogFunctionProbe
-from ddtrace.debugging._probe.model import LogLineProbe
-from ddtrace.debugging._probe.model import MetricFunctionProbe
-from ddtrace.debugging._probe.model import MetricLineProbe
 from ddtrace.debugging._probe.model import Probe
-from ddtrace.debugging._probe.model import SpanDecorationFunctionProbe
-from ddtrace.debugging._probe.model import SpanDecorationLineProbe
-from ddtrace.debugging._probe.model import SpanFunctionProbe
 from ddtrace.debugging._probe.registry import ProbeRegistry
 from ddtrace.debugging._probe.remoteconfig import ProbePollerEvent
 from ddtrace.debugging._probe.remoteconfig import ProbePollerEventType
 from ddtrace.debugging._probe.remoteconfig import ProbeRCAdapter
 from ddtrace.debugging._probe.status import ProbeStatusLogger
 from ddtrace.debugging._signal.collector import SignalCollector
-from ddtrace.debugging._signal.metric_sample import MetricSample
 from ddtrace.debugging._signal.model import Signal
 from ddtrace.debugging._signal.model import SignalState
-from ddtrace.debugging._signal.snapshot import Snapshot
-from ddtrace.debugging._signal.tracing import DynamicSpan
-from ddtrace.debugging._signal.tracing import SpanDecoration
 from ddtrace.debugging._uploader import LogsIntakeUploaderV1
 from ddtrace.debugging._uploader import UploaderProduct
 from ddtrace.internal import compat
@@ -62,7 +51,6 @@
 from ddtrace.internal.module import register_post_run_module_hook
 from ddtrace.internal.module import unregister_post_run_module_hook
 from ddtrace.internal.rate_limiter import BudgetRateLimiterWithJitter as RateLimiter
-from ddtrace.internal.rate_limiter import RateLimitExceeded
 from ddtrace.internal.remoteconfig.worker import remoteconfig_poller
 from ddtrace.internal.service import Service
 from ddtrace.internal.wrapping.context import WrappingContext
@@ -190,35 +178,15 @@ def _open_signals(self) -> None:
             # for each probe.
             trace_context = self._tracer.current_trace_context()
 
-            if isinstance(probe, MetricFunctionProbe):
-                signal = MetricSample(
-                    probe=probe,
+            try:
+                signal = Signal.from_probe(
+                    probe,
                     frame=frame,
                     thread=thread,
                     trace_context=trace_context,
                     meter=self._probe_meter,
                 )
-            elif isinstance(probe, LogFunctionProbe):
-                signal = Snapshot(
-                    probe=probe,
-                    frame=frame,
-                    thread=thread,
-                    trace_context=trace_context,
-                )
-            elif isinstance(probe, SpanFunctionProbe):
-                signal = DynamicSpan(
-                    probe=probe,
-                    frame=frame,
-                    thread=thread,
-                    trace_context=trace_context,
-                )
-            elif isinstance(probe, SpanDecorationFunctionProbe):
-                signal = SpanDecoration(
-                    probe=probe,
-                    frame=frame,
-                    thread=thread,
-                )
-            else:
+            except TypeError:
                 log.error("Unsupported probe type: %s", type(probe))
                 continue
 
@@ -385,39 +353,19 @@ def _dd_debugger_hook(self, probe: Probe) -> None:
         instrumented code is running.
         """
         try:
-            actual_frame = sys._getframe(1)
-            signal: Optional[Signal] = None
-            if isinstance(probe, MetricLineProbe):
-                signal = MetricSample(
-                    probe=probe,
-                    frame=actual_frame,
+            try:
+                signal = Signal.from_probe(
+                    probe,
+                    frame=sys._getframe(1),
                     thread=threading.current_thread(),
                     trace_context=self._tracer.current_trace_context(),
                     meter=self._probe_meter,
                 )
-            elif isinstance(probe, LogLineProbe):
-                if probe.take_snapshot:
-                    # TODO: Global limit evaluated before probe conditions
-                    if self._global_rate_limiter.limit() is RateLimitExceeded:
-                        return
-
-                signal = Snapshot(
-                    probe=probe,
-                    frame=actual_frame,
-                    thread=threading.current_thread(),
-                    trace_context=self._tracer.current_trace_context(),
-                )
-            elif isinstance(probe, SpanDecorationLineProbe):
-                signal = SpanDecoration(
-                    probe=probe,
-                    frame=actual_frame,
-                    thread=threading.current_thread(),
-                )
-            else:
-                log.error("Unsupported probe type: %r", type(probe))
+            except TypeError:
+                log.error("Unsupported probe type: %r", type(probe), exc_info=True)
                 return
 
-            signal.do_line()
+            signal.do_line(self._global_rate_limiter if probe.is_global_rate_limited() else None)
 
             if signal.state is SignalState.DONE:
                 self._probe_registry.set_emitting(probe)

ddtrace/debugging/_encoding.py

@@ -15,7 +15,7 @@
 from typing import Union
 
 from ddtrace.debugging._config import di_config
-from ddtrace.debugging._signal.model import LogSignal
+from ddtrace.debugging._signal.log import LogSignal
 from ddtrace.debugging._signal.snapshot import Snapshot
 from ddtrace.internal import forksafe
 from ddtrace.internal._encoding import BufferFull

ddtrace/debugging/_expressions.py

@@ -23,6 +23,7 @@
     arg_operation           =>  {"<arg_op_type>": [<argument_list>]}
     arg_op_type             =>  filter | substring | getmember | index
 """  # noqa
+
 from dataclasses import dataclass
 from itertools import chain
 import re

ddtrace/debugging/_probe/model.py

@@ -85,6 +85,9 @@ def update(self, other: "Probe") -> None:
         for attrib in (f.name for f in fields(self) if f.compare):
             setattr(self, attrib, getattr(other, attrib))
 
+    def is_global_rate_limited(self) -> bool:
+        return False
+
     def __hash__(self):
         return hash(self.probe_id)
 
@@ -245,12 +248,14 @@ class LogProbeMixin(AbstractProbeMixIn):
 
 @dataclass
 class LogLineProbe(Probe, LineLocationMixin, LogProbeMixin, ProbeConditionMixin, RateLimitMixin):
-    pass
+    def is_global_rate_limited(self) -> bool:
+        return self.take_snapshot
 
 
 @dataclass
 class LogFunctionProbe(Probe, FunctionLocationMixin, TimingMixin, LogProbeMixin, ProbeConditionMixin, RateLimitMixin):
-    pass
+    def is_global_rate_limited(self) -> bool:
+        return self.take_snapshot
 
 
 @dataclass

ddtrace/debugging/_signal/__init__.py

@@ -0,0 +1,5 @@
+# DEV: Import these modules to allow registering the single dispatch functions
+from ddtrace.debugging._signal.metric_sample import MetricSample  # noqa
+from ddtrace.debugging._signal.snapshot import Snapshot  # noqa
+from ddtrace.debugging._signal.tracing import DynamicSpan  # noqa
+from ddtrace.debugging._signal.tracing import SpanDecoration  # noqa

ddtrace/debugging/_signal/collector.py

@@ -6,7 +6,7 @@
 
 from ddtrace.debugging._encoding import BufferedEncoder
 from ddtrace.debugging._metrics import metrics
-from ddtrace.debugging._signal.model import LogSignal
+from ddtrace.debugging._signal.log import LogSignal
 from ddtrace.debugging._signal.model import Signal
 from ddtrace.debugging._signal.model import SignalState
 from ddtrace.internal._encoding import BufferFull

ddtrace/debugging/_signal/log.py

@@ -0,0 +1,67 @@
+import abc
+from dataclasses import dataclass
+import typing as t
+
+from ddtrace.debugging._probe.model import FunctionLocationMixin
+from ddtrace.debugging._probe.model import LineLocationMixin
+from ddtrace.debugging._signal.model import Signal
+
+
+@dataclass
+class LogSignal(Signal):
+    """A signal that also emits a log message.
+
+    Some signals might require sending a log message along with the base signal
+    data. For example, all the collected errors from expression evaluations
+    (e.g. conditions) might need to be reported.
+    """
+
+    @property
+    @abc.abstractmethod
+    def message(self) -> t.Optional[str]:
+        """The log message to emit."""
+        pass
+
+    @abc.abstractmethod
+    def has_message(self) -> bool:
+        """Whether the signal has a log message to emit."""
+        pass
+
+    @property
+    def data(self) -> t.Dict[str, t.Any]:
+        """Extra data to include in the snapshot portion of the log message."""
+        return {}
+
+    def _probe_details(self) -> t.Dict[str, t.Any]:
+        probe = self.probe
+        if isinstance(probe, LineLocationMixin):
+            location = {
+                "file": str(probe.resolved_source_file),
+                "lines": [str(probe.line)],
+            }
+        elif isinstance(probe, FunctionLocationMixin):
+            location = {
+                "type": probe.module,
+                "method": probe.func_qname,
+            }
+        else:
+            return {}
+
+        return {
+            "id": probe.probe_id,
+            "version": probe.version,
+            "location": location,
+        }
+
+    @property
+    def snapshot(self) -> t.Dict[str, t.Any]:
+        full_data = {
+            "id": self.uuid,
+            "timestamp": int(self.timestamp * 1e3),  # milliseconds
+            "evaluationErrors": [{"expr": e.expr, "message": e.message} for e in self.errors],
+            "probe": self._probe_details(),
+            "language": "python",
+        }
+        full_data.update(self.data)
+
+        return full_data

ddtrace/debugging/_signal/metric_sample.py

@@ -4,9 +4,12 @@
 from typing import cast
 
 from ddtrace.debugging._metrics import probe_metrics
+from ddtrace.debugging._probe.model import MetricFunctionProbe
+from ddtrace.debugging._probe.model import MetricLineProbe
 from ddtrace.debugging._probe.model import MetricProbeKind
 from ddtrace.debugging._probe.model import MetricProbeMixin
-from ddtrace.debugging._signal.model import LogSignal
+from ddtrace.debugging._signal.log import LogSignal
+from ddtrace.debugging._signal.model import probe_to_signal
 from ddtrace.internal.metrics import Metrics
 
 
@@ -50,3 +53,13 @@ def message(self) -> Optional[str]:
 
     def has_message(self) -> bool:
         return bool(self.errors)
+
+
+@probe_to_signal.register
+def _(probe: MetricFunctionProbe, frame, thread, trace_context, meter):
+    return MetricSample(probe=probe, frame=frame, thread=thread, trace_context=trace_context, meter=meter)
+
+
+@probe_to_signal.register
+def _(probe: MetricLineProbe, frame, thread, trace_context, meter):
+    return MetricSample(probe=probe, frame=frame, thread=thread, trace_context=trace_context, meter=meter)