Support serializable toolbar

.gitignore

@@ -12,6 +12,7 @@ htmlcov
 .tox
 geckodriver.log
 coverage.xml
+venv
 .direnv/
 .envrc
 venv

Makefile

@@ -7,6 +7,12 @@ example:  ## Run the example application
 		--noinput --username="$(USER)" --email="$(USER)@mailinator.com"
 	python example/manage.py runserver
 
+example_async:
+	python example/manage.py migrate --noinput
+	-DJANGO_SUPERUSER_PASSWORD=p python example/manage.py createsuperuser \
+		--noinput --username="$(USER)" --email="$(USER)@mailinator.com"
+	daphne example.asgi:application
+
 example_test:  ## Run the test suite for the example application
 	python example/manage.py test example
 

debug_toolbar/migrations/0001_initial.py

@@ -0,0 +1,24 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    operations = [
+        migrations.CreateModel(
+            name="HistoryEntry",
+            fields=[
+                (
+                    "request_id",
+                    models.UUIDField(primary_key=True, serialize=False),
+                ),
+                ("data", models.JSONField(default=dict)),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+            ],
+            options={
+                "verbose_name": "history entry",
+                "verbose_name_plural": "history entries",
+                "ordering": ["-created_at"],
+            },
+        ),
+    ]

debug_toolbar/models.py

@@ -0,0 +1,16 @@
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+
+class HistoryEntry(models.Model):
+    request_id = models.UUIDField(primary_key=True)
+    data = models.JSONField(default=dict)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        verbose_name = _("history entry")
+        verbose_name_plural = _("history entries")
+        ordering = ["-created_at"]
+
+    def __str__(self):
+        return str(self.request_id)

debug_toolbar/panels/__init__.py

@@ -1,5 +1,6 @@
 from django.core.handlers.asgi import ASGIRequest
 from django.template.loader import render_to_string
+from django.utils.functional import classproperty
 
 from debug_toolbar import settings as dt_settings
 from debug_toolbar.utils import get_name_from_obj
@@ -15,19 +16,27 @@ class Panel:
     def __init__(self, toolbar, get_response):
         self.toolbar = toolbar
         self.get_response = get_response
+        self.from_store = False
 
     # Private panel properties
 
-    @property
-    def panel_id(self):
-        return self.__class__.__name__
+    @classproperty
+    def panel_id(cls):
+        return cls.__name__
 
     @property
     def enabled(self) -> bool:
-        # check if the panel is async compatible
+        # Check if the panel is async compatible
         if not self.is_async and isinstance(self.toolbar.request, ASGIRequest):
             return False
 
+        if self.from_store:
+            # If the toolbar was loaded from the store the existence of
+            # recorded data indicates whether it was enabled or not.
+            # We can't use the remainder of the logic since we don't have
+            # a request to work off of.
+            return bool(self.get_stats())
+
         # The user's cookies should override the default value
         cookie_value = self.toolbar.request.COOKIES.get("djdt" + self.panel_id)
         if cookie_value is not None:
@@ -175,9 +184,16 @@ def record_stats(self, stats):
         """
         Store data gathered by the panel. ``stats`` is a :class:`dict`.
 
-        Each call to ``record_stats`` updates the statistics dictionary.
+        Each call to ``record_stats`` updates the store's data for
+        the panel.
+
+        To support backwards compatibility, it will also update the
+        panel's statistics dictionary.
         """
         self.toolbar.stats.setdefault(self.panel_id, {}).update(stats)
+        self.toolbar.store.save_panel(
+            self.toolbar.request_id, self.panel_id, self.toolbar.stats[self.panel_id]
+        )
 
     def get_stats(self):
         """
@@ -261,6 +277,15 @@ def generate_server_timing(self, request, response):
         Does not return a value.
         """
 
+    def load_stats_from_store(self, data):
+        """
+        Instantiate the panel from serialized data.
+
+        Return the panel instance.
+        """
+        self.toolbar.stats.setdefault(self.panel_id, {}).update(data)
+        self.from_store = True
+
     @classmethod
     def run_checks(cls):
         """

debug_toolbar/panels/alerts.py

@@ -141,11 +141,9 @@ def check_invalid_file_form_configuration(self, html_content):
         return self.alerts
 
     def generate_stats(self, request, response):
-        if not is_processable_html_response(response):
-            return
-
-        html_content = response.content.decode(response.charset)
-        self.check_invalid_file_form_configuration(html_content)
+        if is_processable_html_response(response):
+            html_content = response.content.decode(response.charset)
+            self.check_invalid_file_form_configuration(html_content)
 
         # Further alert checks can go here
 

debug_toolbar/panels/cache.py

@@ -171,16 +171,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",
@@ -216,6 +217,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/__init__.py

@@ -1,3 +1,3 @@
 from debug_toolbar.panels.history.panel import HistoryPanel
 
-__all__ = ["HistoryPanel"]
+__all__ = [HistoryPanel.panel_id]

debug_toolbar/panels/history/forms.py

@@ -5,8 +5,8 @@ class HistoryStoreForm(forms.Form):
     """
     Validate params
 
-        store_id: The key for the store instance to be fetched.
+        request_id: The key for the store instance to be fetched.
     """
 
-    store_id = forms.CharField(widget=forms.HiddenInput())
+    request_id = forms.CharField(widget=forms.HiddenInput())
     exclude_history = forms.BooleanField(widget=forms.HiddenInput(), required=False)

debug_toolbar/panels/history/panel.py

@@ -24,9 +24,9 @@ class HistoryPanel(Panel):
     def get_headers(self, request):
         headers = super().get_headers(request)
         observe_request = self.toolbar.get_observe_request()
-        store_id = self.toolbar.store_id
-        if store_id and observe_request(request):
-            headers["djdt-store-id"] = store_id
+        request_id = self.toolbar.request_id
+        if request_id and observe_request(request):
+            headers["djdt-request-id"] = request_id
         return headers
 
     @property
@@ -87,23 +87,25 @@ def content(self):
 
         Fetch every store for the toolbar and include it in the template.
         """
-        stores = {}
-        for id, toolbar in reversed(self.toolbar._store.items()):
-            stores[id] = {
-                "toolbar": toolbar,
+        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={"store_id": id, "exclude_history": True}
+                    initial={"request_id": request_id, "exclude_history": True}
                 ),
             }
 
         return render_to_string(
             self.template,
             {
-                "current_store_id": self.toolbar.store_id,
-                "stores": stores,
+                "current_request_id": self.toolbar.request_id,
+                "toolbar_history": toolbar_history,
                 "refresh_form": HistoryStoreForm(
                     initial={
-                        "store_id": self.toolbar.store_id,
+                        "request_id": self.toolbar.request_id,
                         "exclude_history": True,
                     }
                 ),

debug_toolbar/panels/history/views.py

@@ -4,6 +4,7 @@
 from debug_toolbar._compat import login_not_required
 from debug_toolbar.decorators import render_with_toolbar_language, require_show_toolbar
 from debug_toolbar.panels.history.forms import HistoryStoreForm
+from debug_toolbar.store import get_store
 from debug_toolbar.toolbar import DebugToolbar
 
 
@@ -15,12 +16,12 @@ def history_sidebar(request):
     form = HistoryStoreForm(request.GET)
 
     if form.is_valid():
-        store_id = form.cleaned_data["store_id"]
-        toolbar = DebugToolbar.fetch(store_id)
+        request_id = form.cleaned_data["request_id"]
+        toolbar = DebugToolbar.fetch(request_id)
         exclude_history = form.cleaned_data["exclude_history"]
         context = {}
         if toolbar is None:
-            # When the store_id has been popped already due to
+            # When the request_id has been popped already due to
             # RESULTS_CACHE_SIZE
             return JsonResponse(context)
         for panel in toolbar.panels:
@@ -36,7 +37,7 @@ def history_sidebar(request):
                 ),
             }
         return JsonResponse(context)
-    return HttpResponseBadRequest("Form errors")
+    return HttpResponseBadRequest(f"Form errors: {form.errors}")
 
 
 @login_not_required
@@ -49,19 +50,22 @@ def history_refresh(request):
     if form.is_valid():
         requests = []
         # Convert to list to handle mutations happening in parallel
-        for id, toolbar in list(DebugToolbar._store.items()):
+        for request_id in get_store().request_ids():
+            toolbar = DebugToolbar.fetch(request_id)
             requests.append(
                 {
-                    "id": id,
+                    "id": request_id,
                     "content": render_to_string(
                         "debug_toolbar/panels/history_tr.html",
                         {
-                            "id": id,
-                            "store_context": {
-                                "toolbar": toolbar,
+                            "request_id": request_id,
+                            "history_context": {
+                                "history_stats": toolbar.store.panel(
+                                    request_id, "HistoryPanel"
+                                ),
                                 "form": HistoryStoreForm(
                                     initial={
-                                        "store_id": id,
+                                        "request_id": request_id,
                                         "exclude_history": True,
                                     }
                                 ),

debug_toolbar/panels/profiling.py

@@ -25,6 +25,7 @@ def __init__(
         self.id = id
         self.parent_ids = parent_ids or []
         self.hsv = hsv
+        self.has_subfuncs = False
 
     def parent_classes(self):
         return self.parent_classes
@@ -130,6 +131,21 @@ def cumtime_per_call(self):
     def indent(self):
         return 16 * self.depth
 
+    def serialize(self):
+        return {
+            "has_subfuncs": self.has_subfuncs,
+            "id": self.id,
+            "parent_ids": self.parent_ids,
+            "is_project_func": self.is_project_func(),
+            "indent": self.indent(),
+            "func_std_string": self.func_std_string(),
+            "cumtime": self.cumtime(),
+            "cumtime_per_call": self.cumtime_per_call(),
+            "tottime": self.tottime(),
+            "tottime_per_call": self.tottime_per_call(),
+            "count": self.count(),
+        }
+
 
 class ProfilingPanel(Panel):
     """
@@ -148,7 +164,6 @@ def process_request(self, request):
 
     def add_node(self, func_list, func, max_depth, cum_time):
         func_list.append(func)
-        func.has_subfuncs = False
         if func.depth < max_depth:
             for subfunc in func.subfuncs():
                 # Always include the user's code
@@ -182,4 +197,4 @@ def generate_stats(self, request, response):
                 dt_settings.get_config()["PROFILER_MAX_DEPTH"],
                 cum_time_threshold,
             )
-            self.record_stats({"func_list": func_list})
+            self.record_stats({"func_list": [func.serialize() for func in func_list]})

debug_toolbar/panels/settings.py

@@ -1,4 +1,4 @@
-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
 
@@ -19,7 +19,16 @@ 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({"settings": dict(sorted(get_safe_settings().items()))})
+        self.record_stats(
+            {
+                "settings": {
+                    key: force_str(value)
+                    for key, value in sorted(get_safe_settings().items())
+                }
+            }
+        )

debug_toolbar/panels/sql/__init__.py

@@ -1,3 +1,3 @@
 from debug_toolbar.panels.sql.panel import SQLPanel
 
-__all__ = ["SQLPanel"]
+__all__ = [SQLPanel.panel_id]