chore(di): add @key and @value to collection expressions (#12028)

We add the `@key` and `@value` special identifier to allow users to
refer to keys and values from a dict-like object.

## Checklist
- [ ] 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/_expressions.py

@@ -46,6 +46,7 @@
 from ddtrace.debugging._safety import safe_getitem
 from ddtrace.internal.compat import PYTHON_VERSION_INFO as PY
 from ddtrace.internal.logger import get_logger
+from ddtrace.internal.safety import _isinstance
 
 
 DDASTType = Union[Dict[str, Any], Dict[str, List[Any]], Any]
@@ -126,7 +127,7 @@ def _make_function(self, ast: DDASTType, args: Tuple[str, ...], name: str) -> Fu
         return FunctionType(abstract_code.to_code(), {}, name, (), None)
 
     def _make_lambda(self, ast: DDASTType) -> Callable[[Any, Any], Any]:
-        return self._make_function(ast, ("_dd_it", "_locals"), "<lambda>")
+        return self._make_function(ast, ("_dd_it", "_dd_key", "_dd_value", "_locals"), "<lambda>")
 
     def _compile_direct_predicate(self, ast: DDASTType) -> Optional[List[Instr]]:
         # direct_predicate       =>  {"<direct_predicate_type>": <predicate>}
@@ -200,12 +201,12 @@ def _compile_arg_predicate(self, ast: DDASTType) -> Optional[List[Instr]]:
             if ca is None:
                 raise ValueError("Invalid argument: %r" % a)
 
-            return self._call_function(
-                lambda i, c, _locals: f(c(_, _locals) for _ in i),
-                ca,
-                [Instr("LOAD_CONST", fb)],
-                [Instr("LOAD_FAST", "_locals")],
-            )
+            def coll_iter(it, cond, _locals):
+                if _isinstance(it, dict):
+                    return f(cond(k, k, v, _locals) for k, v in it.items())
+                return f(cond(e, None, None, _locals) for e in it)
+
+            return self._call_function(coll_iter, ca, [Instr("LOAD_CONST", fb)], [Instr("LOAD_FAST", "_locals")])
 
         if _type in {"startsWith", "endsWith"}:
             a, b = args
@@ -245,8 +246,8 @@ def _compile_direct_operation(self, ast: DDASTType) -> Optional[List[Instr]]:
             if not isinstance(arg, str):
                 return None
 
-            if arg == "@it":
-                return [Instr("LOAD_FAST", "_dd_it")]
+            if arg in {"@it", "@key", "@value"}:
+                return [Instr("LOAD_FAST", f"_dd_{arg[1:]}")]
 
             return self._call_function(
                 get_local, [Instr("LOAD_FAST", "_locals")], [Instr("LOAD_CONST", self.__ref__(arg))]
@@ -297,12 +298,12 @@ def _compile_arg_operation(self, ast: DDASTType) -> Optional[List[Instr]]:
             if ca is None:
                 raise ValueError("Invalid argument: %r" % a)
 
-            return self._call_function(
-                lambda i, c, _locals: type(i)(_ for _ in i if c(_, _locals)),
-                ca,
-                [Instr("LOAD_CONST", fb)],
-                [Instr("LOAD_FAST", "_locals")],
-            )
+            def coll_filter(it, cond, _locals):
+                if _isinstance(it, dict):
+                    return type(it)({k: v for k, v in it.items() if cond(k, k, v, _locals)})
+                return type(it)(e for e in it if cond(e, None, None, _locals))
+
+            return self._call_function(coll_filter, ca, [Instr("LOAD_CONST", fb)], [Instr("LOAD_FAST", "_locals")])
 
         if _type == "getmember":
             v, attr = args

tests/debugging/test_expressions.py

@@ -74,6 +74,10 @@ def __getitem__(self, name):
         ({"eq": [{"ref": "hits"}, None]}, {"hits": None}, True),
         ({"substring": [{"ref": "payload"}, 4, 7]}, {"payload": "hello world"}, "hello world"[4:7]),
         ({"any": [{"ref": "collection"}, {"isEmpty": {"ref": "@it"}}]}, {"collection": ["foo", "bar", ""]}, True),
+        ({"any": [{"ref": "coll"}, {"isEmpty": {"ref": "@value"}}]}, {"coll": {0: "foo", 1: "bar", 2: ""}}, True),
+        ({"any": [{"ref": "coll"}, {"isEmpty": {"ref": "@value"}}]}, {"coll": {0: "foo", 1: "bar", 2: "baz"}}, False),
+        ({"any": [{"ref": "coll"}, {"isEmpty": {"ref": "@key"}}]}, {"coll": {"foo": 0, "bar": 1, "": 2}}, True),
+        ({"any": [{"ref": "coll"}, {"isEmpty": {"ref": "@key"}}]}, {"coll": {"foo": 0, "bar": 1, "baz": 2}}, False),
         ({"startsWith": [{"ref": "local_string"}, "hello"]}, {"local_string": "hello world!"}, True),
         ({"startsWith": [{"ref": "local_string"}, "world"]}, {"local_string": "hello world!"}, False),
         (
@@ -91,6 +95,16 @@ def __getitem__(self, name):
             {"collection": {"foo", "bar", ""}},
             {"foo", "bar"},
         ),
+        (
+            {"filter": [{"ref": "collection"}, {"not": {"isEmpty": {"ref": "@value"}}}]},
+            {"collection": {1: "foo", 2: "bar", 3: ""}},
+            {1: "foo", 2: "bar"},
+        ),
+        (
+            {"filter": [{"ref": "collection"}, {"not": {"isEmpty": {"ref": "@key"}}}]},
+            {"collection": {"foo": 1, "bar": 2, "": 3}},
+            {"foo": 1, "bar": 2},
+        ),
         ({"contains": [{"ref": "payload"}, "hello"]}, {"payload": CustomObject("contains")}, SideEffect),
         (
             {"contains": [{"ref": "payload"}, "hello"]},