Create generate_stats, an optional method similar to process_response.

generate_stats is not always called. It will only be called when
the toolbar is going to insert itself into the response. The method
process_response will always be called and should be used for panels
that need to interrupt the request such as the RedirectsPanel.

This update is to address issue #517.

Author: tim-schilling

debug_toolbar/middleware.py

@@ -126,6 +126,10 @@ def process_response(self, request, response):
             # When the body ends with a newline, there's two trailing groups.
             bits.append(''.join(m[0] for m in matches if m[1] == ''))
         if len(bits) > 1:
+            # When the toolbar will be inserted for sure, generate the stats.
+            for panel in reversed(toolbar.enabled_panels):
+                panel.generate_stats(request, response)
+
             bits[-2] += toolbar.render_toolbar()
             response.content = insert_before.join(bits)
             if response.get('Content-Length', None):

debug_toolbar/panels/__init__.py

@@ -167,10 +167,28 @@ def process_view(self, request, view_func, view_args, view_kwargs):
 
     def process_response(self, request, response):
         """
-        Like process_response in Django's middleware.
+        Like process_response in Django's middleware. This is similar to
+        :meth:`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.
+        """
+
+    def generate_stats(self, request, response):
+        """
+        Similar to :meth:`process_response`, 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`.
+
+        Does not return a value.
         """
 
 

debug_toolbar/panels/cache.py

@@ -244,7 +244,7 @@ def disable_instrumentation(self):
             middleware_cache.caches = original_caches
         cache.get_cache = original_get_cache
 
-    def process_response(self, request, response):
+    def generate_stats(self, request, response):
         self.record_stats({
             'total_calls': len(self.calls),
             'calls': self.calls,

debug_toolbar/panels/headers.py

@@ -47,7 +47,7 @@ def process_request(self, request):
             'environ': self.environ,
         })
 
-    def process_response(self, request, response):
+    def generate_stats(self, request, response):
         self.response_headers = OrderedDict(sorted(response.items()))
         self.record_stats({
             'response_headers': self.response_headers,

debug_toolbar/panels/logging.py

@@ -74,7 +74,7 @@ def nav_subtitle(self):
     def process_request(self, request):
         collector.clear_collection()
 
-    def process_response(self, request, response):
+    def generate_stats(self, request, response):
         records = collector.get_collection()
         self._records[threading.currentThread()] = records
         collector.clear_collection()

debug_toolbar/panels/profiling.py

@@ -142,7 +142,7 @@ def add_node(self, func_list, func, max_depth, cum_time=0.1):
                     func.has_subfuncs = True
                     self.add_node(func_list, subfunc, max_depth, cum_time=cum_time)
 
-    def process_response(self, request, response):
+    def generate_stats(self, request, response):
         if not hasattr(self, 'profiler'):
             return None
         # Could be delayed until the panel content is requested (perf. optim.)

debug_toolbar/panels/request.py

@@ -25,7 +25,7 @@ def nav_subtitle(self):
         view_func = self.get_stats().get('view_func', '')
         return view_func.rsplit('.', 1)[-1]
 
-    def process_response(self, request, response):
+    def generate_stats(self, request, response):
         self.record_stats({
             'get': [(k, request.GET.getlist(k)) for k in sorted(request.GET)],
             'post': [(k, request.POST.getlist(k)) for k in sorted(request.POST)],

debug_toolbar/panels/settings.py

@@ -19,7 +19,7 @@ class SettingsPanel(Panel):
     def title(self):
         return _("Settings from <code>%s</code>") % settings.SETTINGS_MODULE
 
-    def process_response(self, request, response):
+    def generate_stats(self, request, response):
         self.record_stats({
             'settings': OrderedDict(sorted(get_safe_settings().items(),
                                            key=lambda s: s[0])),

debug_toolbar/panels/signals.py

@@ -58,7 +58,7 @@ def signals(self):
             signals[signal_name] = getattr(signals_mod, signal_name)
         return signals
 
-    def process_response(self, request, response):
+    def generate_stats(self, request, response):
         signals = []
         for name, signal in sorted(self.signals.items(), key=lambda x: x[0]):
             if signal is None:

debug_toolbar/panels/sql/panel.py

@@ -136,7 +136,7 @@ def disable_instrumentation(self):
         for connection in connections.all():
             unwrap_cursor(connection)
 
-    def process_response(self, request, response):
+    def generate_stats(self, request, response):
         colors = contrasting_color_generator()
         trace_colors = defaultdict(lambda: next(colors))
         query_duplicates = defaultdict(lambda: defaultdict(int))

debug_toolbar/panels/staticfiles.py

@@ -113,7 +113,7 @@ def nav_subtitle(self):
     def process_request(self, request):
         collector.clear_collection()
 
-    def process_response(self, request, response):
+    def generate_stats(self, request, response):
         used_paths = collector.get_collection()
         self._paths[threading.currentThread()] = used_paths
 

debug_toolbar/panels/templates/panel.py

@@ -195,7 +195,7 @@ def enable_instrumentation(self):
     def disable_instrumentation(self):
         template_rendered.disconnect(self._store_template_info)
 
-    def process_response(self, request, response):
+    def generate_stats(self, request, response):
         template_context = []
         for template_data in self.templates:
             info = {}

debug_toolbar/panels/timer.py

@@ -52,7 +52,7 @@ def process_request(self, request):
         if self.has_content:
             self._start_rusage = resource.getrusage(resource.RUSAGE_SELF)
 
-    def process_response(self, request, response):
+    def generate_stats(self, request, response):
         stats = {}
         if hasattr(self, '_start_time'):
             stats['total_time'] = (time.time() - self._start_time) * 1000

debug_toolbar/panels/versions.py

@@ -22,7 +22,7 @@ def nav_subtitle(self):
 
     template = 'debug_toolbar/panels/versions.html'
 
-    def process_response(self, request, response):
+    def generate_stats(self, request, response):
         versions = [
             ('Python', '%d.%d.%d' % sys.version_info[:3]),
             ('Django', self.get_app_version(django)),

tests/panels/test_cache.py

@@ -46,3 +46,16 @@ def test_recording_get_cache(self):
         default_cache.set('foo', 'bar')
         second_cache.get('foo')
         self.assertEqual(len(self.panel.calls), 2)
+
+    def test_insert_content(self):
+        """
+        Test that the panel only inserts content after generate_stats and
+        not the process_response.
+        """
+        cache.cache.get('café')
+        self.panel.process_response(self.request, self.response)
+        # ensure the panel does not have content yet.
+        self.assertNotIn('café', self.panel.content)
+        self.panel.generate_stats(self.request, self.response)
+        # ensure the panel renders correctly.
+        self.assertIn('café', self.panel.content)

tests/panels/test_logging.py

@@ -1,3 +1,5 @@
+# coding: utf-8
+
 from __future__ import absolute_import, unicode_literals
 
 import logging
@@ -24,6 +26,7 @@ def test_happy_case(self):
         self.logger.info('Nothing to see here, move along!')
 
         self.panel.process_response(self.request, self.response)
+        self.panel.generate_stats(self.request, self.response)
         records = self.panel.get_stats()['records']
 
         self.assertEqual(1, len(records))
@@ -34,12 +37,26 @@ def test_formatting(self):
         self.logger.info('There are %d %s', 5, 'apples')
 
         self.panel.process_response(self.request, self.response)
+        self.panel.generate_stats(self.request, self.response)
         records = self.panel.get_stats()['records']
 
         self.assertEqual(1, len(records))
         self.assertEqual('There are 5 apples',
                          records[0]['message'])
 
+    def test_insert_content(self):
+        """
+        Test that the panel only inserts content after generate_stats and
+        not the process_response.
+        """
+        self.logger.info('café')
+        self.panel.process_response(self.request, self.response)
+        # ensure the panel does not have content yet.
+        self.assertNotIn('café', self.panel.content)
+        self.panel.generate_stats(self.request, self.response)
+        # ensure the panel renders correctly.
+        self.assertIn('café', self.panel.content)
+
     def test_failing_formatting(self):
         class BadClass(object):
             def __str__(self):
@@ -49,6 +66,7 @@ def __str__(self):
         self.logger.debug('This class is misbehaving: %s', BadClass())
 
         self.panel.process_response(self.request, self.response)
+        self.panel.generate_stats(self.request, self.response)
         records = self.panel.get_stats()['records']
 
         self.assertEqual(1, len(records))

tests/panels/test_profiling.py

@@ -23,9 +23,23 @@ def setUp(self):
     def test_regular_view(self):
         self.panel.process_view(self.request, regular_view, ('profiling',), {})
         self.panel.process_response(self.request, self.response)
+        self.panel.generate_stats(self.request, self.response)
         self.assertIn('func_list', self.panel.get_stats())
         self.assertIn('regular_view', self.panel.content)
 
+    def test_insert_content(self):
+        """
+        Test that the panel only inserts content after generate_stats and
+        not the process_response.
+        """
+        self.panel.process_view(self.request, regular_view, ('profiling',), {})
+        self.panel.process_response(self.request, self.response)
+        # ensure the panel does not have content yet.
+        self.assertNotIn('regular_view', self.panel.content)
+        self.panel.generate_stats(self.request, self.response)
+        # ensure the panel renders correctly.
+        self.assertIn('regular_view', self.panel.content)
+
 
 @override_settings(DEBUG=True,
                    DEBUG_TOOLBAR_PANELS=['debug_toolbar.panels.profiling.ProfilingPanel'])

tests/panels/test_redirects.py

@@ -58,3 +58,14 @@ def test_unknown_status_code_with_reason(self):
         redirect['Location'] = 'http://somewhere/else/'
         response = self.panel.process_response(self.request, redirect)
         self.assertContains(response, '369 Look Ma!')
+
+    def test_insert_content(self):
+        """
+        Test that the panel only inserts content after generate_stats and
+        not the process_response.
+        """
+        redirect = HttpResponse(status=304)
+        response = self.panel.process_response(self.request, redirect)
+        self.assertIsNotNone(response)
+        response = self.panel.generate_stats(self.request, redirect)
+        self.assertIsNone(response)

tests/panels/test_request.py

@@ -19,6 +19,7 @@ def test_non_ascii_session(self):
             self.request.session['là'.encode('utf-8')] = 'là'.encode('utf-8')
         self.panel.process_request(self.request)
         self.panel.process_response(self.request, self.response)
+        self.panel.generate_stats(self.request, self.response)
         content = self.panel.content
         if six.PY3:
             self.assertIn('où', content)
@@ -30,4 +31,18 @@ def test_object_with_non_ascii_repr_in_request_params(self):
         self.request.path = '/non_ascii_request/'
         self.panel.process_request(self.request)
         self.panel.process_response(self.request, self.response)
+        self.panel.generate_stats(self.request, self.response)
+        self.assertIn('nôt åscíì', self.panel.content)
+
+    def test_insert_content(self):
+        """
+        Test that the panel only inserts content after generate_stats and
+        not the process_response.
+        """
+        self.request.path = '/non_ascii_request/'
+        self.panel.process_response(self.request, self.response)
+        # ensure the panel does not have content yet.
+        self.assertNotIn('nôt åscíì', self.panel.content)
+        self.panel.generate_stats(self.request, self.response)
+        # ensure the panel renders correctly.
         self.assertIn('nôt åscíì', self.panel.content)

tests/panels/test_sql.py

@@ -64,10 +64,24 @@ def test_non_ascii_query(self):
         self.assertEqual(len(self.panel._queries), 3)
 
         self.panel.process_response(self.request, self.response)
+        self.panel.generate_stats(self.request, self.response)
 
         # ensure the panel renders correctly
         self.assertIn('café', self.panel.content)
 
+    def test_insert_content(self):
+        """
+        Test that the panel only inserts content after generate_stats and
+        not the process_response.
+        """
+        list(User.objects.filter(username='café'.encode('utf-8')))
+        self.panel.process_response(self.request, self.response)
+        # ensure the panel does not have content yet.
+        self.assertNotIn('café', self.panel.content)
+        self.panel.generate_stats(self.request, self.response)
+        # ensure the panel renders correctly.
+        self.assertIn('café', self.panel.content)
+
     @unittest.skipUnless(connection.vendor == 'postgresql',
                          'Test valid only on PostgreSQL')
     def test_erroneous_query(self):

tests/panels/test_staticfiles.py

@@ -16,6 +16,7 @@ def setUp(self):
     def test_default_case(self):
         self.panel.process_request(self.request)
         self.panel.process_response(self.request, self.response)
+        self.panel.generate_stats(self.request, self.response)
         self.assertIn('django.contrib.staticfiles.finders.'
                       'AppDirectoriesFinder', self.panel.content)
         self.assertIn('django.contrib.staticfiles.finders.'
@@ -26,3 +27,18 @@ def test_default_case(self):
                          ['django.contrib.admin', 'debug_toolbar'])
         self.assertEqual(self.panel.get_staticfiles_dirs(),
                          finders.FileSystemFinder().locations)
+
+    def test_insert_content(self):
+        """
+        Test that the panel only inserts content after generate_stats and
+        not the process_response.
+        """
+        self.panel.process_request(self.request)
+        self.panel.process_response(self.request, self.response)
+        # ensure the panel does not have content yet.
+        self.assertNotIn('django.contrib.staticfiles.finders.'
+                         'AppDirectoriesFinder', self.panel.content)
+        self.panel.generate_stats(self.request, self.response)
+        # ensure the panel renders correctly.
+        self.assertIn('django.contrib.staticfiles.finders.'
+                      'AppDirectoriesFinder', self.panel.content)

tests/panels/test_template.py

@@ -48,6 +48,22 @@ def test_object_with_non_ascii_repr_in_context(self):
         c = Context({'object': NonAsciiRepr()})
         t.render(c)
         self.panel.process_response(self.request, self.response)
+        self.panel.generate_stats(self.request, self.response)
+        self.assertIn('nôt åscíì', self.panel.content)
+
+    def test_insert_content(self):
+        """
+        Test that the panel only inserts content after generate_stats and
+        not the process_response.
+        """
+        t = Template("{{ object }}")
+        c = Context({'object': NonAsciiRepr()})
+        t.render(c)
+        self.panel.process_response(self.request, self.response)
+        # ensure the panel does not have content yet.
+        self.assertNotIn('nôt åscíì', self.panel.content)
+        self.panel.generate_stats(self.request, self.response)
+        # ensure the panel renders correctly.
         self.assertIn('nôt åscíì', self.panel.content)
 
     def test_custom_context_processor(self):
@@ -56,6 +72,7 @@ def test_custom_context_processor(self):
         c = RequestContext(self.request, processors=[context_processor])
         t.render(c)
         self.panel.process_response(self.request, self.response)
+        self.panel.generate_stats(self.request, self.response)
         self.assertIn('tests.panels.test_template.context_processor', self.panel.content)
 
     def test_disabled(self):

tests/test_integration.py

@@ -45,6 +45,7 @@ def _resolve_stats(self, path):
         panel = self.toolbar.get_panel_by_id('RequestPanel')
         panel.process_request(self.request)
         panel.process_response(self.request, self.response)
+        panel.generate_stats(self.request, self.response)
         return panel.get_stats()
 
     def test_url_resolving_positional(self):