chore(debugger): support for all metric kinds with value expression (#4699)

## Description

Effort to make feature parity with dd-trace-java metric implementation. 
To gain parity python debugger need to support:
1. GAUGE and HISTOGRAM metrics. 
2. Be able to evaluate the metric value expression
3. Support Method Metric Probe with duration

We also decided to support DISTRIBUTION metric support as well. 
This PR address the two main features. future PR would add support for
function level Metric Probe

## Reviewer Checklist
- [ ] Title is accurate.
- [ ] Description motivates each change.
- [ ] No unnecessary changes were introduced in this PR.
- [ ] Avoid breaking
[API](https://ddtrace.readthedocs.io/en/stable/versioning.html#interfaces)
changes unless absolutely necessary.
- [ ] Tests provided or description of manual testing performed is
included in the code or PR.
- [ ] Release note has been added and follows the [library release note
guidelines](https://ddtrace.readthedocs.io/en/stable/contributing.html#Release-Note-Guidelines),
or else `changelog/no-changelog` label added.
- [ ] All relevant GitHub issues are correctly linked.
- [ ] Backports are identified and tagged with Mergifyio.

Co-authored-by: Brett Langdon <[email protected]>
Co-authored-by: Gabriele N. Tornetta <[email protected]>

Author: 3 people

ddtrace/debugging/_debugger.py

@@ -254,10 +254,19 @@ def _dd_debugger_hook(self, probe):
             if isinstance(probe, MetricProbe):
                 # TODO: Handle value expressions
                 assert probe.kind is not None and probe.name is not None
+
+                value = float(probe.value(sys._getframe(1).f_locals)) if probe.value is not None else 1
+
+                # TODO[perf]: We know the tags in advance so we can avoid the
+                # list comprehension.
                 if probe.kind == MetricProbeKind.COUNTER:
-                    # TODO[perf]: We know the tags in advance so we can avoid the
-                    # list comprehension.
-                    self._probe_meter.increment(probe.name, tags=probe.tags)
+                    self._probe_meter.increment(probe.name, value, probe.tags)
+                elif probe.kind == MetricProbeKind.GAUGE:
+                    self._probe_meter.gauge(probe.name, value, probe.tags)
+                elif probe.kind == MetricProbeKind.HISTOGRAM:
+                    self._probe_meter.histogram(probe.name, value, probe.tags)
+                elif probe.kind == MetricProbeKind.DISTRIBUTION:
+                    self._probe_meter.distribution(probe.name, value, probe.tags)
 
                 return
 

ddtrace/debugging/_probe/model.py

@@ -107,3 +107,4 @@ class MetricProbeKind(object):
 class MetricProbe(LineProbe):
     kind = attr.ib(type=Optional[str], default=None)
     name = attr.ib(type=Optional[str], default=None)
+    value = attr.ib(type=Optional[Callable[[Dict[str, Any]], Any]], default=None)

ddtrace/debugging/_probe/remoteconfig.py

@@ -25,21 +25,21 @@
 _EXPRESSION_CACHE = LFUCache()
 
 
-def _invalid_condition(_):
-    """Forces probes with invalid conditions to never trigger.
+def _invalid_expression(_):
+    """Forces probes with invalid expression/conditions to never trigger.
 
     Any signs of invalid conditions in logs is an indication of a problem with
     the expression compiler.
     """
     return False
 
 
-INVALID_CONDITION = _invalid_condition
+INVALID_EXPRESSION = _invalid_expression
 
 
-def _compile_condition(when):
+def _compile_expression(when):
     # type: (Optional[Dict[str, Any]]) -> Optional[Callable[[Dict[str, Any]], Any]]
-    global _EXPRESSION_CACHE, INVALID_CONDITION
+    global _EXPRESSION_CACHE, INVALID_EXPRESSION
 
     if when is None:
         return None
@@ -52,13 +52,13 @@ def compile_or_invalid(expr):
             return dd_compile(ast)
         except Exception:
             log.error("Cannot compile expression: %s", expr, exc_info=True)
-            return INVALID_CONDITION
+            return INVALID_EXPRESSION
 
     expr = when["dsl"]
 
     compiled = _EXPRESSION_CACHE.get(expr, compile_or_invalid)  # type: Callable[[Dict[str, Any]], Any]
 
-    if compiled is INVALID_CONDITION:
+    if compiled is INVALID_EXPRESSION:
         log.error("Cannot compile expression: %s", expr, exc_info=True)
 
     return compiled
@@ -91,7 +91,7 @@ def probe(_id, _type, attribs):
     if _type == "snapshotProbes":
         args = dict(
             probe_id=_id,
-            condition=_compile_condition(attribs.get("when")),
+            condition=_compile_expression(attribs.get("when")),
             active=attribs["active"],
             tags=dict(_.split(":", 1) for _ in attribs.get("tags", [])),
         )
@@ -116,6 +116,7 @@ def probe(_id, _type, attribs):
             line=int(attribs["where"]["lines"][0]),
             name=attribs["metricName"],
             kind=attribs["kind"],
+            value=_compile_expression(attribs.get("value")),
         )
 
     raise ValueError("Unknown probe type: %s" % _type)

ddtrace/internal/metrics.py

@@ -47,6 +47,24 @@ def increment(self, name, value=1.0, tags=None):
                 ".".join((self.name, name)), value, [":".join(_) for _ in tags.items()] if tags else None
             )
 
+        def gauge(self, name, value=1.0, tags=None):
+            # type: (str, float, Optional[Dict[str, str]]) -> None
+            if not self.metrics.enabled:
+                return None
+
+            self.metrics._client.gauge(
+                ".".join((self.name, name)), value, [":".join(_) for _ in tags.items()] if tags else None
+            )
+
+        def histogram(self, name, value=1.0, tags=None):
+            # type: (str, float, Optional[Dict[str, str]]) -> None
+            if not self.metrics.enabled:
+                return None
+
+            self.metrics._client.histogram(
+                ".".join((self.name, name)), value, [":".join(_) for _ in tags.items()] if tags else None
+            )
+
         def distribution(self, name, value=1.0, tags=None):
             # type: (str, float, Optional[Dict[str, str]]) -> None
             if not self.metrics.enabled:

tests/debugging/test_debugger.py

@@ -481,25 +481,58 @@ def mock_metrics():
         _probe_metrics._client = old_client
 
 
-def test_debugger_metric_probe(mock_metrics):
+def create_line_metric_probe(kind, value=None):
+    return MetricProbe(
+        probe_id="metric-probe-test",
+        source_file="tests/submod/stuff.py",
+        line=36,
+        kind=kind,
+        name="test.counter",
+        tags={"foo": "bar"},
+        value=value,
+    )
+
+
+def test_debugger_metric_probe_simple_count(mock_metrics):
     with debugger() as d:
-        d.add_probes(
-            MetricProbe(
-                probe_id="metric-probe-test",
-                source_file="tests/submod/stuff.py",
-                line=36,
-                kind=MetricProbeKind.COUNTER,
-                name="test.counter",
-                tags={"foo": "bar"},
-            ),
-        )
+        d.add_probes(create_line_metric_probe(MetricProbeKind.COUNTER))
         sleep(0.5)
-
         Stuff().instancestuff()
-
         assert call("probe.test.counter", 1.0, ["foo:bar"]) in mock_metrics.increment.mock_calls
 
 
+def test_debugger_metric_probe_count_value(mock_metrics):
+    with debugger() as d:
+        d.add_probes(create_line_metric_probe(MetricProbeKind.COUNTER, dd_compile("#bar")))
+        sleep(0.5)
+        Stuff().instancestuff(40)
+        assert call("probe.test.counter", 40.0, ["foo:bar"]) in mock_metrics.increment.mock_calls
+
+
+def test_debugger_metric_probe_guage_value(mock_metrics):
+    with debugger() as d:
+        d.add_probes(create_line_metric_probe(MetricProbeKind.GAUGE, dd_compile("#bar")))
+        sleep(0.5)
+        Stuff().instancestuff(41)
+        assert call("probe.test.counter", 41.0, ["foo:bar"]) in mock_metrics.gauge.mock_calls
+
+
+def test_debugger_metric_probe_histogram_value(mock_metrics):
+    with debugger() as d:
+        d.add_probes(create_line_metric_probe(MetricProbeKind.HISTOGRAM, dd_compile("#bar")))
+        sleep(0.5)
+        Stuff().instancestuff(42)
+        assert call("probe.test.counter", 42.0, ["foo:bar"]) in mock_metrics.histogram.mock_calls
+
+
+def test_debugger_metric_probe_distribution_value(mock_metrics):
+    with debugger() as d:
+        d.add_probes(create_line_metric_probe(MetricProbeKind.DISTRIBUTION, dd_compile("#bar")))
+        sleep(0.5)
+        Stuff().instancestuff(43)
+        assert call("probe.test.counter", 43.0, ["foo:bar"]) in mock_metrics.distribution.mock_calls
+
+
 def test_debugger_multiple_function_probes_on_same_function():
     global Stuff