1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
"""
Debug Toolbar middleware
"""
from __future__ import absolute_import, unicode_literals
import re
import threading
from django.conf import settings
from django.utils import six
from django.utils.encoding import force_text
from django.utils.lru_cache import lru_cache
from django.utils.module_loading import import_string
from debug_toolbar import settings as dt_settings
from debug_toolbar.toolbar import DebugToolbar
try:
from django.utils.deprecation import MiddlewareMixin
except ImportError: # Django < 1.10
# Works perfectly for everyone using MIDDLEWARE_CLASSES
MiddlewareMixin = object
_HTML_TYPES = ('text/html', 'application/xhtml+xml')
def show_toolbar(request):
"""
Default function to determine whether to show the toolbar on a given page.
"""
if request.META.get('REMOTE_ADDR', None) not in settings.INTERNAL_IPS:
return False
return bool(settings.DEBUG)
@lru_cache()
def get_show_toolbar():
# If SHOW_TOOLBAR_CALLBACK is a string, which is the recommended
# setup, resolve it to the corresponding callable.
func_or_path = dt_settings.get_config()['SHOW_TOOLBAR_CALLBACK']
if isinstance(func_or_path, six.string_types):
return import_string(func_or_path)
else:
return func_or_path
class DebugToolbarMiddleware(MiddlewareMixin):
"""
Middleware to set up Debug Toolbar on incoming request and render toolbar
on outgoing response.
"""
debug_toolbars = {}
def process_request(self, request):
# Decide whether the toolbar is active for this request.
show_toolbar = get_show_toolbar()
if not show_toolbar(request):
return
# 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
# 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()
# Check for responses where the toolbar can't be inserted.
content_encoding = response.get('Content-Encoding', '')
content_type = response.get('Content-Type', '').split(';')[0]
if any((getattr(response, 'streaming', False),
'gzip' in content_encoding,
content_type not in _HTML_TYPES)):
return response
# Collapse the toolbar by default if SHOW_COLLAPSED is set.
if toolbar.config['SHOW_COLLAPSED'] and 'djdt' not in request.COOKIES:
response.set_cookie('djdt', 'hide', 864000)
# Insert the toolbar in the response.
content = force_text(response.content, encoding=response.charset)
insert_before = dt_settings.get_config()['INSERT_BEFORE']
pattern = re.escape(insert_before)
bits = re.split(pattern, content, flags=re.IGNORECASE)
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):
response['Content-Length'] = len(response.content)
return response
|
