Update all panels to use data from get_stats on render

Any instance attributes shouldn't be used because they can't be
relied upon for historical purposes. Especially when it comes to
the titles and nav titles.

Author: tim-schilling

debug_toolbar/panels/cache.py

@@ -169,16 +169,17 @@ def _record_call(self, cache, name, original_method, args, kwargs):
 
     @property
     def nav_subtitle(self):
-        cache_calls = len(self.calls)
+        stats = self.get_stats()
+        cache_calls = len(stats.get("calls"))
         return ngettext(
             "%(cache_calls)d call in %(time).2fms",
             "%(cache_calls)d calls in %(time).2fms",
             cache_calls,
-        ) % {"cache_calls": cache_calls, "time": self.total_time}
+        ) % {"cache_calls": cache_calls, "time": stats.get("total_time")}
 
     @property
     def title(self):
-        count = len(getattr(settings, "CACHES", ["default"]))
+        count = self.get_stats().get("total_caches")
         return ngettext(
             "Cache calls from %(count)d backend",
             "Cache calls from %(count)d backends",
@@ -214,6 +215,7 @@ def generate_stats(self, request, response):
                 "hits": self.hits,
                 "misses": self.misses,
                 "counts": self.counts,
+                "total_caches": len(getattr(settings, "CACHES", ["default"])),
             }
         )
 

debug_toolbar/panels/history/panel.py

@@ -89,6 +89,9 @@ def content(self):
         toolbar_history = {}
         for request_id in reversed(self.toolbar.store.request_ids()):
             toolbar_history[request_id] = {
+                "history_stats": self.toolbar.store.panel(
+                    request_id, HistoryPanel.panel_id
+                ),
                 "form": HistoryStoreForm(
                     initial={"request_id": request_id, "exclude_history": True}
                 ),

debug_toolbar/panels/history/views.py

@@ -55,16 +55,18 @@ def history_refresh(request):
                     "content": render_to_string(
                         "debug_toolbar/panels/history_tr.html",
                         {
-                            "id": request_id,
-                            "store_context": {
-                                "toolbar": toolbar,
-                                "form": HistoryStoreForm(
-                                    initial={
-                                        "request_id": request_id,
-                                        "exclude_history": True,
-                                    }
-                                ),
+                            "request_id": request_id,
+                            "history_context": {
+                                "history_stats": toolbar.store.panel(
+                                    request_id, "HistoryPanel"
+                                )
                             },
+                            "form": HistoryStoreForm(
+                                initial={
+                                    "request_id": request_id,
+                                    "exclude_history": True,
+                                }
+                            ),
                         },
                     ),
                 }

debug_toolbar/panels/settings.py

@@ -1,4 +1,3 @@
-from django.conf import settings
 from django.utils.encoding import force_str
 from django.utils.translation import gettext_lazy as _
 from django.views.debug import get_default_exception_reporter_filter
@@ -18,7 +17,9 @@ class SettingsPanel(Panel):
     nav_title = _("Settings")
 
     def title(self):
-        return _("Settings from %s") % settings.SETTINGS_MODULE
+        return _("Settings from %s") % self.get_stats()["settings"].get(
+            "SETTINGS_MODULE"
+        )
 
     def generate_stats(self, request, response):
         self.record_stats(

debug_toolbar/panels/sql/panel.py

@@ -159,19 +159,20 @@ def record(self, **kwargs):
 
     @property
     def nav_subtitle(self):
-        query_count = len(self._queries)
+        stats = self.get_stats()
+        query_count = len(stats.get("queries", []))
         return ngettext(
             "%(query_count)d query in %(sql_time).2fms",
             "%(query_count)d queries in %(sql_time).2fms",
             query_count,
         ) % {
             "query_count": query_count,
-            "sql_time": self._sql_time,
+            "sql_time": stats.get("sql_time"),
         }
 
     @property
     def title(self):
-        count = len(self._databases)
+        count = len(self.get_stats().get("databases"))
         return ngettext(
             "SQL queries from %(count)d connection",
             "SQL queries from %(count)d connections",

debug_toolbar/panels/staticfiles.py

@@ -79,9 +79,10 @@ class StaticFilesPanel(panels.Panel):
 
     @property
     def title(self):
+        stats = self.get_stats()
         return _("Static files (%(num_found)s found, %(num_used)s used)") % {
-            "num_found": self.num_found,
-            "num_used": self.num_used,
+            "num_found": stats.get("num_found"),
+            "num_used": stats.get("num_used"),
         }
 
     def __init__(self, *args, **kwargs):
@@ -95,16 +96,11 @@ def enable_instrumentation(self):
     def disable_instrumentation(self):
         storage.staticfiles_storage = _original_storage
 
-    @property
-    def num_used(self):
-        stats = self.get_stats()
-        return stats and stats["num_used"]
-
     nav_title = _("Static files")
 
     @property
     def nav_subtitle(self):
-        num_used = self.num_used
+        num_used = self.get_stats().get("num_used")
         return ngettext(
             "%(num_used)s file used", "%(num_used)s files used", num_used
         ) % {"num_used": num_used}

debug_toolbar/panels/templates/panel.py

@@ -145,15 +145,16 @@ def _store_template_info(self, sender, **kwargs):
 
     @property
     def title(self):
-        num_templates = len(self.templates)
+        num_templates = len(self.get_stats()["templates"])
         return _("Templates (%(num_templates)s rendered)") % {
             "num_templates": num_templates
         }
 
     @property
     def nav_subtitle(self):
-        if self.templates:
-            return self.templates[0]["template"].name
+        templates = self.get_stats()["templates"]
+        if templates:
+            return templates[0]["name"]
         return ""
 
     template = "debug_toolbar/panels/templates.html"
@@ -171,7 +172,6 @@ def disable_instrumentation(self):
     def generate_stats(self, request, response):
         template_context = []
         for template_data in self.templates:
-            info = {}
             # Clean up some info about templates
             template = template_data["template"]
             if hasattr(template, "origin") and template.origin and template.origin.name:
@@ -180,12 +180,15 @@ def generate_stats(self, request, response):
             else:
                 template.origin_name = _("No origin")
                 template.origin_hash = ""
-            info["template"] = force_str(template)
+            context = {
+                "template": force_str(template),
+                "name": template.name,
+            }
             # Clean up context for better readability
             if self.toolbar.config["SHOW_TEMPLATE_CONTEXT"]:
                 context_list = template_data.get("context", [])
-                info["context"] = "\n".join(context_list)
-            template_context.append(info)
+                context["context"] = "\n".join(context_list)
+            template_context.append(context)
 
         # Fetch context_processors/template_dirs from any template
         if self.templates:

debug_toolbar/panels/timer.py

@@ -19,11 +19,11 @@ class TimerPanel(Panel):
 
     def nav_subtitle(self):
         stats = self.get_stats()
-        if hasattr(self, "_start_rusage"):
-            utime = self._end_rusage.ru_utime - self._start_rusage.ru_utime
-            stime = self._end_rusage.ru_stime - self._start_rusage.ru_stime
+        if stats.get("utime"):
+            utime = stats.get("utime")
+            stime = stats.get("stime")
             return _("CPU: %(cum)0.2fms (%(total)0.2fms)") % {
-                "cum": (utime + stime) * 1000.0,
+                "cum": (utime + stime),
                 "total": stats["total_time"],
             }
         elif "total_time" in stats:
@@ -64,27 +64,44 @@ def process_request(self, request):
             self._start_rusage = resource.getrusage(resource.RUSAGE_SELF)
         return super().process_request(request)
 
+    def serialize_rusage(self, data):
+        fields_to_serialize = [
+            "ru_utime",
+            "ru_stime",
+            "ru_nvcsw",
+            "ru_nivcsw",
+            "ru_minflt",
+            "ru_majflt",
+        ]
+        return {field: getattr(data, field) for field in fields_to_serialize}
+
     def generate_stats(self, request, response):
         stats = {}
         if hasattr(self, "_start_time"):
             stats["total_time"] = (perf_counter() - self._start_time) * 1000
-        if hasattr(self, "_start_rusage"):
+        if self.has_content:
             self._end_rusage = resource.getrusage(resource.RUSAGE_SELF)
-            stats["utime"] = 1000 * self._elapsed_ru("ru_utime")
-            stats["stime"] = 1000 * self._elapsed_ru("ru_stime")
+            start = self.serialize_rusage(self._start_rusage)
+            end = self.serialize_rusage(self._end_rusage)
+            stats.update(
+                {
+                    "utime": 1000 * self._elapsed_ru(start, end, "ru_utime"),
+                    "stime": 1000 * self._elapsed_ru(start, end, "ru_stime"),
+                    "vcsw": self._elapsed_ru(start, end, "ru_nvcsw"),
+                    "ivcsw": self._elapsed_ru(start, end, "ru_nivcsw"),
+                    "minflt": self._elapsed_ru(start, end, "ru_minflt"),
+                    "majflt": self._elapsed_ru(start, end, "ru_majflt"),
+                }
+            )
             stats["total"] = stats["utime"] + stats["stime"]
-            stats["vcsw"] = self._elapsed_ru("ru_nvcsw")
-            stats["ivcsw"] = self._elapsed_ru("ru_nivcsw")
-            stats["minflt"] = self._elapsed_ru("ru_minflt")
-            stats["majflt"] = self._elapsed_ru("ru_majflt")
             # these are documented as not meaningful under Linux.  If you're
             # running BSD feel free to enable them, and add any others that I
             # hadn't gotten to before I noticed that I was getting nothing but
             # zeroes and that the docs agreed. :-(
             #
-            #        stats['blkin'] = self._elapsed_ru('ru_inblock')
-            #        stats['blkout'] = self._elapsed_ru('ru_oublock')
-            #        stats['swap'] = self._elapsed_ru('ru_nswap')
+            #        stats['blkin'] = self._elapsed_ru(start, end, 'ru_inblock')
+            #        stats['blkout'] = self._elapsed_ru(start, end, 'ru_oublock')
+            #        stats['swap'] = self._elapsed_ru(start, end, 'ru_nswap')
             #        stats['rss'] = self._end_rusage.ru_maxrss
             #        stats['srss'] = self._end_rusage.ru_ixrss
             #        stats['urss'] = self._end_rusage.ru_idrss
@@ -102,5 +119,6 @@ def generate_server_timing(self, request, response):
             "total_time", "Elapsed time", stats.get("total_time", 0)
         )
 
-    def _elapsed_ru(self, name):
-        return getattr(self._end_rusage, name) - getattr(self._start_rusage, name)
+    @staticmethod
+    def _elapsed_ru(start, end, name):
+        return end.get(name) - start.get(name)

debug_toolbar/panels/versions.py

@@ -14,7 +14,7 @@ class VersionsPanel(Panel):
 
     @property
     def nav_subtitle(self):
-        return "Django %s" % django.get_version()
+        return "Django %s" % self.get_stats()["django_version"]
 
     title = _("Versions")
 
@@ -27,7 +27,11 @@ def generate_stats(self, request, response):
         ]
         versions += list(self.gen_app_versions())
         self.record_stats(
-            {"versions": sorted(versions, key=lambda v: v[0]), "paths": sys.path}
+            {
+                "django_version": django.get_version(),
+                "versions": sorted(versions, key=lambda v: v[0]),
+                "paths": sys.path,
+            }
         )
 
     def gen_app_versions(self):

debug_toolbar/store.py

@@ -128,6 +128,16 @@ def panel(cls, request_id: str, panel_id: str) -> Any:
         else:
             return deserialize(data)
 
+    @classmethod
+    def panels(cls, request_id: str) -> Any:
+        """Fetch all the panel data for the given request_id"""
+        try:
+            panel_mapping = cls._request_store[request_id]
+        except KeyError:
+            return {}
+        for panel, data in panel_mapping.items():
+            yield panel, deserialize(data)
+
 
 def get_store() -> BaseStore:
     return import_string(dt_settings.get_config()["TOOLBAR_STORE_CLASS"])