Add new stack trace functionality

* Add a private _StackTraceRecorder class to debug_toolbar.utils which
  implements caching to reduce the overhead of expensive file system
  operations.  This class has a get_stack_trace() method which combines
  the functionality of the get_stack() and tidy_stacktrace() functions.
* Add a new debug_toolbar.utils function, get_stack_trace() which gets
  or instantiates a thread/async task context-local _StackTraceRecorder
  instance and returns a stack trace using its get_stack_trace() method.
* Add a new debug_toolbar.utils function, clear_stack_trace_caches(),
  which removes any thread/async task context-local _StackTraceRecorder
  instance.
* Update the DebugToolbarMiddleware to call the
  clear_stack_trace_caches() function after processing a request to
  ensure that each subsequent request gets a clean cache.

Author: living180

debug_toolbar/middleware.py

@@ -10,6 +10,7 @@
 
 from debug_toolbar import settings as dt_settings
 from debug_toolbar.toolbar import DebugToolbar
+from debug_toolbar.utils import clear_stack_trace_caches
 
 _HTML_TYPES = ("text/html", "application/xhtml+xml")
 
@@ -56,6 +57,7 @@ def __call__(self, request):
             # Run panels like Django middleware.
             response = toolbar.process_request(request)
         finally:
+            clear_stack_trace_caches()
             # Deactivate instrumentation ie. monkey-unpatch. This must run
             # regardless of the response. Keep 'return' clauses below.
             for panel in reversed(toolbar.enabled_panels):

debug_toolbar/utils.py

@@ -1,10 +1,12 @@
 import inspect
+import linecache
 import os.path
 import sys
 from importlib import import_module
 from pprint import pformat
 
 import django
+from asgiref.local import Local
 from django.core.exceptions import ImproperlyConfigured
 from django.template import Node
 from django.utils.html import format_html
@@ -18,6 +20,9 @@
     threading = None
 
 
+_local_data = Local()
+
+
 # Figure out some paths
 django_path = os.path.realpath(os.path.dirname(django.__file__))
 
@@ -242,6 +247,99 @@ def get_stack(context=1):
     return framelist
 
 
+def _stack_frames(depth=1):
+    frame = inspect.currentframe()
+    while frame is not None:
+        if depth > 0:
+            depth -= 1
+        else:
+            yield frame
+        frame = frame.f_back
+
+
+class _StackTraceRecorder:
+    def __init__(self, excluded_paths):
+        self.excluded_paths = excluded_paths
+        self.filename_cache = {}
+        self.is_excluded_cache = {}
+
+    def get_source_file(self, frame):
+        frame_filename = frame.f_code.co_filename
+
+        value = self.filename_cache.get(frame_filename)
+        if value is None:
+            filename = inspect.getsourcefile(frame)
+            if filename is None:
+                is_source = False
+                filename = frame_filename
+            else:
+                is_source = True
+                # Ensure linecache validity the first time this recorder
+                # encounters the filename in this frame.
+                linecache.checkcache(filename)
+            value = (filename, is_source)
+            self.filename_cache[frame_filename] = value
+
+        return value
+
+    def is_excluded_path(self, path):
+        excluded = self.is_excluded_cache.get(path)
+        if excluded is None:
+            resolved_path = os.path.realpath(path)
+            excluded = any(
+                resolved_path.startswith(excluded_path)
+                for excluded_path in self.excluded_paths
+            )
+            self.is_excluded_cache[path] = excluded
+        return excluded
+
+    def get_stack_trace(self, include_locals=False, depth=1):
+        trace = []
+        for frame in _stack_frames(depth=depth + 1):
+            filename, is_source = self.get_source_file(frame)
+
+            if self.is_excluded_path(filename):
+                continue
+
+            line_no = frame.f_lineno
+            func_name = frame.f_code.co_name
+
+            if is_source:
+                module = inspect.getmodule(frame, filename)
+                module_globals = module.__dict__ if module is not None else None
+                source_line = linecache.getline(
+                    filename, line_no, module_globals
+                ).strip()
+            else:
+                source_line = ""
+
+            frame_locals = frame.f_locals if include_locals else None
+
+            trace.append((filename, line_no, func_name, source_line, frame_locals))
+        trace.reverse()
+        return trace
+
+
+def get_stack_trace(depth=1):
+    config = dt_settings.get_config()
+    if config["ENABLE_STACKTRACES"]:
+        stack_trace_recorder = getattr(_local_data, "stack_trace_recorder", None)
+        if stack_trace_recorder is None:
+            stack_trace_recorder = _StackTraceRecorder(hidden_paths)
+            _local_data.stack_trace_recorder = stack_trace_recorder
+        return stack_trace_recorder.get_stack_trace(
+            include_locals=config["ENABLE_STACKTRACES_LOCALS"],
+            depth=depth,
+        )
+    else:
+        return []
+
+
+def clear_stack_trace_caches():
+    if hasattr(_local_data, "stack_trace_recorder"):
+        del _local_data.stack_trace_recorder
+
+
 class ThreadCollector:
     def __init__(self):
         if threading is None: