use helper for code path resolution

Author: P403n1x87

ddtrace/debugging/_function/discovery.py

@@ -1,6 +1,5 @@
 from collections import defaultdict
 from collections import deque
-from pathlib import Path
 from types import CodeType
 from types import FunctionType
 from types import ModuleType
@@ -24,6 +23,7 @@
 from ddtrace.internal.utils.inspection import collect_code_objects
 from ddtrace.internal.utils.inspection import functions_for_code
 from ddtrace.internal.utils.inspection import linenos
+from ddtrace.internal.utils.inspection import resolved_code_origin
 from ddtrace.internal.utils.inspection import undecorated
 
 
@@ -209,7 +209,7 @@ def _collect_functions(module: ModuleType) -> Dict[str, _FunctionCodePair]:
 
                 for name in (k, local_name) if isinstance(k, str) and k != local_name else (local_name,):
                     fullname = ".".join((c.__fullname__, name)) if c.__fullname__ else name
-                    if fullname not in functions or Path(code.co_filename).resolve() == path:
+                    if fullname not in functions or resolved_code_origin(code) == path:
                         # Give precedence to code objects from the module and
                         # try to retrieve any potentially decorated function so
                         # that we don't end up returning the decorator function
@@ -285,7 +285,7 @@ def __init__(self, module: ModuleType) -> None:
 
                 if (
                     function not in seen_functions
-                    and Path(cast(FunctionType, function).__code__.co_filename).resolve() == module_path
+                    and resolved_code_origin(cast(FunctionType, function).__code__) == module_path
                 ):
                     # We only map line numbers for functions that actually belong to
                     # the module.
@@ -342,7 +342,7 @@ def _resolve_pair(self, pair: _FunctionCodePair, fullname: str) -> FullyNamedFun
 
             code = pair.code
             assert code is not None  # nosec
-            f = undecorated(cast(FunctionType, target), cast(str, part), Path(code.co_filename).resolve())
+            f = undecorated(cast(FunctionType, target), cast(str, part), resolved_code_origin(code))
             if not (isinstance(f, FunctionType) and f.__code__ is code):
                 raise e
 

ddtrace/debugging/_origin/span.py

@@ -102,7 +102,7 @@ def from_frame(cls, frame: FrameType) -> "ExitSpanProbe":
             ExitSpanProbe,
             cls.build(
                 name=code.co_qualname if sys.version_info >= (3, 11) else code.co_name,  # type: ignore[attr-defined]
-                filename=str(Path(code.co_filename).resolve()),
+                filename=str(Path(code.co_filename)),
                 line=frame.f_lineno,
             ),
         )

ddtrace/internal/coverage/code.py

@@ -20,6 +20,7 @@
 from ddtrace.internal.packages import purelib_path
 from ddtrace.internal.packages import stdlib_path
 from ddtrace.internal.test_visibility.coverage_lines import CoverageLines
+from ddtrace.internal.utils.inspection import resolved_code_origin
 
 
 log = get_logger(__name__)
@@ -317,7 +318,7 @@ def transform(self, code: CodeType, _module: ModuleType) -> CodeType:
         if _module is None:
             return code
 
-        code_path = Path(code.co_filename).resolve()
+        code_path = resolved_code_origin(code)
 
         if not any(code_path.is_relative_to(include_path) for include_path in self._include_paths):
             # Not a code object we want to instrument

ddtrace/internal/symbol_db/symbols.py

@@ -38,6 +38,7 @@
 from ddtrace.internal.utils.http import connector
 from ddtrace.internal.utils.http import multipart
 from ddtrace.internal.utils.inspection import linenos
+from ddtrace.internal.utils.inspection import resolved_code_origin
 from ddtrace.internal.utils.inspection import undecorated
 from ddtrace.settings._agent import config as agent_config
 from ddtrace.settings.symbol_db import config as symdb_config
@@ -323,7 +324,7 @@ def _(cls, code: CodeType, data: ScopeData, recursive: bool = True):
             return None
         data.seen.add(code_id)
 
-        if Path(code.co_filename).resolve() != data.origin:
+        if (code_origin := resolved_code_origin(code)) != data.origin:
             # Comes from another module.
             return None
 
@@ -337,7 +338,7 @@ def _(cls, code: CodeType, data: ScopeData, recursive: bool = True):
         return Scope(
             scope_type=ScopeType.CLOSURE,  # DEV: Not in the sense of a Python closure.
             name=code.co_name,
-            source_file=str(Path(code.co_filename).resolve()),
+            source_file=str(code_origin),
             start_line=start_line,
             end_line=end_line,
             symbols=Symbol.from_code(code),

ddtrace/internal/utils/inspection.py

@@ -13,6 +13,7 @@
 from typing import cast
 
 from ddtrace.internal.safety import _isinstance
+from ddtrace.internal.utils.cache import cached
 
 
 @singledispatch
@@ -31,14 +32,23 @@ def _(f: FunctionType) -> Set[int]:
     return linenos(f.__code__)
 
 
+@cached(maxsize=4 << 10)
+def _filename_to_resolved_path(filename: str) -> Path:
+    return Path(filename).resolve()
+
+
+def resolved_code_origin(code: CodeType) -> Path:
+    return _filename_to_resolved_path(code.co_filename)
+
+
 def undecorated(f: FunctionType, name: str, path: Path) -> FunctionType:
     # Find the original function object from a decorated function. We use the
     # expected function name to guide the search and pick the correct function.
     # The recursion is needed in case of multiple decorators. We make it BFS
     # to find the function as soon as possible.
 
     def match(g):
-        return g.__code__.co_name == name and Path(g.__code__.co_filename).resolve() == path
+        return g.__code__.co_name == name and resolved_code_origin(g.__code__) == path
 
     if _isinstance(f, FunctionType) and match(f):
         return f