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_headers_coerces_http_name():
result = dict(get_headers({
'HTTP_ACCEPT': 'text/plain',
}))
assert 'accept' in result
assert result['accept'] == 'text/plain'
def test_get_headers_tuple_as_key():
result = dict(get_headers({
('a', 'tuple'): 'foo',
}))
assert result == {}
def test_get_headers_coerces_content_length():
result = dict(get_headers({
'CONTENT_LENGTH': '134',
}))
assert 'content-length' in result
assert result['content-length'] == '134'
def test_coerces_content_type(self):
result = dict(get_headers({
'CONTENT_TYPE': 'text/plain',
}))
self.assertIn('content-type', result)
self.assertEquals(result['content-type'], 'text/plain')
def test_coerces_http_name(self):
result = dict(get_headers({
'HTTP_ACCEPT': 'text/plain',
}))
self.assertIn('accept', result)
self.assertEquals(result['accept'], 'text/plain')
def test_get_headers_coerces_content_length():
result = dict(get_headers({"CONTENT_LENGTH": "134"}))
assert "content-length" in result
assert result["content-length"] == "134"
def test_coerces_content_length(self):
result = dict(get_headers({
'CONTENT_LENGTH': '134',
}))
self.assertIn('content-length', result)
self.assertEquals(result['content-length'], '134')
def test_get_headers_coerces_content_type():
result = dict(get_headers({"CONTENT_TYPE": "text/plain"}))
assert "content-type" in result
assert result["content-type"] == "text/plain"
def test_get_headers_coerces_http_name():
result = dict(get_headers({"HTTP_ACCEPT": "text/plain"}))
assert "accept" in result
assert result["accept"] == "text/plain"
def test_get_headers_tuple_as_key():
result = dict(get_headers({("a", "tuple"): "foo"}))
assert result == {}
def test_get_headers_coerces_content_type():
result = dict(get_headers({
'CONTENT_TYPE': 'text/plain',
}))
assert 'content-type' in result
assert result['content-type'] == 'text/plain'
def test_tuple_as_key(self):
result = dict(get_headers({
('a', 'tuple'): 'foo',
}))
self.assertEquals(result, {})
