Coverage for qutebrowser/utils/log.py: 68%

430 ↛ 431line 430 didn't jump to line 431, because the condition on line 430 was never true if any(msg.strip().startswith(pattern) for pattern in suppressed_msgs):

level = logging.DEBUG

else:

level = qt_to_logging[msg_type]

435 ↛ 437line 435 didn't jump to line 437, because the condition on line 435 was never false if context.function is None:

func = 'none'

elif ':' in context.function:

func = '"{}"'.format(context.function)

else:

func = context.function

442 ↛ 445line 442 didn't jump to line 445, because the condition on line 442 was never false if context.category is None or context.category == 'default':

name = 'qt'

else:

name = 'qt-' + context.category

446 ↛ 450line 446 didn't jump to line 450, because the condition on line 446 was never true if msg.splitlines()[0] == ('This application failed to start because it '

'could not find or load the Qt platform plugin '

'"xcb".'):

# Handle this message specially.

msg += ("\n\nOn Archlinux, this should fix the problem:\n"

" pacman -S libxkbcommon-x11")

faulthandler.disable()

454 ↛ 457line 454 didn't jump to line 457, because the condition on line 454 was never false if _args.debug:

stack = ''.join(traceback.format_stack())

else:

stack = None

record = qt.makeRecord(name, level, context.file, context.line, msg, None,

None, func, sinfo=stack)

qt.handle(record)

@contextlib.contextmanager

def hide_qt_warning(pattern, logger='qt'):

"""Hide Qt warnings matching the given regex."""

log_filter = QtWarningFilter(pattern)

logger_obj = logging.getLogger(logger)

logger_obj.addFilter(log_filter)

try:

yield

finally:

logger_obj.removeFilter(log_filter)

class QtWarningFilter(logging.Filter):

"""Filter to filter Qt warnings.

Attributes:

_pattern: The start of the message.

"""

def __init__(self, pattern):

super().__init__()

self._pattern = pattern

def filter(self, record):

"""Determine if the specified record is to be logged."""

do_log = not record.msg.strip().startswith(self._pattern)

return do_log

class LogFilter(logging.Filter):

"""Filter to filter log records based on the commandline argument.

The default Filter only supports one name to show - we support a

comma-separated list instead.

Attributes:

_names: A list of names that should be logged.

"""

def __init__(self, names):

super().__init__()

self.names = names

def filter(self, record):

"""Determine if the specified record is to be logged."""

if self.names is None:

return True

if record.levelno > logging.DEBUG:

# More important than DEBUG, so we won't filter at all

return True

for name in self.names:

if record.name == name:

return True

elif not record.name.startswith(name):

continue

elif record.name[len(name)] == '.':

return True

return False

class RAMHandler(logging.Handler):

"""Logging handler which keeps the messages in a deque in RAM.

Loosely based on logging.BufferingHandler which is unsuitable because it

uses a simple list rather than a deque.

Attributes:

_data: A deque containing the logging records.

"""

def __init__(self, capacity):

super().__init__()

self.html_formatter = None

539 ↛ 542line 539 didn't jump to line 542, because the condition on line 539 was never false if capacity != -1:

self._data = collections.deque(maxlen=capacity)

else:

self._data = collections.deque()

def emit(self, record):

545 ↛ exitline 545 didn't return from function 'emit', because the condition on line 545 was never false if record.levelno >= logging.DEBUG:

# We don't log VDEBUG to RAM.

self._data.append(record)

def dump_log(self, html=False, level='vdebug'):

"""Dump the complete formatted log data as string.

FIXME: We should do all the HTML formatter via jinja2.

(probably obsolete when moving to a widget for logging,

https://github.com/qutebrowser/qutebrowser/issues/34

"""

minlevel = LOG_LEVELS.get(level.upper(), VDEBUG_LEVEL)

lines = []

fmt = self.html_formatter.format if html else self.format

self.acquire()

try:

records = list(self._data)

finally:

self.release()

for record in records:

565 ↛ 564line 565 didn't jump to line 564, because the condition on line 565 was never false if record.levelno >= minlevel:

lines.append(fmt(record))

return '\n'.join(lines)

def change_log_capacity(self, capacity):

self._data = collections.deque(self._data, maxlen=capacity)

class ColoredFormatter(logging.Formatter):

"""Logging formatter to output colored logs.

Attributes:

use_colors: Whether to do colored logging or not.

"""

def __init__(self, fmt, datefmt, style, *, use_colors):

super().__init__(fmt, datefmt, style)

self.use_colors = use_colors

def format(self, record):

if self.use_colors:

color_dict = dict(COLOR_ESCAPES)

color_dict['reset'] = RESET_ESCAPE

log_color = LOG_COLORS[record.levelname]

color_dict['log_color'] = COLOR_ESCAPES[log_color]

else:

color_dict = {color: '' for color in COLOR_ESCAPES}

color_dict['reset'] = ''

color_dict['log_color'] = ''

record.__dict__.update(color_dict)

return super().format(record)

class HTMLFormatter(logging.Formatter):

"""Formatter for HTML-colored log messages.

Attributes:

_log_colors: The colors to use for logging levels.

_colordict: The colordict passed to the logger.

"""

def __init__(self, fmt, datefmt, log_colors):

"""Constructor.

Args:

fmt: The format string to use.

datefmt: The date format to use.

log_colors: The colors to use for logging levels.

"""

super().__init__(fmt, datefmt)

self._log_colors = log_colors

self._colordict = {}

# We could solve this nicer by using CSS, but for this simple case this

# works.

for color in COLORS:

self._colordict[color] = '<font color="{}">'.format(color)

self._colordict['reset'] = '</font>'

def format(self, record):

record.__dict__.update(self._colordict)

if record.levelname in self._log_colors:

color = self._log_colors[record.levelname]

record.log_color = self._colordict[color]

else:

record.log_color = ''

for field in ['msg', 'filename', 'funcName', 'levelname', 'module',

'name', 'pathname', 'processName', 'threadName']:

data = str(getattr(record, field))

setattr(record, field, pyhtml.escape(data))

msg = super().format(record)

if not msg.endswith(self._colordict['reset']):

msg += self._colordict['reset']

return msg

def formatTime(self, record, datefmt=None):

out = super().formatTime(record, datefmt)

return pyhtml.escape(out)

class JSONFormatter(logging.Formatter):

"""Formatter for JSON-encoded log messages."""

def format(self, record):

obj = {}

for field in ['created', 'msecs', 'levelname', 'name', 'module',

'funcName', 'lineno', 'levelno']:

obj[field] = getattr(record, field)

obj['message'] = record.getMessage()

if record.exc_info is not None:

obj['traceback'] = super().formatException(record.exc_info)

return json.dumps(obj)

Coverage for qutebrowser/utils/log.py : 68%

290 statements 212 run 78 missing 3 excluded 17 partial