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