def emit(self, record: logging.LogRecord):
"""Add a logging message."""
msg = record.msg
if isinstance(record.msg, utils.LogMessage):
# Ensure we don't use the extra ASCII indents here.
record.msg = record.msg.format_msg()
self.widget['state'] = "normal"
# We don't want to indent the first line.
firstline, *lines = self.format(record).split('\n')
self.widget.insert(
END,
# Start with a newline so it doesn't end with one.
'\n' + firstline,
(record.levelname,),
)
for line in lines:
self.widget.insert(
END,
'\n' + line,
# Indent following lines.
(record.levelname, 'INDENT'),
)
self.widget.see(END) # Scroll to the end
self.widget['state'] = "disabled"
# Undo the record overwrite, so other handlers get the correct object.
record.msg = msg
def format(self, record: logging.LogRecord) -> str:
# record is a LogRecord
# https://docs.python.org/3.4/library/logging.html#logging.LogRecord
# message = super().format(record)
super().format(record)
# Since fmt does not contain asctime, the Formatter.format()
# will not write asctime (since its usesTime()) function will be
# false. Therefore:
record.asctime = self.formatTime(record, self.datefmt)
bg_col = self.log_background_colors[record.levelno]
msg = escape(record.getMessage())
# escape() won't replace \n but will replace & etc.
if self.replace_nl_with_br:
msg = msg.replace("\n", "<br>")
html = (
'<span style="color:#008B8B">{time}.{ms:03d} {name}:{lvname}: '
'</span><span style="color:{color}{bg}">{msg}</font>{br}'.format(
time=record.asctime,
ms=int(record.msecs),
name=record.name,
lvname=record.levelname,
color=self.log_colors[record.levelno],
msg=msg,
bg=";background-color:{}".format(bg_col) if bg_col else "",
br="<br>" if self.append_br else "",
)
)
# print("record.__dict__: {}".format(record.__dict__))
# print("html: {}".format(html))
return html
def format(self, record: logging.LogRecord):
"""
Format the specified record as text.
This implementation is directly copied from the superclass,
only adding the codeblock to the traceback.
"""
record.message = clean_content(record.getMessage())
if self.usesTime():
record.asctime = self.formatTime(record, self.datefmt)
s = self.formatMessage(record)
if record.exc_info:
# Cache the traceback text to avoid converting it multiple times
# (it's constant anyway)
if not record.exc_text:
record.exc_text = self.formatException(record.exc_info)
if record.exc_text:
if s[-1:] != "\n":
s = s + "\n"
# add a codeblock so the DiscordHandler can properly split
# the error into multiple messages if needed
s = f'{s}```py\n{record.exc_text}```'
if record.stack_info:
if s[-1:] != "\n":
s = s + "\n"
s = s + self.formatStack(record.stack_info)
return s
def record(self, app_name):
self.record_count += 1
msg = "log msg %r" %(self.record_count, )
record = LogRecord("name", logging.INFO, "x.py", 42, msg, None, None)
record.app_name = app_name
record.created = 100 + self.record_count
record.msecs = 42
return record
def log_and_publish(self, message, *args, **kwargs):
"""Log a line using and send it to the web tier.
The *args are passed to logger.info()
The **kwargs are passed to '_send_line()'
"""
logger.info(message, *args)
record = LogRecord('name', logging.INFO, "(unknown file)", 0,
message, args, exc_info=None, func=None)
full_message = record.getMessage()
self.publish_message(line=full_message, **kwargs)
def makeRecord(self, name, level, fn, lno, msg, args, exc_info,
func=None, extra=None):
rv = LogRecord(name, level, fn, lno, msg, args, exc_info, func)
if extra is not None:
for key, value in extra.items():
if key in ("message", "asctime") or key in rv.__dict__:
raise KeyError(
"Attempt to override %r in LogRecord" % key)
rv.__dict__[key] = value
rv.processName = multiprocessing.current_process()._name
return rv
def log_and_publish_error(self, message, *args, **kwargs):
"""Log a line using and send it to the web tier.
The *args are passed to logger.info()
The **kwargs are passed to '_send_line()'
"""
logger.error(message, *args)
record = LogRecord('name', logging.ERROR, "(unknown file)", 0,
message, args, exc_info=None, func=None)
full_message = record.getMessage()
updated_kwargs = dict(kwargs)
updated_kwargs['errorLine'] = True
self.publish_message(line=full_message, **updated_kwargs)
def test_json_formatter_easy_extra_types(json_formatter):
record = LogRecord(
name='test', level=INFO, pathname='/test.py', lineno=1337, msg="This is a test", args=[], exc_info=None
)
record.extra_one = 'String Test'
record.extra_two = 1092384901283490120984
record.extra_three = ['list test']
actual = json.loads(json_formatter.format(record))
assert_contains(actual, {
'extra_one': 'String Test',
'extra_two': 1092384901283490120984,
'extra_three': ['list test'],
})
def test_json_formatter_non_easy_extra_types(json_formatter):
record = LogRecord(
name='test', level=INFO, pathname='/test.py', lineno=1337, msg="This is a test", args=[], exc_info=None
)
class Example(object):
def __repr__(self):
return 'Example Repr in action!'
record.extra_one = Example()
actual = json.loads(json_formatter.format(record))
assert_contains(actual, {
'extra_one': 'Example Repr in action!',
})
def filter(self, record: logging.LogRecord) -> bool:
""" Decide whether the record should be logged. """
message = record.getMessage()
is_new_message = message not in self.__messages_seen
if is_new_message:
self.__messages_seen.add(message)
return is_new_message
def add_logentry(self, record: logging.LogRecord):
model = self.builder.get_object('logstore')
assert isinstance(model, Gtk.ListStore)
if record.levelno == logging.DEBUG:
textcolor = 'gray'
bgcolor = 'white'
elif record.levelno == logging.INFO:
textcolor = 'black'
bgcolor = 'white'
elif record.levelno == logging.WARNING:
textcolor = 'orange'
bgcolor = 'white'
elif record.levelno == logging.ERROR:
textcolor = 'red'
bgcolor = 'white'
elif record.levelno == logging.CRITICAL:
textcolor = 'black'
bgcolor = 'red'
else:
textcolor = 'blue'
bgcolor = 'white'
it = model.append(
[record.asctime, record.levelname, record.levelno, '{}:{:d}'.format(record.name, record.lineno),
record.getMessage(), textcolor, bgcolor, record.levelno >= self.filterlevel])
while len(model) > self.nentries:
model.remove(model.get_iter_first())
if self.builder.get_object('autoscroll_checkbutton').get_active():
filteredmodel = self.builder.get_object('logstore_filtered')
assert isinstance(filteredmodel, Gtk.TreeModelFilter)
success, it = filteredmodel.convert_child_iter_to_iter(it)
if success:
self.builder.get_object('logview').scroll_to_cell(filteredmodel.get_path(it), None, True, 0.0, 1.0)
self.update_shown_count()
def format_message(self, record: logging.LogRecord): # noqa: C901
s = record.getMessage()
if record.exc_info:
# Cache the traceback text to avoid converting it multiple times
# (it's constant anyway)
if not record.exc_text:
record.exc_text = self.formatException(record.exc_info)
if record.exc_text:
if s[-1:] != '\n':
s = s + '\n'
s = s + record.exc_text
if record.stack_info:
if s[-1:] != '\n':
s = s + '\n'
s = s + self.formatStack(record.stack_info)
return s
def filter(self, record: logging.LogRecord) -> bool:
if record.exc_info:
self.logged_stack = True
message = record.getMessage()
if self.regex.match(message):
self.matched = True
return False
return True
def _format_record(self, record: logging.LogRecord=None) -> logging.LogRecord:
"""
Formatted the LogRecord
:param record: LogRecord with the message info
:return: LogRecord with formatted message
"""
# ensure that exc_info and args
# have been stringified. Removes any chance of
# unpickleable things inside and possibly reduces
# message size sent over the pipe.
if record.args:
record.msg = record.msg % record.args
record.args = None
if record.exc_info:
self.format(record)
record.exc_info = None
return record
def emit(self, record: logging.LogRecord):
"""Add a logging message."""
msg = record.msg
if isinstance(record.msg, srctools.logger.LogMessage):
# Ensure we don't use the extra ASCII indents here.
record.msg = record.msg.format_msg()
self.widget['state'] = "normal"
# We don't want to indent the first line.
firstline, *lines = self.format(record).split('\n')
if self.has_text:
# Start with a newline so it doesn't end with one.
self.widget.insert(
END,
'\n',
(),
)
self.widget.insert(
END,
firstline,
(record.levelname,),
)
for line in lines:
self.widget.insert(
END,
'\n',
('INDENT',),
line,
# Indent following lines.
(record.levelname, 'INDENT'),
)
self.widget.see(END) # Scroll to the end
self.widget['state'] = "disabled"
# Update it, so it still runs even when we're busy with other stuff.
self.widget.update_idletasks()
self.has_text = True
# Undo the record overwrite, so other handlers get the correct object.
record.msg = msg
def test_extra_formatter_formats_log_with_extra():
format_string = "{message}"
formatter = ExtraConsoleFormatter(format_string)
log_message = "A sample log with extra: {foo}."
extra = dict(foo='bar')
log_record = LogRecord(
'name',
INFO,
'some_function',
42,
log_message,
None,
None
)
log_record.foo = extra['foo']
log_result = formatter.format(log_record)
assert_that(log_result, is_(equal_to(log_message.format(**extra))))
def test_extra_formatter_supports_old_and_new_formats():
format_string = "{message}"
formatter = ExtraConsoleFormatter(format_string)
log_message = "A sample log with old string %s, new: {foo}"
args = ("bar",)
extra = dict(foo="baz")
log_record = LogRecord(
'name',
INFO,
'some_function',
42,
log_message,
args,
0
)
log_record.foo = extra['foo']
log_result = formatter.format(log_record)
assert_that(log_result, is_(equal_to(log_message.format(**extra) % args)))
def makeRecord(self, name, level, fn, lno, msg, args, exc_info, func=None, extra=None):
record = LogRecord(name, level, fn, lno, msg, args, exc_info, func)
if exc_info:
if extra is None:
extra = {}
# get additional info about the exception
ex_type, ex, _ = exc_info
extra["exc_type"] = ex_type.__name__
# add members of the exception as extra info except callables and non-public stuff
for name, val in inspect.getmembers(ex, lambda a: not callable(a)):
# args just contains all exception args again, can be ignored
if not name.startswith("_") and name not in ("args",):
# rename keys which collide with names from the log record
if name in ["message", "asctime"] or hasattr(record, name):
extra["exc_" + name] = val
else:
extra[name] = val
if issubclass(ex_type, UnicodeError):
obj = extra["object"]
if isinstance(obj, str):
# escape string that caused this exception
start = extra["start"]
end = extra["end"]
snippet_start = start - 1000 if start > 1000 else start
snippet_end = end + 1000
error_part = obj[start:end + 1].encode("string_escape")
extra["object"] = obj[snippet_start:start - 1] + "[ERROR]" + error_part + "[/ERROR]" + obj[end + 1:snippet_end]
else:
extra["object"] = obj[:2000]
if extra is not None:
for key in extra:
if (key in ["message", "asctime"]) or (key in record.__dict__):
raise KeyError("Attempt to overwrite %r in LogRecord" % key)
record.__dict__[key] = extra[key]
return record
def format(self, record: logging.LogRecord):
now = datetime.now(tz=self._tz)
data = dict(
context=self._context,
name=self._name,
message=record.getMessage(),
level=record.levelname,
date=now,
color_start="",
color_end="",
)
if self._terminal:
data['color_start'] = TerminalColor.for_level(record.levelno)
if data['color_start']:
data['color_end'] = colorama.Style.RESET_ALL
s = (
"{context}/{name}"
" [{date:%Y-%m-%d %H:%M:%S %z}]"
" {color_start}| "
"{level:{level_name_length}}"
" | {message}"
"{color_end}"
).format(level_name_length=self._max_logging_level_length, **data)
if record.exc_info:
# Cache the traceback text to avoid converting it multiple times
# (it's constant anyway)
if not record.exc_text:
record.exc_text = self.formatException(record.exc_info)
if record.exc_text:
if s[-1:] != "\n":
s += "\n"
s = s + record.exc_text
if record.stack_info:
if s[-1:] != "\n":
s += "\n"
s = s + self.formatStack(record.stack_info)
return s
def emit(self, record: logging.LogRecord) -> None:
report = {} # type: Dict[str, Any]
try:
report['node'] = platform.node()
report['host'] = platform.node()
add_deployment_metadata(report)
if record.exc_info:
stack_trace = ''.join(traceback.format_exception(*record.exc_info))
message = str(record.exc_info[1])
else:
stack_trace = 'No stack trace available'
message = record.getMessage()
if '\n' in message:
# Some exception code paths in queue processors
# seem to result in super-long messages
stack_trace = message
message = message.split('\n')[0]
report['stack_trace'] = stack_trace
report['message'] = message
report['logger_name'] = record.name
report['log_module'] = find_log_caller_module(record)
report['log_lineno'] = record.lineno
if hasattr(record, "request"):
add_request_metadata(report, record.request) # type: ignore # record.request is added dynamically
except Exception:
report['message'] = "Exception in preparing exception report!"
logging.warning(report['message'], exc_info=True)
report['stack_trace'] = "See /var/log/zulip/errors.log"
try:
if settings.STAGING_ERROR_NOTIFICATIONS:
# On staging, process the report directly so it can happen inside this
# try/except to prevent looping
from zerver.lib.error_notify import notify_server_error
notify_server_error(report)
else:
queue_json_publish('error_reports', dict(
type = "server",
report = report,
))
except Exception:
# If this breaks, complain loudly but don't pass the traceback up the stream
# However, we *don't* want to use logging.exception since that could trigger a loop.
logging.warning("Reporting an exception triggered an exception!", exc_info=True)
def _shorten_name_of_logrecord(record: logging.LogRecord) -> logging.LogRecord:
record = copy.copy(record) # avoid mutating arg
# strip the main module name from the logger name
if record.name.startswith("vialectrum."):
record.name = record.name[13:]
# manual map to shorten common module names
record.name = record.name.replace("interface.Interface", "interface", 1)
record.name = record.name.replace("network.Network", "network", 1)
record.name = record.name.replace("synchronizer.Synchronizer", "synchronizer", 1)
record.name = record.name.replace("verifier.SPV", "verifier", 1)
record.name = record.name.replace("gui.qt.main_window.ElectrumWindow", "gui.qt.main_window", 1)
return record
def handle(self, record: logging.LogRecord):
""" Do whatever it takes to actually log the specified logging record.
:param logging.LogRecord record: Log record instance to emit
:return None:
"""
with self._lock:
if record.levelno == LEVEL_PROGRESS:
record.levelname = LEVEL_NAME_PROGRESS
self.__enable_cr_mode()
try:
padding = ' ' * (self.__terminal_width - len(self.handler.format(record)))
except:
padding = ''
record.msg += padding
elif self.__in_cr_mode:
self.__disable_cr_mode()
self.handler.stream.write(self.handler.terminator)
self.handler.handle(record)
def filter(self, record: logging.LogRecord):
name = package_name.shorten(record.name, 35)
record.msg = name + " | " + str(record.msg)
return True
def write(self, msg):
self.emit(LogRecord('run_cmd', logging.INFO, __file__, 0, msg, '', ''))
def test_logging_handler_dont_emit_elasticapm(capsys, elasticapm_client):
handler = LoggingHandler(elasticapm_client)
handler.emit(LogRecord("elasticapm.errors", 1, "/ab/c/", 10, "Oops", [], None))
out, err = capsys.readouterr()
assert "Oops" in err
def filter(self, record: logging.LogRecord) -> bool:
"""Hide sensitive data in messages."""
record.msg = record.msg.replace(self.text, "*******")
return True
def emit(self, record: logging.LogRecord) -> None:
report: Dict[str, Any] = {}
# This parameter determines whether Zulip should attempt to
# send Zulip messages containing the error report. If there's
# syntax that makes the Markdown processor throw an exception,
# we really don't want to send that syntax into a new Zulip
# message in exception handler (that's the stuff of which
# recursive exception loops are made).
#
# We initialize is_markdown_rendering_exception to `True` to
# prevent the infinite loop of Zulip messages by ERROR_BOT if
# the outer try block here throws an exception before we have
# a chance to check the exception for whether it comes from
# markdown.
is_markdown_rendering_exception = True
try:
report['node'] = platform.node()
report['host'] = platform.node()
report['deployment_data'] = dict(
git=try_git_describe(),
ZULIP_VERSION=ZULIP_VERSION,
)
if record.exc_info:
stack_trace = ''.join(
traceback.format_exception(*record.exc_info))
message = str(record.exc_info[1])
is_markdown_rendering_exception = record.msg.startswith(
'Exception in Markdown parser')
else:
stack_trace = 'No stack trace available'
message = record.getMessage()
if '\n' in message:
# Some exception code paths in queue processors
# seem to result in super-long messages
stack_trace = message
message = message.split('\n')[0]
is_markdown_rendering_exception = False
report['stack_trace'] = stack_trace
report['message'] = message
report['logger_name'] = record.name
report['log_module'] = find_log_caller_module(record)
report['log_lineno'] = record.lineno
if isinstance(record, HasRequest):
add_request_metadata(report, record.request)
except Exception:
report['message'] = "Exception in preparing exception report!"
logging.warning(report['message'], exc_info=True)
report['stack_trace'] = "See /var/log/zulip/errors.log"
capture_exception()
if settings.DEBUG_ERROR_REPORTING: # nocoverage
logging.warning("Reporting an error to admins...")
logging.warning(
"Reporting an error to admins: %s %s %s %s %s",
record.levelname,
report['logger_name'],
report['log_module'],
report['message'],
report['stack_trace'],
)
try:
if settings.STAGING_ERROR_NOTIFICATIONS:
# On staging, process the report directly so it can happen inside this
# try/except to prevent looping
from zerver.lib.error_notify import notify_server_error
notify_server_error(report, is_markdown_rendering_exception)
else:
queue_json_publish('error_reports',
dict(
type="server",
report=report,
))
except Exception:
# If this breaks, complain loudly but don't pass the traceback up the stream
# However, we *don't* want to use logging.exception since that could trigger a loop.
logging.warning("Reporting an exception triggered an exception!",
exc_info=True)
capture_exception()
def format(self, record: LogRecord) -> str:
record.name = self._shorten_module_name(record.name)
record.args = self._redact_logging_args(record.args)
return super().format(record)
def emit(self, record: logging.LogRecord) -> None: # pragma: no cover
"""Intercept standard logging messages toward Loguru sink."""
logger_opt = logger.opt(depth=7, exception=record.exc_info)
logger_opt.log(record.levelname, record.getMessage())
def health_check_filter(record: LogRecord) -> bool:
# Filter out health checks from the logs, they're verbose and happen frequently
return not ("GET /healthcheck" in record.getMessage()
and record.status_code == 200)
def filter(self, record: logging.LogRecord) -> bool:
if self.prefix:
record.msg = self.prefix + ' ' + record.msg
return True
def filter(self, record: logging.LogRecord) -> bool:
record.skip_warningsiserror = True # type: ignore
return True
def filter(self, record: logging.LogRecord) -> bool:
return ("were not used when initializing T5EncoderModel: ['decoder."
not in record.getMessage())
def emit(self, record: logging.LogRecord) -> None: # pragma: no cover
logger_opt = logger.opt(depth=7, exception=record.exc_info)
logger_opt.log(record.levelname, record.getMessage())
def filter(self, record: logging.LogRecord):
rid = context.get_request_id()
cid = context.get_correlation_id()
record.msg = f"RID: {rid} | CID: {cid} | {str(record.msg)}"
return True
def cherrypy_filter(record: logging.LogRecord) -> int:
blocked = ['TLSV1_ALERT_DECRYPT_ERROR']
msg = record.getMessage()
return not any([m for m in blocked if m in msg])
def match(self, record: logging.LogRecord):
match_name = bool(re.match(self.name_regexp, record.name))
match_regexp = bool(re.match(self.msg_regexp, record.getMessage()))
return match_name and match_regexp
def emit(self, record: logging.LogRecord) -> None:
report: Dict[str, Any] = {}
try:
report["node"] = platform.node()
report["host"] = platform.node()
report["deployment_data"] = dict(
git=try_git_describe(),
ZULIP_VERSION=ZULIP_VERSION,
)
if record.exc_info:
stack_trace = "".join(
traceback.format_exception(*record.exc_info))
message = str(record.exc_info[1])
else:
stack_trace = "No stack trace available"
message = record.getMessage()
if "\n" in message:
# Some exception code paths in queue processors
# seem to result in super-long messages
stack_trace = message
message = message.split("\n")[0]
report["stack_trace"] = stack_trace
report["message"] = message
report["logger_name"] = record.name
report["log_module"] = find_log_caller_module(record)
report["log_lineno"] = record.lineno
if isinstance(record, HasRequest):
add_request_metadata(report, record.request)
except Exception:
report["message"] = "Exception in preparing exception report!"
logging.warning(report["message"], exc_info=True)
report["stack_trace"] = "See /var/log/zulip/errors.log"
capture_exception()
if settings.DEBUG_ERROR_REPORTING: # nocoverage
logging.warning("Reporting an error to admins...")
logging.warning(
"Reporting an error to admins: %s %s %s %s %s",
record.levelname,
report["logger_name"],
report["log_module"],
report["message"],
report["stack_trace"],
)
try:
queue_json_publish(
"error_reports",
dict(
type="server",
report=report,
),
)
except Exception:
# If this breaks, complain loudly but don't pass the traceback up the stream
# However, we *don't* want to use logging.exception since that could trigger a loop.
logging.warning("Reporting an exception triggered an exception!",
exc_info=True)
capture_exception()
def filter(self, record: logging.LogRecord):
msg = record.getMessage()
return self._filter.match(msg) is not None
def record():
return LogRecord("foo", "INFO", "foo", 10, "waagh :(", (), None)
def filter(self, record: LogRecord):
record.function = self.function or ""
return True
def formatMessage(self, Record: logging.LogRecord) -> None:
lvl: str = Record.levelname
wanted_color: str = self.colors.get(lvl, self.default_color)
Record.levelname = f"{wanted_color}{lvl}{self.default_color}"
return self._style.format(Record)
def format(self, record: logging.LogRecord) -> str:
levelname = record.levelname
if levelname in self.COLORS:
record.levelname = self._to(self.COLORS[levelname], levelname)
return logging.Formatter.format(self, record)
def _formatTime(self, record: logging.LogRecord) -> None:
if self.usesTime():
record.asctime = self.formatTime(record, self.datefmt)
def filter(self, record: logging.LogRecord) -> bool:
"""Hide sensitive data in messages."""
record.msg = record.msg.replace(self.text, '*******')
return True
def filter(self, record: logging.LogRecord) -> bool:
for skip in self.skips:
if record.getMessage().startswith(skip):
return False
return True
def emit(self, record: logging.LogRecord) -> None:
"""Send a log message."""
self.slack.chat_postMessage(channel=self.channel,
text=record.getMessage())
def emit(self, record: logging.LogRecord) -> None:
report = {} # type: Dict[str, Any]
# This parameter determines whether Zulip should attempt to
# send Zulip messages containing the error report. If there's
# syntax that makes the markdown processor throw an exception,
# we really don't want to send that syntax into a new Zulip
# message in exception handler (that's the stuff of which
# recursive exception loops are made).
#
# We initialize is_bugdown_rendering_exception to `True` to
# prevent the infinite loop of zulip messages by ERROR_BOT if
# the outer try block here throws an exception before we have
# a chance to check the exception for whether it comes from
# bugdown.
is_bugdown_rendering_exception = True
try:
report['node'] = platform.node()
report['host'] = platform.node()
add_deployment_metadata(report)
if record.exc_info:
stack_trace = ''.join(traceback.format_exception(*record.exc_info))
message = str(record.exc_info[1])
from zerver.lib.exceptions import BugdownRenderingException
is_bugdown_rendering_exception = record.msg.startswith('Exception in Markdown parser')
else:
stack_trace = 'No stack trace available'
message = record.getMessage()
if '\n' in message:
# Some exception code paths in queue processors
# seem to result in super-long messages
stack_trace = message
message = message.split('\n')[0]
is_bugdown_rendering_exception = False
report['stack_trace'] = stack_trace
report['message'] = message
report['logger_name'] = record.name
report['log_module'] = find_log_caller_module(record)
report['log_lineno'] = record.lineno
if hasattr(record, "request"):
add_request_metadata(report, record.request) # type: ignore # record.request is added dynamically
except Exception:
report['message'] = "Exception in preparing exception report!"
logging.warning(report['message'], exc_info=True)
report['stack_trace'] = "See /var/log/zulip/errors.log"
if settings.DEBUG_ERROR_REPORTING: # nocoverage
logging.warning("Reporting an error to admins...")
logging.warning("Reporting an error to admins: {} {} {} {} {}" .format(
record.levelname, report['logger_name'], report['log_module'],
report['message'], report['stack_trace']))
try:
if settings.STAGING_ERROR_NOTIFICATIONS:
# On staging, process the report directly so it can happen inside this
# try/except to prevent looping
from zerver.lib.error_notify import notify_server_error
notify_server_error(report, is_bugdown_rendering_exception)
else:
queue_json_publish('error_reports', dict(
type = "server",
report = report,
))
except Exception:
# If this breaks, complain loudly but don't pass the traceback up the stream
# However, we *don't* want to use logging.exception since that could trigger a loop.
logging.warning("Reporting an exception triggered an exception!", exc_info=True)
def filter_(record: logging.LogRecord) -> bool:
record.processName = process_name
return True
def filter(self, record: logging.LogRecord) -> bool:
# NOTE: space is important after `GET /`, else all logs will be disabled.
return record.getMessage().find("GET / ") == -1
def emit(self, record: logging.LogRecord):
dispatcher = self.dispatchers.get(record.levelno, self.vim.echom)
dispatcher(record.getMessage())
def filter(self, record: logging.LogRecord):
for attr in self._remove:
if hasattr(record, attr):
record.__delattr__(attr)
return True
def filter(self, record: logging.LogRecord) -> bool:
record.time_filter = datetime.datetime.utcnow().strftime(
"%Y-%m-%d %H:%M:%S.%f")
return True
def filter(record: logging.LogRecord) -> bool:
"""Removes exception stack traces information."""
record.exc_info = None
record.exc_text = None # type: ignore
return True
def _format_line(record: logging.LogRecord, msg: str) -> str:
record = copy(record)
record.msg = msg
record.args = ()
return _super_format(record)
def format(self, record: logging.LogRecord) -> str:
"""
:param record:
:return:
"""
"""
Attribute name Format Description
args You shouldn’t need to format this yourself. The tuple of arguments merged into msg to produce message, or a dict whose values are used for the merge (when there is only one argument, and it is a dictionary).
asctime %(asctime)s Human-readable time when the LogRecord was created. By default this is of the form ‘2003-07-08 16:49:45,896’ (the numbers after the comma are millisecond portion of the time).
created %(created)f Time when the LogRecord was created (as returned by time.time()).
exc_info You shouldn’t need to format this yourself. Exception tuple (à la sys.exc_info) or, if no exception has occurred, None.
filename %(filename)s Filename portion of pathname.
funcName %(funcName)s Name of function containing the logging call.
levelname %(levelname)s Text logging level for the message ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL').
levelno %(levelno)s Numeric logging level for the message (DEBUG, INFO, WARNING, ERROR, CRITICAL).
lineno %(lineno)d Source line number where the logging call was issued (if available).
module %(module)s Module (name portion of filename).
msecs %(msecs)d Millisecond portion of the time when the LogRecord was created.
message %(message)s The logged message, computed as msg % args. This is set when Formatter.format() is invoked.
msg You shouldn’t need to format this yourself. The format string passed in the original logging call. Merged with args to produce message, or an arbitrary object (see Using arbitrary objects as messages).
name %(name)s Name of the config_logger used to log the call.
pathname %(pathname)s Full pathname of the source file where the logging call was issued (if available).
process %(process)d Process ID (if available).
processName %(processName)s Process name (if available).
relativeCreated %(relativeCreated)d Time in milliseconds when the LogRecord was created, relative to the time the logging module was loaded.
stack_info You shouldn’t need to format this yourself. Stack frame information (where available) from the bottom of the stack in the current thread, up to and including the stack frame of the logging call which resulted in the creation of this record.
thread %(thread)d Thread ID (if available).
threadName %(threadName)s Thread name (if available).
[service.randomtrailers.backend:DiscoverTmdbMovies:process_page]
[service.randomtrailers.backend:FolderMovieData:add_to_discovered_trailers TRACE_DISCOVERY]
"""
# threadName Constants.CURRENT_ADDON_SHORT_NAME funcName:lineno
# [threadName name funcName:lineno]
text = ''
try:
start_file = record.__dict__.get('start_file', None)
try:
pathname, lineno, func = start_file
except ValueError:
pathname, lineno, func = "(unknown file)", 0, "(unknown function)"
record.pathname = pathname
try:
record.filename = os.path.basename(pathname)
record.module = os.path.splitext(record.filename)[0]
except (TypeError, ValueError, AttributeError):
record.filename = pathname
record.module = "Unknown module"
record.lineno = lineno
record.funcName = func
suffix = super().format(record)
passed_traces = record.__dict__.get('trace_string', None)
if passed_traces is None:
if type(self).INCLUDE_THREAD_INFO:
prefix = '[Thread {!s} {!s}.{!s}:{!s}:{!s}]'.format(
record.threadName, record.name, record.funcName,
record.lineno, record.levelname)
else:
prefix = '[{!s}.{!s}:{!s}]'.format(record.name,
record.funcName,
record.lineno)
else:
if type(self).INCLUDE_THREAD_INFO:
prefix = '[Thread {!s} {!s}.{!s}:{!s}:{!s} Trace:{!s}]'.format(
record.threadName, record.name, record.funcName,
record.lineno, record.levelname, passed_traces)
else:
prefix = '[{!s}.{!s}:{!s}:{!s} Trace:{!s}]'.format(
record.name, record.funcName, record.lineno,
record.levelname, passed_traces)
text = '{} {}'.format(prefix, suffix)
except Exception as e:
pass
return text
