def get_data_from_request(request, capture_body=False):
result = {
'env': dict(get_environ(request.environ)),
'headers': dict(
get_headers(request.environ),
),
'method': request.method,
'socket': {
'remote_address': request.environ.get('REMOTE_ADDR'),
'encrypted': request.is_secure
},
'cookies': request.cookies,
}
if request.method not in ('GET', 'HEAD'):
body = None
if request.content_type == 'application/x-www-form-urlencoded':
body = compat.multidict_to_dict(request.form)
elif request.content_type.startswith('multipart/form-data'):
body = compat.multidict_to_dict(request.form)
if request.files:
body['_files'] = {
field: val[0].filename if len(val) == 1 else [f.filename for f in val]
for field, val in compat.iterlists(request.files)
}
else:
try:
body = request.data
except ClientDisconnected:
pass
if body is not None:
result['body'] = body if capture_body else '[REDACTED]'
result['url'] = get_url_dict(request.url)
return result
def get_data_from_request(request, capture_body=False, capture_headers=True):
result = {
"env": dict(get_environ(request.env)),
"method": request.method,
"socket": {"remote_address": request.env.get("REMOTE_ADDR"),
"encrypted": True if request.scheme == 'https' else False},
"cookies": request.cookies,
}
if capture_headers:
result["headers"] = dict(get_headers(request.env))
if request.method in constants.HTTP_WITH_BODY:
body = None
if request.content_type == "application/x-www-form-urlencoded":
body = compat.multidict_to_dict(request.stream.read())
elif request.content_type and request.content_type.startswith("multipart/form-data"):
body = compat.multidict_to_dict(request.stream.read())
else:
try:
body = request.stream.read()
except ClientDisconnected:
pass
if body is not None:
result["body"] = body if capture_body else "[REDACTED]"
result["url"] = get_url_dict(request.url)
return result
def get_data_from_request(request, config, event_type):
result = {
"env": dict(get_environ(request.environ)),
"method": request.method,
"socket": {"remote_address": request.environ.get("REMOTE_ADDR")},
"cookies": request.cookies,
}
if config.capture_headers:
result["headers"] = dict(get_headers(request.environ))
if request.method in constants.HTTP_WITH_BODY:
if config.capture_body not in ("all", event_type):
result["body"] = "[REDACTED]"
else:
body = None
if request.content_type == "application/x-www-form-urlencoded":
body = compat.multidict_to_dict(request.form)
elif request.content_type and request.content_type.startswith("multipart/form-data"):
body = compat.multidict_to_dict(request.form)
if request.files:
body["_files"] = {
field: val[0].filename if len(val) == 1 else [f.filename for f in val]
for field, val in compat.iterlists(request.files)
}
else:
try:
body = request.get_data(as_text=True)
except ClientDisconnected:
pass
if body is not None:
result["body"] = body
result["url"] = get_url_dict(request.url)
return result
def get_data_from_request(self, request, event_type):
result = {
"env": dict(get_environ(request.META)),
"method": request.method,
"socket": {
"remote_address": request.META.get("REMOTE_ADDR"),
"encrypted": request.is_secure()
},
"cookies": dict(request.COOKIES),
}
if self.config.capture_headers:
request_headers = dict(get_headers(request.META))
for key, value in request_headers.items():
if isinstance(value, (int, float)):
request_headers[key] = str(value)
result["headers"] = request_headers
if request.method in constants.HTTP_WITH_BODY:
content_type = request.META.get("CONTENT_TYPE")
if content_type == "application/x-www-form-urlencoded":
data = compat.multidict_to_dict(request.POST)
elif content_type and content_type.startswith(
"multipart/form-data"):
data = compat.multidict_to_dict(request.POST)
if request.FILES:
data["_files"] = {
field: file.name
for field, file in compat.iteritems(request.FILES)
}
else:
try:
data = request.body
except Exception as e:
self.logger.debug("Can't capture request body: %s",
compat.text_type(e))
data = "<unavailable>"
capture_body = self.config.capture_body in ("all", event_type)
result["body"] = data if (capture_body
or not data) else "[REDACTED]"
if hasattr(request, "get_raw_uri"):
# added in Django 1.9
url = request.get_raw_uri()
else:
try:
# Requires host to be in ALLOWED_HOSTS, might throw a
# DisallowedHost exception
url = request.build_absolute_uri()
except DisallowedHost:
# We can't figure out the real URL, so we have to set it to
# DisallowedHost
result["url"] = {"full": "DisallowedHost"}
url = None
if url:
result["url"] = get_url_dict(url)
return result
def get_data_from_request(self, request, capture_body=False):
result = {
'env': dict(get_environ(request.META)),
'headers': dict(get_headers(request.META)),
'method': request.method,
'socket': {
'remote_address': request.META.get('REMOTE_ADDR'),
'encrypted': request.is_secure()
},
'cookies': dict(request.COOKIES),
}
if request.method in constants.HTTP_WITH_BODY:
content_type = request.META.get('CONTENT_TYPE')
if content_type == 'application/x-www-form-urlencoded':
data = compat.multidict_to_dict(request.POST)
elif content_type and content_type.startswith(
'multipart/form-data'):
data = compat.multidict_to_dict(request.POST)
if request.FILES:
data['_files'] = {
field: file.name
for field, file in compat.iteritems(request.FILES)
}
else:
try:
data = request.body
except Exception:
data = '<unavailable>'
result['body'] = data if (capture_body
or not data) else '[REDACTED]'
if hasattr(request, 'get_raw_uri'):
# added in Django 1.9
url = request.get_raw_uri()
else:
try:
# Requires host to be in ALLOWED_HOSTS, might throw a
# DisallowedHost exception
url = request.build_absolute_uri()
except DisallowedHost:
# We can't figure out the real URL, so we have to set it to
# DisallowedHost
result['url'] = {'full': 'DisallowedHost'}
url = None
if url:
result['url'] = get_url_dict(url)
return result
def handle_exception(self, exc_info, environ):
event_id = self.client.capture(
"Exception",
exc_info=exc_info,
context={
"request": {
"method": environ.get("REQUEST_METHOD"),
"url": get_url_dict(get_current_url(environ)),
"headers": dict(get_headers(environ)),
"env": dict(get_environ(environ)),
}
},
handled=False,
)
return event_id
def handle_exception(self, exc_info, environ):
event_id = self.client.capture(
'Exception',
exc_info=exc_info,
context={
'request': {
'method': environ.get('REQUEST_METHOD'),
'url': get_url_dict(get_current_url(environ)),
'headers': dict(get_headers(environ)),
'env': dict(get_environ(environ)),
}
},
handled=False,
)
return event_id
def get_data_from_request(self, request, event_type):
result = {
"env": dict(get_environ(request.META)),
"method": request.method,
"socket": {
"remote_address": request.META.get("REMOTE_ADDR")
},
"cookies": dict(request.COOKIES),
}
if self.config.capture_headers:
request_headers = dict(get_headers(request.META))
for key, value in request_headers.items():
if isinstance(value, (int, float)):
request_headers[key] = str(value)
result["headers"] = request_headers
if request.method in constants.HTTP_WITH_BODY:
capture_body = self.config.capture_body in ("all", event_type)
if not capture_body:
result["body"] = "[REDACTED]"
else:
content_type = request.META.get("CONTENT_TYPE")
if content_type == "application/x-www-form-urlencoded":
data = compat.multidict_to_dict(request.POST)
elif content_type and content_type.startswith(
"multipart/form-data"):
data = compat.multidict_to_dict(request.POST)
if request.FILES:
data["_files"] = {
field: file.name
for field, file in compat.iteritems(request.FILES)
}
else:
try:
data = request.body
except Exception as e:
self.logger.debug("Can't capture request body: %s",
compat.text_type(e))
data = "<unavailable>"
if data is not None:
result["body"] = data
url = get_raw_uri(request)
result["url"] = get_url_dict(url)
return result
def get_data_from_request(self, request):
if request.method != 'GET':
try:
if hasattr(request, 'body'):
# Django 1.4+
raw_data = request.body
else:
raw_data = request.raw_post_data
data = raw_data if raw_data else request.POST
except Exception:
# assume we had a partial read:
data = '<unavailable>'
else:
data = None
environ = request.META
result = {
'body': data,
'env': dict(get_environ(environ)),
'headers': dict(get_headers(environ)),
'method': request.method,
'socket': {
'remote_address': request.META.get('REMOTE_ADDR'),
'encrypted': request.is_secure()
},
'cookies': dict(request.COOKIES),
}
if hasattr(request, 'get_raw_uri'):
# added in Django 1.9
url = request.get_raw_uri()
else:
try:
# Requires host to be in ALLOWED_HOSTS, might throw a
# DisallowedHost exception
url = request.build_absolute_uri()
except DisallowedHost:
# We can't figure out the real URL, so we have to set it to
# DisallowedHost
result['url'] = {'raw': 'DisallowedHost'}
url = None
if url:
result['url'] = get_url_dict(url)
return result
def get_data_from_request(request):
body = None
if request.data:
body = request.data
elif request.form:
body = urlencode(request.form)
result = {
'body': body,
'env': dict(get_environ(request.environ)),
'headers': dict(get_headers(request.environ), ),
'method': request.method,
'socket': {
'remote_address': request.environ.get('REMOTE_ADDR'),
'encrypted': request.is_secure
},
'cookies': request.cookies,
}
result['url'] = get_url_dict(request.url)
return result
def test_get_environ_has_remote_addr():
result = dict(get_environ({'REMOTE_ADDR': '127.0.0.1'}))
assert 'REMOTE_ADDR' in result
assert result['REMOTE_ADDR'] == '127.0.0.1'
def test_get_environ_hides_wsgi_input():
result = list(get_environ({'wsgi.input': 'foo'}))
assert 'wsgi.input' not in result
def test_get_environ_has_server_port():
result = dict(get_environ({'SERVER_PORT': 80}))
assert 'SERVER_PORT' in result
assert result['SERVER_PORT'] == 80
def test_has_server_name(self):
result = dict(get_environ({'SERVER_NAME': '127.0.0.1'}))
self.assertIn('SERVER_NAME', result)
self.assertEquals(result['SERVER_NAME'], '127.0.0.1')
def test_has_remote_addr(self):
result = dict(get_environ({'REMOTE_ADDR': '127.0.0.1'}))
self.assertIn('REMOTE_ADDR', result)
self.assertEquals(result['REMOTE_ADDR'], '127.0.0.1')
def test_get_environ_hides_wsgi_input():
result = list(get_environ({"wsgi.input": "foo"}))
assert "wsgi.input" not in result
def test_has_server_port(self):
result = dict(get_environ({'SERVER_PORT': 80}))
self.assertIn('SERVER_PORT', result)
self.assertEquals(result['SERVER_PORT'], 80)
def test_get_environ_has_server_port():
result = dict(get_environ({"SERVER_PORT": 80}))
assert "SERVER_PORT" in result
assert result["SERVER_PORT"] == 80
def test_get_environ_has_server_name():
result = dict(get_environ({"SERVER_NAME": "127.0.0.1"}))
assert "SERVER_NAME" in result
assert result["SERVER_NAME"] == "127.0.0.1"
def test_get_environ_has_remote_addr():
result = dict(get_environ({"REMOTE_ADDR": "127.0.0.1"}))
assert "REMOTE_ADDR" in result
assert result["REMOTE_ADDR"] == "127.0.0.1"
def test_get_environ_has_server_name():
result = dict(get_environ({'SERVER_NAME': '127.0.0.1'}))
assert 'SERVER_NAME' in result
assert result['SERVER_NAME'] == '127.0.0.1'
def test_hides_wsgi_input(self):
result = list(get_environ({'wsgi.input': 'foo'}))
self.assertNotIn('wsgi.input', result)
