def _emit(self, record): # type: (LogRecord) -> None if not _can_record(record): return hub = Hub.current if hub.client is None: return client_options = hub.client.options # exc_info might be None or (None, None, None) if record.exc_info is not None and record.exc_info[0] is not None: event, hint = event_from_exception( record.exc_info, client_options=client_options, mechanism={ "type": "logging", "handled": True }, ) elif record.exc_info and record.exc_info[0] is None: event = {} hint = {} with capture_internal_exceptions(): event["threads"] = { "values": [{ "stacktrace": current_stacktrace(client_options["with_locals"]), "crashed": False, "current": True, }] } else: event = {} hint = {} hint["log_record"] = record client = Hub.current.client event["level"] = _logging_to_event_level(record.levelname) event["logger"] = record.name event["logentry"] = { "message": to_string(record.msg), "params": partial_serialize(client, record.args, should_repr_strings=False), } event["extra"] = partial_serialize(client, _extra_from_record(record), should_repr_strings=False) hub.capture_event(event, hint=hint)
def _emit(self, record): # type: (LogRecord) -> None if not _can_record(record): return hub = Hub.current if hub.client is None: return client_options = hub.client.options # exc_info might be None or (None, None, None) # # exc_info may also be any falsy value due to Python stdlib being # liberal with what it receives and Celery's billiard being "liberal" # with what it sends. See # https://github.com/getsentry/sentry-python/issues/904 if record.exc_info and record.exc_info[0] is not None: event, hint = event_from_exception( record.exc_info, client_options=client_options, mechanism={ "type": "logging", "handled": True }, ) elif record.exc_info and record.exc_info[0] is None: event = {} hint = {} with capture_internal_exceptions(): event["threads"] = { "values": [{ "stacktrace": current_stacktrace(client_options["with_locals"]), "crashed": False, "current": True, }] } else: event = {} hint = {} hint["log_record"] = record event["level"] = _logging_to_event_level(record.levelname) event["logger"] = record.name event["logentry"] = { "message": to_string(record.msg), "params": record.args } event["extra"] = _extra_from_record(record) hub.capture_event(event, hint=hint)
def _prepare_event(self, event, hint, scope): if event.get("timestamp") is None: event["timestamp"] = datetime.utcnow() if scope is not None: event = scope.apply_to_event(event, hint) if event is None: return 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"] = [ { "stacktrace": current_stacktrace(), "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"] ) before_send = self.options["before_send"] if before_send is not None: with capture_internal_exceptions(): new_event = before_send(event, hint) if new_event is None: logger.info("before send dropped event (%s)", event) event = new_event # Postprocess the event in the very end so that annotated types do # generally not surface in before_send if event is not None: strip_event_mut(event) event = flatten_metadata(event) event = convert_types(event) return event
def _emit(self, record): # type: (LogRecord) -> None if not _can_record(record): return hub = Hub.current if hub.client is None: return hint = None # type: Optional[Dict[str, Any]] client_options = hub.client.options # exc_info might be None or (None, None, None) if record.exc_info is not None and record.exc_info[0] is not None: event, hint = event_from_exception( record.exc_info, client_options=client_options, mechanism={ "type": "logging", "handled": True }, ) elif record.exc_info and record.exc_info[0] is None: event = {} hint = None with capture_internal_exceptions(): event["threads"] = [{ "stacktrace": current_stacktrace(client_options["with_locals"]), "crashed": False, "current": True, }] else: event = {} event["level"] = _logging_to_event_level(record.levelname) event["logger"] = record.name event["logentry"] = { "message": to_string(record.msg), "params": record.args } event["extra"] = _extra_from_record(record) hub.capture_event(event, hint=hint)
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: # type: ignore event[key] = text_type( self.options[key]).strip() # type: ignore 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 = Serializer().serialize_event(event) 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 _emit(self, record): # type: (LogRecord) -> None if not _can_record(record): return hub = Hub.current if hub.client is None: return client_options = hub.client.options # exc_info might be None or (None, None, None) # # exc_info may also be any falsy value due to Python stdlib being # liberal with what it receives and Celery's billiard being "liberal" # with what it sends. See # https://github.com/getsentry/sentry-python/issues/904 if record.exc_info and record.exc_info[0] is not None: event, hint = event_from_exception( record.exc_info, client_options=client_options, mechanism={ "type": "logging", "handled": True }, ) elif record.exc_info and record.exc_info[0] is None: event = {} hint = {} with capture_internal_exceptions(): event["threads"] = { "values": [{ "stacktrace": current_stacktrace( client_options["with_locals"], client_options["with_source_context"], ), "crashed": False, "current": True, }] } else: event = {} hint = {} hint["log_record"] = record event["level"] = _logging_to_event_level(record.levelname) event["logger"] = record.name # Log records from `warnings` module as separate issues record_caputured_from_warnings_module = (record.name == "py.warnings" and record.msg == "%s") if record_caputured_from_warnings_module: # use the actual message and not "%s" as the message # this prevents grouping all warnings under one "%s" issue msg = record.args[0] # type: ignore event["logentry"] = { "message": msg, "params": (), } else: event["logentry"] = { "message": to_string(record.msg), "params": record.args, } event["extra"] = _extra_from_record(record) hub.capture_event(event, hint=hint)
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