def extract_into_event(self, event):
client = Hub.current.client
if client is None:
return
content_length = self.content_length()
request_info = event.setdefault("request", {})
request_info["url"] = self.url()
if _should_send_default_pii():
request_info["cookies"] = dict(self.cookies())
bodies = client.options["request_bodies"]
if (
bodies == "never"
or (bodies == "small" and content_length > 10 ** 3)
or (bodies == "medium" and content_length > 10 ** 4)
):
data = AnnotatedValue(
"",
{"rem": [["!config", "x", 0, content_length]], "len": content_length},
)
else:
parsed_body = self.parsed_body()
if parsed_body:
data = parsed_body
elif self.raw_data():
data = AnnotatedValue(
"",
{"rem": [["!raw", "x", 0, content_length]], "len": content_length},
)
else:
return
request_info["data"] = data
def extract_into_event(self, event):
# type: (Dict[str, Any]) -> None
client = Hub.current.client
if client is None:
return
data = None # type: Optional[Union[AnnotatedValue, Dict[str, Any]]]
content_length = self.content_length()
request_info = event.get("request", {})
if _should_send_default_pii():
request_info["cookies"] = dict(self.cookies())
if not request_body_within_bounds(client, content_length):
data = AnnotatedValue(
"",
{"rem": [["!config", "x", 0, content_length]], "len": content_length},
)
else:
parsed_body = self.parsed_body()
if parsed_body is not None:
data = parsed_body
elif self.raw_data():
data = AnnotatedValue(
"",
{"rem": [["!raw", "x", 0, content_length]], "len": content_length},
)
else:
data = None
if data is not None:
request_info["data"] = data
event["request"] = request_info
def get_aiohttp_request_data(hub, request):
# type: (Hub, Request) -> Union[Optional[str], AnnotatedValue]
bytes_body = request._read_bytes
if bytes_body is not None:
# we have body to show
if not request_body_within_bounds(hub.client, len(bytes_body)):
return AnnotatedValue(
"",
{
"rem": [["!config", "x", 0,
len(bytes_body)]],
"len": len(bytes_body)
},
)
encoding = request.charset or "utf-8"
return bytes_body.decode(encoding, "replace")
if request.can_read_body:
# body exists but we can't show it
return BODY_NOT_READ_MESSAGE
# request has no body
return None
def extract_into_event(self, event):
# type: (Dict[str, Any]) -> None
client = Hub.current.client
if client is None:
return
data = None # type: Optional[Union[AnnotatedValue, Dict[str, Any]]]
content_length = self.content_length()
request_info = event.setdefault("request", {})
bodies = client.options["request_bodies"]
if (bodies == "never" or (bodies == "small" and content_length > 10**3)
or (bodies == "medium" and content_length > 10**4)):
data = AnnotatedValue(
"",
{
"rem": [["!config", "x", 0, content_length]],
"len": content_length
},
)
else:
data = self.message_data
request_info["data"] = data
def extract_into_event(self, event):
# type: (Dict[str, Any]) -> None
client = Hub.current.client
if client is None:
return
data = None # type: Optional[Union[AnnotatedValue, Dict[str, Any]]]
content_length = self.content_length()
request_info = event.get("request", {})
if _should_send_default_pii():
request_info["cookies"] = dict(self.cookies())
bodies = client.options["request_bodies"]
if (bodies == "never" or (bodies == "small" and content_length > 10**3)
or (bodies == "medium" and content_length > 10**4)):
data = AnnotatedValue(
"",
{
"rem": [["!config", "x", 0, content_length]],
"len": content_length
},
)
else:
parsed_body = self.parsed_body()
if parsed_body is not None:
data = parsed_body
elif self.raw_data():
data = AnnotatedValue(
"",
{
"rem": [["!raw", "x", 0, content_length]],
"len": content_length
},
)
else:
data = None
if data is not None:
request_info["data"] = data
event["request"] = partial_serialize(client,
request_info,
should_repr_strings=False)
def event_processor(sentry_event, hint, start_time=start_time):
# type: (Event, Hint, datetime) -> Optional[Event]
remaining_time_in_milis = aws_context.get_remaining_time_in_millis()
exec_duration = configured_timeout - remaining_time_in_milis
extra = sentry_event.setdefault("extra", {})
extra["lambda"] = {
"function_name": aws_context.function_name,
"function_version": aws_context.function_version,
"invoked_function_arn": aws_context.invoked_function_arn,
"aws_request_id": aws_context.aws_request_id,
"execution_duration_in_millis": exec_duration,
"remaining_time_in_millis": remaining_time_in_milis,
}
extra["cloudwatch logs"] = {
"url": _get_cloudwatch_logs_url(aws_context, start_time),
"log_group": aws_context.log_group_name,
"log_stream": aws_context.log_stream_name,
}
request = sentry_event.get("request", {})
if "httpMethod" in aws_event:
request["method"] = aws_event["httpMethod"]
request["url"] = _get_url(aws_event, aws_context)
if "queryStringParameters" in aws_event:
request["query_string"] = aws_event["queryStringParameters"]
if "headers" in aws_event:
request["headers"] = _filter_headers(aws_event["headers"])
if _should_send_default_pii():
user_info = sentry_event.setdefault("user", {})
id = aws_event.get("identity", {}).get("userArn")
if id is not None:
user_info.setdefault("id", id)
ip = aws_event.get("identity", {}).get("sourceIp")
if ip is not None:
user_info.setdefault("ip_address", ip)
if "body" in aws_event:
request["data"] = aws_event.get("body", "")
else:
if aws_event.get("body", None):
# Unfortunately couldn't find a way to get structured body from AWS
# event. Meaning every body is unstructured to us.
request["data"] = AnnotatedValue(
"", {"rem": [["!raw", "x", 0, 0]]})
sentry_event["request"] = request
return sentry_event
def _filter_headers(headers):
# type: (Dict[str, str]) -> Dict[str, str]
if _should_send_default_pii():
return headers
return {
k: (v if k.upper().replace("-", "_")
not in SENSITIVE_HEADERS else AnnotatedValue(
"", {"rem": [["!config", "x", 0, len(v)]]}))
for k, v in iteritems(headers)
}
def test_flatten_metadata():
assert flatten_metadata({"foo": u"bar"}) == {"foo": u"bar"}
assert flatten_metadata({"foo": ["bar"]}) == {"foo": [u"bar"]}
assert flatten_metadata({"foo": [AnnotatedValue("bar", u"meta")]}) == {
"foo": [u"bar"],
"_meta": {
"foo": {
"0": {
"": u"meta"
}
}
},
}
def parsed_body(self):
form = self.form()
files = self.files()
if form or files:
data = dict(form.items())
for k, v in files.items():
size = self.size_of_file(v)
data[k] = AnnotatedValue(
"", {"len": size, "rem": [["!raw", "x", 0, size]]}
)
return data
return self.json()
def event_processor(event, hint):
# type: (Event, Hint) -> Optional[Event]
final_time = datetime.utcnow()
time_diff = final_time - initial_time
execution_duration_in_millis = time_diff.microseconds / MILLIS_TO_SECONDS
extra = event.setdefault("extra", {})
extra["google cloud functions"] = {
"function_name": environ.get("FUNCTION_NAME"),
"function_entry_point": environ.get("ENTRY_POINT"),
"function_identity": environ.get("FUNCTION_IDENTITY"),
"function_region": environ.get("FUNCTION_REGION"),
"function_project": environ.get("GCP_PROJECT"),
"execution_duration_in_millis": execution_duration_in_millis,
"configured_timeout_in_seconds": configured_timeout,
}
extra["google cloud logs"] = {
"url": _get_google_cloud_logs_url(final_time),
}
request = event.get("request", {})
request["url"] = "gcp:///{}".format(environ.get("FUNCTION_NAME"))
if hasattr(gcp_event, "method"):
request["method"] = gcp_event.method
if hasattr(gcp_event, "query_string"):
request["query_string"] = gcp_event.query_string.decode("utf-8")
if hasattr(gcp_event, "headers"):
request["headers"] = _filter_headers(gcp_event.headers)
if _should_send_default_pii():
if hasattr(gcp_event, "data"):
request["data"] = gcp_event.data
else:
if hasattr(gcp_event, "data"):
# Unfortunately couldn't find a way to get structured body from GCP
# event. Meaning every body is unstructured to us.
request["data"] = AnnotatedValue(
"", {"rem": [["!raw", "x", 0, 0]]})
event["request"] = request
return event
def parsed_body(self):
# type: () -> Optional[Dict[str, Any]]
form = self.form()
files = self.files()
if form or files:
data = dict(iteritems(form))
for k, v in iteritems(files):
size = self.size_of_file(v)
data[k] = AnnotatedValue(
"", {"len": size, "rem": [["!raw", "x", 0, size]]}
)
return data
return self.json()
def event_processor(event, hint):
# type: (Event, Hint) -> Optional[Event]
extra = event.setdefault("extra", {})
extra["lambda"] = {
"remaining_time_in_millis":
aws_context.get_remaining_time_in_millis(),
"function_name": aws_context.function_name,
"function_version": aws_context.function_version,
"invoked_function_arn": aws_context.invoked_function_arn,
"aws_request_id": aws_context.aws_request_id,
}
request = event.get("request", {})
if "httpMethod" in aws_event:
request["method"] = aws_event["httpMethod"]
request["url"] = _get_url(aws_event, aws_context)
if "queryStringParameters" in aws_event:
request["query_string"] = aws_event["queryStringParameters"]
if "headers" in aws_event:
request["headers"] = _filter_headers(aws_event["headers"])
if aws_event.get("body", None):
# Unfortunately couldn't find a way to get structured body from AWS
# event. Meaning every body is unstructured to us.
request["data"] = AnnotatedValue("",
{"rem": [["!raw", "x", 0, 0]]})
if _should_send_default_pii():
user_info = event.setdefault("user", {})
id = aws_event.get("identity", {}).get("userArn")
if id is not None:
user_info["id"] = id
ip = aws_event.get("identity", {}).get("sourceIp")
if ip is not None:
user_info["ip_address"] = ip
event["request"] = partial_serialize(Hub.current.client,
request,
should_repr_strings=False)
return event
def event_processor(event, hint):
extra = event.setdefault("extra", {})
extra["lambda"] = {
"remaining_time_in_millis":
aws_context.get_remaining_time_in_millis(),
"function_name": aws_context.function_name,
"function_version": aws_context.function_version,
"invoked_function_arn": aws_context.invoked_function_arn,
"aws_request_id": aws_context.aws_request_id,
}
request = event.setdefault("request", {})
if "httpMethod" in aws_event and "method" not in request:
request["method"] = aws_event["httpMethod"]
if "url" not in request:
request["url"] = _get_url(aws_event, aws_context)
if "queryStringParameters" in aws_event and "query_string" not in request:
request["query_string"] = aws_event["queryStringParameters"]
if "headers" in aws_event and "headers" not in request:
request["headers"] = _filter_headers(aws_event["headers"])
if aws_event.get("body", None):
# Unfortunately couldn't find a way to get structured body from AWS
# event. Meaning every body is unstructured to us.
request["data"] = AnnotatedValue("",
{"rem": [["!raw", "x", 0, 0]]})
if _should_send_default_pii():
user_info = event.setdefault("user", {})
if "id" not in user_info:
user_info["id"] = aws_event.get("identity", {}).get("userArn")
if "ip_address" not in user_info:
user_info["ip_address"] = aws_event.get("identity",
{}).get("sourceIp")
return event
