Restructure the Panel class to execute more like the MIDDLEWARE

This allows the ProfilingPanel to no longer skip remaining panels or
middlewares.

This change is backwards incompatible. Third party panels will need to
adjust to use this new architecture. It removes support for Django
1.11's deprecated MIDDLEWARE_CLASSES setting.

The Panel.__init__() method is now passed a get_response argument. The
Panel.process_request() method must now always return a response.
Usually this is the response returned by get_response() but may also
return a different response as is the case in the ``RedirectsPanel``.

Panel.process_response() and Panel.process_view() have been removed.

Fixes #1135

Author: jdufresne

debug_toolbar/apps.py

@@ -23,14 +23,8 @@ def check_middleware(app_configs, **kwargs):
     gzip_index = None
     debug_toolbar_indexes = []
 
-    setting = getattr(settings, "MIDDLEWARE", None)
-    setting_name = "MIDDLEWARE"
-    if setting is None:
-        setting = settings.MIDDLEWARE_CLASSES
-        setting_name = "MIDDLEWARE_CLASSES"
-
     # Determine the indexes which gzip and/or the toolbar are installed at
-    for i, middleware in enumerate(setting):
+    for i, middleware in enumerate(settings.MIDDLEWARE):
         if is_middleware_class(GZipMiddleware, middleware):
             gzip_index = i
         elif is_middleware_class(DebugToolbarMiddleware, middleware):
@@ -41,9 +35,9 @@ def check_middleware(app_configs, **kwargs):
         errors.append(
             Warning(
                 "debug_toolbar.middleware.DebugToolbarMiddleware is missing "
-                "from %s." % setting_name,
+                "from MIDDLEWARE.",
                 hint="Add debug_toolbar.middleware.DebugToolbarMiddleware to "
-                "%s." % setting_name,
+                "MIDDLEWARE.",
                 id="debug_toolbar.W001",
             )
         )
@@ -52,9 +46,9 @@ def check_middleware(app_configs, **kwargs):
         errors.append(
             Warning(
                 "debug_toolbar.middleware.DebugToolbarMiddleware occurs "
-                "multiple times in %s." % setting_name,
+                "multiple times in MIDDLEWARE.",
                 hint="Load debug_toolbar.middleware.DebugToolbarMiddleware only "
-                "once in %s." % setting_name,
+                "once in MIDDLEWARE.",
                 id="debug_toolbar.W002",
             )
         )
@@ -63,9 +57,9 @@ def check_middleware(app_configs, **kwargs):
         errors.append(
             Warning(
                 "debug_toolbar.middleware.DebugToolbarMiddleware occurs before "
-                "django.middleware.gzip.GZipMiddleware in %s." % setting_name,
+                "django.middleware.gzip.GZipMiddleware in MIDDLEWARE.",
                 hint="Move debug_toolbar.middleware.DebugToolbarMiddleware to "
-                "after django.middleware.gzip.GZipMiddleware in %s." % setting_name,
+                "after django.middleware.gzip.GZipMiddleware in MIDDLEWARE.",
                 id="debug_toolbar.W003",
             )
         )

debug_toolbar/middleware.py

@@ -5,11 +5,9 @@
 from __future__ import absolute_import, unicode_literals
 
 import re
-import threading
 
 from django.conf import settings
 from django.utils import six
-from django.utils.deprecation import MiddlewareMixin
 from django.utils.encoding import force_text
 from django.utils.lru_cache import lru_cache
 from django.utils.module_loading import import_string
@@ -41,70 +39,35 @@ def get_show_toolbar():
         return func_or_path
 
 
-class DebugToolbarMiddleware(MiddlewareMixin):
+class DebugToolbarMiddleware(object):
     """
     Middleware to set up Debug Toolbar on incoming request and render toolbar
     on outgoing response.
     """
 
-    debug_toolbars = {}
+    def __init__(self, get_response):
+        self.get_response = get_response
 
-    def process_request(self, request):
-        # Decide whether the toolbar is active for this request.
+    def __call__(self, request):
+        # Decide whether the toolbar is active for this request. Don't render
+        # the toolbar during AJAX requests.
         show_toolbar = get_show_toolbar()
-        if not show_toolbar(request):
-            return
+        if not show_toolbar(request) or request.is_ajax():
+            return self.get_response(request)
 
-        # Don't render the toolbar during AJAX requests.
-        if request.is_ajax():
-            return
-
-        toolbar = DebugToolbar(request)
-        self.__class__.debug_toolbars[threading.current_thread().ident] = toolbar
+        toolbar = DebugToolbar(request, self.get_response)
 
         # Activate instrumentation ie. monkey-patch.
         for panel in toolbar.enabled_panels:
             panel.enable_instrumentation()
-
-        # Run process_request methods of panels like Django middleware.
-        response = None
-        for panel in toolbar.enabled_panels:
-            response = panel.process_request(request)
-            if response:
-                break
-        return response
-
-    def process_view(self, request, view_func, view_args, view_kwargs):
-        toolbar = self.__class__.debug_toolbars.get(threading.current_thread().ident)
-        if not toolbar:
-            return
-
-        # Run process_view methods of panels like Django middleware.
-        response = None
-        for panel in toolbar.enabled_panels:
-            response = panel.process_view(request, view_func, view_args, view_kwargs)
-            if response:
-                break
-        return response
-
-    def process_response(self, request, response):
-        toolbar = self.__class__.debug_toolbars.pop(
-            threading.current_thread().ident, None
-        )
-        if not toolbar:
-            return response
-
-        # Run process_response methods of panels like Django middleware.
-        for panel in reversed(toolbar.enabled_panels):
-            new_response = panel.process_response(request, response)
-            if new_response:
-                response = new_response
-
-        # Deactivate instrumentation ie. monkey-unpatch. This must run
-        # regardless of the response. Keep 'return' clauses below.
-        # (NB: Django's model for middleware doesn't guarantee anything.)
-        for panel in reversed(toolbar.enabled_panels):
-            panel.disable_instrumentation()
+        try:
+            # Run panels like Django middleware.
+            response = toolbar.process_request(request)
+        finally:
+            # Deactivate instrumentation ie. monkey-unpatch. This must run
+            # regardless of the response. Keep 'return' clauses below.
+            for panel in reversed(toolbar.enabled_panels):
+                panel.disable_instrumentation()
 
         # Check for responses where the toolbar can't be inserted.
         content_encoding = response.get("Content-Encoding", "")

debug_toolbar/panels/__init__.py

@@ -13,8 +13,9 @@ class Panel(object):
     Base class for panels.
     """
 
-    def __init__(self, toolbar):
+    def __init__(self, toolbar, get_response):
         self.toolbar = toolbar
+        self.get_response = get_response
 
     # Private panel properties
 
@@ -129,8 +130,7 @@ def disable_instrumentation(self):
         This is the opposite of :meth:`enable_instrumentation`.
 
         Unless the toolbar or this panel is disabled, this method will be
-        called late in :class:`DebugToolbarMiddleware.process_response`. It
-        should be idempotent.
+        called late in the middleware. It should be idempotent.
         """
 
     # Store and retrieve stats (shared between panels for no good reason)
@@ -168,40 +168,21 @@ def get_server_timing_stats(self):
 
     def process_request(self, request):
         """
-        Like process_request in Django's middleware.
+        Like __call__ in Django's middleware.
 
         Write panel logic related to the request there. Save data with
         :meth:`record_stats`.
-        """
-
-    def process_view(self, request, view_func, view_args, view_kwargs):
-        """
-        Like process_view in Django's middleware.
-
-        Write panel logic related to the view there. Save data with
-        :meth:`record_stats`.
-        """
-
-    def process_response(self, request, response):
-        """
-        Like process_response in Django's middleware. This is similar to
-        :meth:`generate_stats <debug_toolbar.panels.Panel.generate_stats>`,
-        but will be executed on every request. It should be used when either
-        the logic needs to be executed on every request or it needs to change
-        the response entirely, such as :class:`RedirectsPanel`.
-
-        Write panel logic related to the response there. Post-process data
-        gathered while the view executed. Save data with :meth:`record_stats`.
 
-        Return a response to overwrite the existing response.
+        Return the existing response or overwrite it.
         """
+        return self.get_response(request)
 
     def generate_stats(self, request, response):
         """
-        Similar to :meth:`process_response
-        <debug_toolbar.panels.Panel.process_response>`,
-        but may not be executed on every request. This will only be called if
-        the toolbar will be inserted into the request.
+        Called after :meth:`process_request
+        <debug_toolbar.panels.Panel.process_request>`, but may not be executed
+        on every request. This will only be called if the toolbar will be
+        inserted into the request.
 
         Write panel logic related to the response there. Post-process data
         gathered while the view executed. Save data with :meth:`record_stats`.

debug_toolbar/panels/headers.py

@@ -51,6 +51,7 @@ def process_request(self, request):
         self.record_stats(
             {"request_headers": self.request_headers, "environ": self.environ}
         )
+        return super(HeadersPanel, self).process_request(request)
 
     def generate_stats(self, request, response):
         self.response_headers = OrderedDict(sorted(response.items()))

debug_toolbar/panels/logging.py

@@ -76,6 +76,7 @@ def nav_subtitle(self):
 
     def process_request(self, request):
         collector.clear_collection()
+        return super(LoggingPanel, self).process_request(request)
 
     def generate_stats(self, request, response):
         records = collector.get_collection()

debug_toolbar/panels/profiling.py

@@ -154,10 +154,11 @@ class ProfilingPanel(Panel):
 
     template = "debug_toolbar/panels/profiling.html"
 
-    def process_view(self, request, view_func, view_args, view_kwargs):
+    def process_request(self, request):
         self.profiler = cProfile.Profile()
-        args = (request,) + view_args
-        return self.profiler.runcall(view_func, *args, **view_kwargs)
+        return self.profiler.runcall(
+            super(ProfilingPanel, self).process_request, request
+        )
 
     def add_node(self, func_list, func, max_depth, cum_time=0.1):
         func_list.append(func)

debug_toolbar/panels/redirects.py

@@ -15,7 +15,8 @@ class RedirectsPanel(Panel):
 
     nav_title = _("Intercept redirects")
 
-    def process_response(self, request, response):
+    def process_request(self, request):
+        response = super(RedirectsPanel, self).process_request(request)
         if 300 <= int(response.status_code) < 400:
             redirect_to = response.get("Location", None)
             if redirect_to:

debug_toolbar/panels/staticfiles.py

@@ -116,6 +116,7 @@ def nav_subtitle(self):
 
     def process_request(self, request):
         collector.clear_collection()
+        return super(StaticFilesPanel, self).process_request(request)
 
     def generate_stats(self, request, response):
         used_paths = collector.get_collection()

debug_toolbar/panels/timer.py

@@ -57,6 +57,7 @@ def process_request(self, request):
         self._start_time = time.time()
         if self.has_content:
             self._start_rusage = resource.getrusage(resource.RUSAGE_SELF)
+        return super(TimerPanel, self).process_request(request)
 
     def generate_stats(self, request, response):
         stats = {}

debug_toolbar/toolbar.py

@@ -18,13 +18,20 @@
 
 
 class DebugToolbar(object):
-    def __init__(self, request):
+    def __init__(self, request, get_response):
         self.request = request
         self.config = dt_settings.get_config().copy()
+        panels = []
+        for panel_class in reversed(self.get_panel_classes()):
+            panel = panel_class(self, get_response)
+            panels.append(panel)
+            if panel.enabled:
+                get_response = panel.process_request
+        self.process_request = get_response
         self._panels = OrderedDict()
-        for panel_class in self.get_panel_classes():
-            panel_instance = panel_class(self)
-            self._panels[panel_instance.panel_id] = panel_instance
+        while panels:
+            panel = panels.pop()
+            self._panels[panel.panel_id] = panel
         self.stats = {}
         self.server_timing_stats = {}
         self.store_id = None

docs/changes.rst

@@ -7,6 +7,19 @@ UNRELEASED
 * Updated ``StaticFilesPanel`` to be compatible with Django 3.0.
 * The ``ProfilingPanel`` is now enabled but inactive by default.
 * Fixed toggling of table rows in the profiling panel UI.
+* The ``ProfilingPanel`` no longer skips remaining panels or middlewares.
+
+**Backwards incompatible changes**
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+* Removed support for Django's deprecated ``MIDDLEWARE_CLASSES`` setting.
+* Restructured ``Panel`` to execute more like the new-style Django MIDDLEWARE.
+  The ``Panel.__init__()`` method is now passed ``get_response`` as the first
+  positional argument. The ``Panel.process_request()`` method must now always
+  return a response. Usually this is the response returned by
+  ``get_response()`` but the panel may also return a different response as is
+  the case in the ``RedirectsPanel``. Third party panels must adjust to this
+  new architecture. ``Panel.process_response()`` and ``Panel.process_view()``
+  have been removed as a result of this change.
 
 1.11 (2018-12-03)
 -----------------

docs/installation.rst

@@ -75,20 +75,11 @@ settings module as follows::
         # ...
     ]
 
-Old-style middleware::
-
-    MIDDLEWARE_CLASSES = [
-        # ...
-        'debug_toolbar.middleware.DebugToolbarMiddleware',
-        # ...
-    ]
-
 .. warning::
 
-    The order of ``MIDDLEWARE`` and ``MIDDLEWARE_CLASSES`` is important. You
-    should include the Debug Toolbar middleware as early as possible in the
-    list. However, it must come after any other middleware that encodes the
-    response's content, such as
+    The order of ``MIDDLEWARE`` is important. You should include the Debug
+    Toolbar middleware as early as possible in the list. However, it must come
+    after any other middleware that encodes the response's content, such as
     :class:`~django.middleware.gzip.GZipMiddleware`.
 
 Configuring Internal IPs

docs/panels.rst

@@ -117,17 +117,6 @@ Profiling information for the processing of the request.
 This panel is included but inactive by default. You can activate it by default
 with the ``DISABLE_PANELS`` configuration option.
 
-If the ``debug_toolbar.middleware.DebugToolbarMiddleware`` is first in
-``MIDDLEWARE`` then the other middlewares' ``process_view`` methods will not be
-executed. This is because ``ProfilingPanel.process_view`` will return a
-``HttpResponse`` which causes the other middlewares' ``process_view`` methods
-to be skipped.
-
-If you run into this issues, then you should either deactivate the
-``ProfilingPanel`` or move ``DebugToolbarMiddleware`` to the end of
-``MIDDLEWARE``. If you do the latter, then the debug toolbar won't track the
-execution of other middleware.
-
 Third-party panels
 ------------------
 
@@ -342,10 +331,6 @@ unauthorized access. There is no public CSS API at this time.
 
     .. automethod:: debug_toolbar.panels.Panel.process_request
 
-    .. automethod:: debug_toolbar.panels.Panel.process_view
-
-    .. automethod:: debug_toolbar.panels.Panel.process_response
-
     .. automethod:: debug_toolbar.panels.Panel.generate_stats
 
 .. _javascript-api:

docs/tips.rst

@@ -18,16 +18,6 @@ Browsers have become more aggressive with caching static assets, such as
 JavaScript and CSS files. Check your browser's development console, and if
 you see errors, try a hard browser refresh or clearing your cache.
 
-Middleware isn't working correctly
-----------------------------------
-
-Using the Debug Toolbar in its default configuration with the profiling panel
-active will cause middlewares after
-``debug_toolbar.middleware.DebugToolbarMiddleware`` to not execute their
-``process_view`` functions. This can be resolved by disabling the profiling
-panel or moving the ``DebugToolbarMiddleware`` to the end of ``MIDDLEWARE``.
-Read more about it at :ref:`ProfilingPanel <profiling-panel>`
-
 Performance considerations
 --------------------------