Document performance implications

[magus]

Not really an issue but I couldn't find a good place to ask this.

When enabled I notice that the pages take significantly longer to render. Normally, I get speedy responses with my current configuration but when I enable the Toolbar I notice that the time it takes to load the page increases significantly.

The timer module displays times of 900-1200 milliseconds which I think is pretty high. The web application I have running is pretty robust and has a lot of bells and whistles but I think these kind of times seem abnormally high and not what I experience without the toolbar enabled. Is 900-1200 a normal number or is that indeed really high, and does anyone have an idea of why it would be taking so long to render with the toolbar enabled?

[hynekcer]

Which of toolbars do you use or need? You can individually disable some panels to find which is slow.

Copy from the file /debug_toolbar/toolbar/loader.py this default set of enabled debug panels to your Django application settings.py and edit it.

    # Override this tuple by copying to settings.py as `DEBUG_TOOLBAR_PANELS`
DEBUG_TOOLBAR_PANELS = (
        'debug_toolbar.panels.version.VersionDebugPanel',
        'debug_toolbar.panels.timer.TimerDebugPanel',
        'debug_toolbar.panels.settings_vars.SettingsVarsDebugPanel',
        'debug_toolbar.panels.headers.HeaderDebugPanel',
        'debug_toolbar.panels.request_vars.RequestVarsDebugPanel',
        'debug_toolbar.panels.sql.SQLDebugPanel',
        'debug_toolbar.panels.template.TemplateDebugPanel',
        #'debug_toolbar.panels.cache.CacheDebugPanel',
        'debug_toolbar.panels.signals.SignalDebugPanel',
        'debug_toolbar.panels.logger.LoggingPanel',
    )

From my expirience only SQLDebugPanel and TemplateDebugPanel can be slow. Speed of SQL panel is easy. If SQL panel is slow (megabytes of SQL details dowloaded by browser) also server without debug panel would not be fast.

The problematic panel can be 'debug_toolbar.panels.template.TemplateDebugPanel' on some conditions: (normally is also sufficiently fast)

• You use your or third party Context processor which returns some values with lazy evaluation.
  for example

      ctx = {
          'some_name': SomeModel.objects.filter(...)
          ....
      }
      return
  

The problem is, that this eventual lazy expession (database query) is by debug_toolbar evaluated more time then a normal expession. (6 times evaluated and forgotten)
These potentially long time running queries can be evaluated by Template panel even in case when they are not used in any your template due to efficiency.
Other problem is, that this evaluation is executed after that SQL toolbar has finished and therefore these potentially long time running queries are not included in SQL results.

If you want use from Template panel blocks Template path and Templates but not the detail context of Context processors (which is very probably), you can use this patch:

--- debug_toolbar/panels/template.py.orig
+++ debug_toolbar/panels/template.py.debug.py
@@ -62,7 +62,10 @@
         context_processors = dict(
             [
                 ("%s.%s" % (k.__module__, k.__name__),
-                    pformat(k(self.request))) for k in get_standard_processors()
+                    # next line can be replaced by 'commented out'
+                    #pformat(k(self.request))
+                    'commented out'
+                    ) for k in get_standard_processors()
             ]
         )
         template_context = []
@@ -99,7 +102,9 @@
                             elif key == 'LANGUAGES' and isinstance(value, tuple):
                                 context_layer[key] = '<<languages>>'
                     try:
-                        context_list.append(pformat(context_layer))
+                        # next line can be replaced by 'pass'
+                        # context_list.append(pformat(context_layer))
+                        pass
                     except UnicodeEncodeError:
                         pass
                 info['context'] = '\n'.join(context_list)

[robhudson]

Nice explanation hynekcer... I should definitely add something like this to the docs.

[aaugustin]

#283 is related.