def get_data_from_request(request: Request, config: Config, event_type: str):
result = {
"method": request.method,
"socket": {"remote_address": request.remote, "encrypted": request.secure},
"cookies": dict(request.cookies),
}
if config.capture_headers:
result["headers"] = dict(request.headers)
# TODO: capture body
result["url"] = get_url_dict(str(request.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 set_tag(self, key, value):
if self.is_transaction:
if key == "type":
self.zuqa_ref.transaction_type = value
elif key == "result":
self.zuqa_ref.result = value
elif key == tags.HTTP_STATUS_CODE:
self.zuqa_ref.result = "HTTP {}xx".format(
compat.text_type(value)[0])
traces.set_context({"status_code": value}, "response")
elif key == "user.id":
traces.set_user_context(user_id=value)
elif key == "user.username":
traces.set_user_context(username=value)
elif key == "user.email":
traces.set_user_context(email=value)
elif key == tags.HTTP_URL:
traces.set_context({"url": get_url_dict(value)}, "request")
elif key == tags.HTTP_METHOD:
traces.set_context({"method": value}, "request")
elif key == tags.COMPONENT:
traces.set_context({"framework": {"name": value}}, "service")
else:
self.zuqa_ref.label(**{key: value})
elif not self.is_dropped:
if key.startswith("db."):
span_context = self.zuqa_ref.context or {}
if "db" not in span_context:
span_context["db"] = {}
if key == tags.DATABASE_STATEMENT:
span_context["db"]["statement"] = value
elif key == tags.DATABASE_USER:
span_context["db"]["user"] = value
elif key == tags.DATABASE_TYPE:
span_context["db"]["type"] = value
self.zuqa_ref.type = "db." + value
else:
self.zuqa_ref.label(**{key: value})
self.zuqa_ref.context = span_context
elif key == tags.SPAN_KIND:
self.zuqa_ref.type = value
else:
self.zuqa_ref.label(**{key: value})
return self
async def get_data_from_request(request: Request, config: Config,
event_type: str) -> dict:
"""Loads data from incoming request for APM capturing.
Args:
request (Request)
config (Config)
event_type (str)
Returns:
dict
"""
result = {
"method": request.method,
"socket": {
"remote_address": _get_client_ip(request),
"encrypted": request.url.is_secure
},
"cookies": request.cookies,
}
if config.capture_headers:
result["headers"] = dict(request.headers)
if request.method in constants.HTTP_WITH_BODY:
if config.capture_body not in ("all", event_type):
result["body"] = "[REDACTED]"
else:
body = None
try:
body = await get_body(request)
if request.headers.get(
"content-type") == "application/x-www-form-urlencoded":
body = await query_params_to_dict(body)
else:
body = json.loads(body)
except Exception:
pass
if body is not None:
result["body"] = body
result["url"] = get_url_dict(str(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"),
"encrypted": request.is_secure
},
"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:
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
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 test_get_url_dict(url, expected):
assert get_url_dict(url) == expected