Due to several limitations of the standard library’s logging module, I wrote my own.
Below are the most important parts. You can find the whole library here.
Any feedback is welcome.
# fancylog - A library for human readable logging. # # Copyright (C) 2017 HOMEINFO - Digitale Informationssysteme GmbH # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. """A library for beautiful, readble logging.""" from datetime import datetime from enum import Enum from sys import stdout, stderr from threading import Thread from time import sleep from traceback import format_exc from blessings import Terminal __all__ = [ 'logging', 'LogLevel', 'LogEntry', 'Logger', 'TTYAnimation', 'LoggingClass'] TERMINAL = Terminal() def logging(name=None, level=None, parent=None, file=None): """Decorator to attach a logger to the respective class.""" def wrap(obj): """Attaches the logger to the respective class.""" logger_name = obj.__name__ if name is None else name obj.logger = Logger(logger_name, level=level, parent=parent, file=file) return obj return wrap class LogLevel(Enum): """Logging levels.""" DEBUG = (10, '🔧', TERMINAL.bold) SUCCESS = (20, '✓', TERMINAL.green) INFO = (30, 'ℹ', TERMINAL.blue) WARNING = (70, '⚠', TERMINAL.yellow) ERROR = (80, '✗', TERMINAL.red) CRITICAL = (90, '☢', lambda string: TERMINAL.bold(TERMINAL.red(string))) FAILURE = (100, '☠', lambda string: TERMINAL.bold(TERMINAL.magenta( string))) def __init__(self, ident, symbol, format_): """Sets the identifier, symbol and color.""" self.ident = ident self.symbol = symbol self.format = format_ def __int__(self): """Returns the identifier.""" return self.ident def __str__(self): """Returns the colored symbol.""" return self.format(self.symbol) def __eq__(self, other): try: return int(self) == int(other) except TypeError: return NotImplemented def __gt__(self, other): try: return int(self) > int(other) except TypeError: return NotImplemented def __ge__(self, other): return self > other or self == other def __lt__(self, other): try: return int(self) < int(other) except TypeError: return NotImplemented def __le__(self, other): return self < other or self == other def __hash__(self): return hash((self.__class__, self.ident)) @property def erroneous(self): """A log level is considered erroneous if it's identifier > 50.""" return self.ident > 50 class LogEntry(Exception): """A log entry.""" def __init__(self, *messages, level=LogLevel.ERROR, sep=None, color=None): """Sets the log level and the respective message(s).""" super().__init__() self.messages = messages self.level = level self.sep = ' ' if sep is None else sep self.color = color self.timestamp = datetime.now() def __hash__(self): """Returns a unique hash.""" return hash(self._hash_tuple) @property def _hash_tuple(self): """Returns the tuple from which to create a unique hash.""" return (self.__class__, self.level, self.messages, self.timestamp) @property def message(self): """Returns the message elements joint by the selected separator.""" return self.sep.join(str(message) for message in self.messages) @property def text(self): """Returns the formatted message text.""" if self.color is not None: return self.color(self.message) return self.message class Logger: """A logger that can be nested.""" CHILD_SEP = '→' def __init__(self, name, level=None, parent=None, file=None): """Sets the logger's name, log level, parent logger, log entry template and file. """ self.name = name self.level = level or LogLevel.INFO self.parent = parent self.file = file self.template = '{1.level} {0}: {1.text}' def __str__(self): """Returns the logger's nested path as a string.""" return self.CHILD_SEP.join(logger.name for logger in self.path) def __hash__(self): """Returns a unique hash.""" return hash(self.__class__, self.name) def __enter__(self): """Returns itself.""" return self def __exit__(self, _, value, __): """Logs risen log entries.""" if isinstance(value, LogEntry): self.log_entry(value) return True return None @property def root(self): """Determines whether the logger is at the root level.""" return self.parent is None @property def path(self): """Yields the logger's path.""" if not self.root: yield from self.parent.path yield self @property def layer(self): """Returns the layer of the logger.""" return 0 if self.root else self.parent.layer + 1 def log_entry(self, log_entry): """Logs a log entry.""" if log_entry.level >= self.level: if self.file is None: file = stderr if log_entry.level.erroneous else stdout else: file = self.file print(self.template.format(self, log_entry), file=file, flush=True) return log_entry def inherit(self, name, level=None, file=None): """Returns a new child of this logger.""" level = self.level if level is None else level file = self.file if file is None else file return self.__class__(name, level=level, parent=self, file=file) def log(self, level, *messages, sep=None, color=None): """Logs messages of a certain log level.""" log_entry = LogEntry(*messages, level=level, sep=sep, color=color) return self.log_entry(log_entry) def debug(self, *messages, sep=None, color=None): """Logs debug messages, defaulting to a stack trace.""" if not messages: messages = ('Stacktrace:', format_exc()) if sep is None: sep = '\n' return self.log(LogLevel.DEBUG, *messages, sep=sep, color=color) def success(self, *messages, sep=None, color=None): """Logs success messages.""" return self.log(LogLevel.SUCCESS, *messages, sep=sep, color=color) def info(self, *messages, sep=None, color=None): """Logs info messages.""" return self.log(LogLevel.INFO, *messages, sep=sep, color=color) def warning(self, *messages, sep=None, color=None): """Logs warning messages.""" return self.log(LogLevel.WARNING, *messages, sep=sep, color=color) def error(self, *messages, sep=None, color=None): """Logs error messages.""" return self.log(LogLevel.ERROR, *messages, sep=sep, color=color) def critical(self, *messages, sep=None, color=None): """Logs critical messages.""" return self.log(LogLevel.CRITICAL, *messages, sep=sep, color=color) def failure(self, *messages, sep=None, color=None): """Logs failure messages.""" return self.log(LogLevel.FAILURE, *messages, sep=sep, color=color) 
