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
