def test_sentry_variables_clip(monkeypatch):
letters = "abcdefghijklmnoprst"
for letter in letters:
locals()[letter] = 1
try:
raise ValueError("eeee")
except ValueError as ee:
event, hint = sentry_sdk.utils.event_from_exception(ee)
vars_dict = event["exception"]["values"][0]["stacktrace"]["frames"][0][
"vars"]
for letter in letters:
assert letter in vars_dict
cliped = serialize(event)
assert len(cliped["exception"]["values"][0]["stacktrace"]["frames"][0]
["vars"]) == 10
monkeypatch.setattr(sentry_sdk.serializer, "MAX_DATABAG_BREADTH", 100)
cliped = serialize(event)
assert len(cliped["exception"]["values"][0]["stacktrace"]["frames"][0]
["vars"]) == len(vars_dict)
assert len(cliped["exception"]["values"][0]["stacktrace"]["frames"][0]
["vars"]) > 10
client = Client("https://[email protected]/77")
Hub.current.bind_client(client)
sentry_sdk.capture_event(event, hint=hint)
def test_before_serialize_node():
def f(o):
if not isinstance(o, list):
return o
return "[!]"
assert serialize({"a": {"b": []}}, before_serialize_node = f)["a"]["b"] == "[!]"
assert serialize({"a": {"b": []}}, before_serialize_node = None)["a"]["b"] == []
def test_sentry_serialize_clip(monkeypatch):
message = "a" * 5000
try:
raise ValueError("eeee")
except ValueError as e:
event, hint = sentry_sdk.utils.event_from_exception(e)
event["message"] = message
cliped = serialize(event)
assert len(cliped["message"]) == 512
monkeypatch.setattr(sentry_sdk.utils, "MAX_STRING_LENGTH", 10**4)
cliped = serialize(event)
assert len(cliped["message"]) == 5000
def prepare_error_data(exception: Exception) -> ErrorInfo:
try:
from sentry_sdk.serializer import serialize
from sentry_sdk.utils import event_from_exception
event = event_from_exception(exception)[0]
event = serialize(event)
return exception, (event,
traceback.extract_tb(exception.__traceback__))
except ImportError:
return exception, traceback.extract_tb(exception.__traceback__)
def test_datetime_precision(dt, semaphore_normalize):
event = serialize({"timestamp": dt})
normalized = semaphore_normalize(event)
if normalized is None:
pytest.skip("no semaphore available")
dt2 = datetime.utcfromtimestamp(normalized["timestamp"])
# Float glitches can happen, and more glitches can happen
# because we try to work around some float glitches in semaphore
assert (dt - dt2).total_seconds() < 1.0
def inner(message, **kwargs):
event = serialize({"logentry": {"message": message}}, **kwargs)
normalized = semaphore_normalize(event)
return normalized["logentry"]["message"]
def inner(message, **kwargs):
event = serialize({"extra": {"foo": message}}, **kwargs)
validate_event_schema(event)
return event["extra"]["foo"]
def inner(message, **kwargs):
event = serialize({"logentry": {"message": message}}, **kwargs)
validate_event_schema(event)
return event["logentry"]["message"]
def _prepare_event(
self,
event, # type: Event
hint, # type: Optional[Hint]
scope, # type: Optional[Scope]
):
# type: (...) -> Optional[Event]
if event.get("timestamp") is None:
event["timestamp"] = datetime.utcnow()
hint = dict(hint or ()) # type: Hint
if scope is not None:
event_ = scope.apply_to_event(event, hint)
if event_ is None:
return None
event = event_
if (
self.options["attach_stacktrace"]
and "exception" not in event
and "stacktrace" not in event
and "threads" not in event
):
with capture_internal_exceptions():
event["threads"] = {
"values": [
{
"stacktrace": current_stacktrace(
self.options["with_locals"]
),
"crashed": False,
"current": True,
}
]
}
for key in "release", "environment", "server_name", "dist":
if event.get(key) is None and self.options[key] is not None:
event[key] = text_type(self.options[key]).strip()
if event.get("sdk") is None:
sdk_info = dict(SDK_INFO)
sdk_info["integrations"] = sorted(self.integrations.keys())
event["sdk"] = sdk_info
if event.get("platform") is None:
event["platform"] = "python"
event = handle_in_app(
event, self.options["in_app_exclude"], self.options["in_app_include"]
)
# Postprocess the event here so that annotated types do
# generally not surface in before_send
if event is not None:
event = serialize(
event,
before_serialize_node=self.options["before_serialize_node"],
)
before_send = self.options["before_send"]
if before_send is not None:
new_event = None
with capture_internal_exceptions():
new_event = before_send(event, hint or {})
if new_event is None:
logger.info("before send dropped event (%s)", event)
event = new_event # type: ignore
return event
def inner(message, **kwargs):
event = serialize({"extra": {"foo": message}}, **kwargs)
normalized = relay_normalize(event)
return normalized["extra"]["foo"]
def test_small_numpy_serialize(monkeypatch):
arr = np.zeros(10, dtype=np.uint8)
arr[1] = 10
monkeypatch.setattr(sentry_sdk.serializer, "safe_repr", safe_repr)
res = serialize(arr)
assert res == str(res)
def test_numpy_array_serialize(monkeypatch, dtype):
arr = np.zeros((10, 10), dtype=dtype)
arr[1, 5] = 10
monkeypatch.setattr(sentry_sdk.serializer, "safe_repr", safe_repr)
res = serialize(arr)
assert res == f"array(size={arr.size}, shape={arr.shape}, dtype={arr.dtype}, min={arr.min()}, max={arr.max()})"
def _prepare_event(
self,
event, # type: Event
hint, # type: Hint
scope, # type: Optional[Scope]
):
# type: (...) -> Optional[Event]
if event.get("timestamp") is None:
event["timestamp"] = datetime.utcnow()
if scope is not None:
is_transaction = event.get("type") == "transaction"
event_ = scope.apply_to_event(event, hint)
# one of the event/error processors returned None
if event_ is None:
if self.transport:
self.transport.record_lost_event(
"event_processor",
data_category=("transaction" if is_transaction else "error"),
)
return None
event = event_
if (
self.options["attach_stacktrace"]
and "exception" not in event
and "stacktrace" not in event
and "threads" not in event
):
with capture_internal_exceptions():
event["threads"] = {
"values": [
{
"stacktrace": current_stacktrace(
self.options["with_locals"],
self.options["with_source_context"],
),
"crashed": False,
"current": True,
}
]
}
for key in "release", "environment", "server_name", "dist":
if event.get(key) is None and self.options[key] is not None:
event[key] = text_type(self.options[key]).strip()
if event.get("sdk") is None:
sdk_info = dict(SDK_INFO)
sdk_info["integrations"] = sorted(self.integrations.keys())
event["sdk"] = sdk_info
if event.get("platform") is None:
event["platform"] = "python"
event = handle_in_app(
event, self.options["in_app_exclude"], self.options["in_app_include"]
)
# Postprocess the event here so that annotated types do
# generally not surface in before_send
if event is not None:
event = serialize(
event,
smart_transaction_trimming=self.options["_experiments"].get(
"smart_transaction_trimming"
),
)
before_send = self.options["before_send"]
if before_send is not None and event.get("type") != "transaction":
new_event = None
with capture_internal_exceptions():
new_event = before_send(event, hint or {})
if new_event is None:
logger.info("before send dropped event (%s)", event)
if self.transport:
self.transport.record_lost_event(
"before_send", data_category="error"
)
event = new_event # type: ignore
return event
