fix(di): dynamic function discovery fallback

We implement a dynamic function discovery fallback when the
function-from-code resolution via the GC fails. This can happen if the
target application has interacted with the GC, e.g. by freezing it at a
time that will prevent the current discovery from being able to resolve
the function from the referenced code object.

Author: P403n1x87

ddtrace/debugging/_function/discovery.py

@@ -326,11 +326,42 @@ def at_line(self, line: int) -> List[FullyNamedFunction]:
 
         return []
 
+    def _resolve_pair(self, pair: _FunctionCodePair, fullname: str) -> FullyNamedFunction:
+        try:
+            return pair.resolve()
+        except ValueError:
+            # We failed to lookup the function by its code object via the GC.
+            # This should not happen, unless the target application is doing
+            # something unusual with the GC. In this case we try our best to
+            # look up the function dynamically from the module. If the function
+            # is decorated, there are chances this might fail.
+            target = (module := self._module)
+            part = None
+            for part in fullname.replace(f"{module.__name__}.", "", 1).split("."):
+                try:
+                    target = getattr(target, part)
+                except AttributeError:
+                    raise
+
+            if target is module:
+                # We didn't move from the module so we don't have a function.
+                raise
+
+            assert (code := pair.code) is not None
+            f = undecorated(cast(FunctionType, target), cast(str, part), Path(code.co_filename).resolve())
+            if not isinstance(target, FunctionType) and target.__code__ is not code:
+                raise
+
+            # Cache the lookup result
+            pair.function = f
+
+            return cast(FullyNamedFunction, f)
+
     def by_name(self, qualname: str) -> FullyNamedFunction:
         """Get the function by its qualified name."""
         fullname = f"{self._module.__name__}.{qualname}"
         try:
-            return self._fullname_index[fullname].resolve()
+            return self._resolve_pair(self._fullname_index[fullname], fullname)
         except ValueError:
             pass
         except KeyError:
@@ -342,11 +373,11 @@ def by_name(self, qualname: str) -> FullyNamedFunction:
                     if qualname == name or qualname.endswith(f".{name}"):
                         for fcp in list(fcps):
                             try:
-                                f = fcp.resolve()
+                                f = self._resolve_pair(fcp, fullname)
 
                                 # We have resolved the function so we can now
                                 # get its full name
-                                self._fullname_index[f"{self._module.__name__}.{f.__qualname__}"] = fcp
+                                self._fullname_index[fullname] = fcp
 
                                 # We can remove the entry from the name index
                                 fcps.pop(0)

releasenotes/notes/fix-di-dynamic-discovery-fallback-3a5623e18584cd79.yaml

@@ -0,0 +1,6 @@
+---
+fixes:
+  - |
+    dynamic instrumentation: improve support for function probes with frameworks
+    and applications that interact with the Python garbage collector (e.g.
+    synapse).