def setup_custom_logger(name):
handler = logging.StreamHandler()
handler.setFormatter(colorlog.LevelFormatter(
fmt={
'DEBUG': '{log_color}[{levelname}:{module}] {message}',
'INFO': '{log_color}{message}',
'WARNING': '{log_color}{levelname}: {message}',
'ERROR': '{log_color}[{levelname}:{module}] {message}',
'CRITICAL': '{log_color}[{levelname}:{module}] {message}',
},
datefmt=None,
reset=True,
log_colors={
'DEBUG': 'cyan',
'INFO': 'white',
'WARNING': 'yellow',
'ERROR': 'red',
'CRITICAL': 'bold_red,bg_white',
},
secondary_log_colors={},
style='{'))
logger = logging.getLogger(name)
# Change to INFO
logger.setLevel(logging.DEBUG)
logger.addHandler(handler)
return logger
def init():
if len(logging.getLogger("").handlers) > 1:
return
shandler = logging.StreamHandler(stream=sys.stdout)
shandler.setFormatter(colorlog.LevelFormatter(
fmt = {
"DEBUG": "{log_color}[{levelname}] {message}",
"INFO": "{log_color}[{levelname}] {message}",
"WARNING": "{log_color}[{levelname}] {message}",
"ERROR": "{log_color}[{levelname}] {message}",
"CRITICAL": "{log_color}[{levelname}] {message}"
},
log_colors = {
"DEBUG": "cyan",
"INFO": "white",
"WARNING": "yellow",
"ERROR": "red",
"CRITICAL": "bold_red"
},
style = "{",
datefmt = ""
))
shandler.setLevel(logging.DEBUG)
logging.getLogger(__package__).addHandler(shandler)
logging.getLogger(__package__).setLevel(logging.DEBUG)
def get_logger (name=None, verbose=False, quiet=False):
"""Multilevel colored log using colorlog"""
# Define conditional color formatter
formatter = colorlog.LevelFormatter(
fmt = {
'DEBUG':'%(log_color)s\t[DEBUG]: %(msg)s',
'INFO': '%(log_color)s\t%(msg)s',
'WARNING': '%(log_color)s## %(msg)s ##',
'ERROR': '%(log_color)sERROR: %(msg)s',
'CRITICAL': '%(log_color)sCRITICAL: %(msg)s'},
log_colors={
'DEBUG': 'white',
'INFO': 'green',
'WARNING': 'bold_blue',
'ERROR': 'bold_red',
'CRITICAL': 'bold_purple'},
reset=True)
# Define logger with custom formatter
logging.basicConfig(format='%(message)s')
logging.getLogger().handlers[0].setFormatter(formatter)
logger = logging.getLogger(name)
# Define logging level depending on verbosity
if verbose:
logger.setLevel(logging.DEBUG)
elif quiet:
logger.setLevel(logging.WARNING)
else:
logger.setLevel(logging.INFO)
return logger
def setup_logger(logger_name: str):
"""
Setting up logging.
"""
formatter = colorlog.LevelFormatter(
fmt={
"DEBUG": "{log_color}[{asctime}] [{name}] [{levelname}] {message}",
"INFO": "{log_color}[{asctime}] [{name}] [{levelname}] {message}",
"WARNING": "{log_color}[{asctime}] [{name}] [{levelname}] {message}",
"ERROR": "{log_color}[{asctime}] [{name}] [{levelname}] {message}",
"CRITICAL": "{log_color}[{asctime}] [{name}] [{levelname}] {message}",
},
log_colors={
"DEBUG": "cyan",
"INFO": "white",
"WARNING": "yellow",
"ERROR": "red",
"CRITICAL": "bold_red"
},
style="{",
datefmt="%Y-%m-%d %H:%M:%S"
)
logger = logging.getLogger(logger_name)
logger.level = logging.INFO
# Set the root logger level, too.
logging.root.setLevel(logger.level)
handler = logging.StreamHandler()
handler.setFormatter(formatter)
logger.addHandler(handler)
return logger
def logger_setup():
# Formats for colorlog.LevelFormatter
log_level_formats = {
'DEBUG': '%(log_color)s%(msg)s (%(module)s:%(lineno)d)',
'INFO': '%(log_color)s%(msg)s',
'WARNING': '%(log_color)sWARNING: %(msg)s (%(module)s:%(lineno)d)',
'ERROR': '%(log_color)sERROR: %(msg)s (%(module)s:%(lineno)d)',
'CRITICAL': '%(log_color)sCRITICAL: %(msg)s (%(module)s:%(lineno)d)',
}
log_colors = {
'DEBUG': 'blue',
'INFO': 'cyan',
'WARNING': 'bold_yellow',
'ERROR': 'red',
'CRITICAL': 'red,bg_white'
}
# Initialize logger that can be used
user_name = getpass.getuser()
logger = logging.getLogger('elektronn3log')
# Only set up the logger if it hasn't already been initialised before:
if not len(logger.handlers) > 0:
logger.setLevel(logging.DEBUG)
lfile_formatter = logging.Formatter(
'[%(asctime)s] [%(levelname)s]\t%(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
uu = uuid.uuid4()
# Temporary log file path, to be changed later.
if os.path.isdir(f'/ptmp/{user_name}'):
lfile_path = os.path.abspath(
f'/ptmp/{user_name}/{uu}_elektronn3.log')
else:
lfile_path = os.path.abspath(
f'/tmp/{user_name}_{uu}_elektronn3.log')
lfile_level = logging.DEBUG
lfile_handler = logging.FileHandler(lfile_path)
lfile_handler.setLevel(lfile_level)
lfile_handler.setFormatter(lfile_formatter)
logger.addHandler(lfile_handler)
lstream_handler = colorlog.StreamHandler(sys.stdout)
lstream_handler.setFormatter(
colorlog.LevelFormatter(fmt=log_level_formats,
log_colors=log_colors))
# set this to logging.DEBUG to enable output for logger.debug() calls
lstream_level = logging.INFO
lstream_handler.setLevel(lstream_level)
logger.addHandler(lstream_handler)
logger.propagate = False
if False: # Test log levels:
logger.critical('== critical')
logger.error('== error')
logger.warning('== warn')
logger.info('== info')
logger.debug('== debug')
def _setup_logging(self):
if len(logging.getLogger(__package__).handlers) >= 1:
LOG.debug("Skipping logger setup, already setup")
return
shandler = logging.StreamHandler(stream=sys.stdout)
shandler.setFormatter(
colorlog.LevelFormatter(fmt={
'DEBUG':
'{log_color}[{levelname}:{module}] {message}',
'INFO':
'{log_color}{message}',
'WARNING':
'{log_color}{levelname}: {message}',
'ERROR':
'{log_color}[{levelname}:{module}] {message}',
'CRITICAL':
'{log_color}[{levelname}:{module}] {message}',
'EVERYTHING':
'{log_color}[{levelname}:{module}] {message}',
'NOISY':
'{log_color}[{levelname}:{module}] {message}',
'VOICEDEBUG':
'{log_color}[{levelname}:{module}][{relativeCreated:.9f}] {message}',
'FFMPEG':
'{log_color}[{levelname}:{module}][{relativeCreated:.9f}] {message}'
},
log_colors={
'DEBUG': 'cyan',
'INFO': 'white',
'WARNING': 'yellow',
'ERROR': 'red',
'CRITICAL': 'bold_red',
'EVERYTHING': 'white',
'NOISY': 'white',
'FFMPEG': 'bold_purple',
'VOICEDEBUG': 'purple',
},
style='{',
datefmt=''))
logging.getLogger(__package__).setLevel(logging.DEBUG)
shandler.setLevel(self.config.debug_level)
fh = logging.FileHandler(filename='logs/kanobot.log',
encoding='utf-8',
mode='w')
fh.setLevel(self.config.debug_level)
logging.getLogger(__package__).addHandler(fh)
logging.getLogger(__package__).addHandler(shandler)
LOG.debug("Set logging level to %s", self.config.debug_level_str)
if self.config.debug_mode:
dlogger = logging.getLogger('discord')
dlogger.setLevel(logging.DEBUG)
dhandler = logging.FileHandler(filename='logs/discord.log',
encoding='utf-8',
mode='w')
dhandler.setFormatter(
logging.Formatter('{asctime}:{levelname}:{name}: {message}',
style='{'))
dlogger.addHandler(dhandler)
def setup_logging(level=logging.INFO):
from tqdm import tqdm
def is_console_handler(handler):
return isinstance(handler,
logging.StreamHandler) and handler.stream in {
sys.stdout, sys.stderr
}
class TqdmLoggingHandler(logging.StreamHandler):
def emit(self, record):
try:
msg = self.format(record)
tqdm.write(msg)
self.flush()
except (KeyboardInterrupt, SystemExit):
raise
except: # noqa pylint: disable=bare-except
self.handleError(record)
logging.basicConfig(stream=sys.stdout, level=level)
handler = TqdmLoggingHandler(sys.stdout)
try:
import colorlog
formatter = colorlog.LevelFormatter(fmt={
'DEBUG':
'%(log_color)sdebug: %(message)s (%(module)s:%(lineno)d)%(reset)s',
'INFO':
'%(log_color)sinfo%(reset)s: %(message)s',
'WARNING':
'%(log_color)swarning%(reset)s: %(message)s (%(module)s:%(lineno)d)',
'ERROR':
'%(log_color)serror%(reset)s: %(message)s (%(module)s:%(lineno)d)',
'CRITICAL':
'%(log_color)scritical: %(message)s (%(module)s:%(lineno)d)%(reset)s',
},
log_colors={
'DEBUG': 'white',
'INFO': 'bold_green',
'WARNING': 'bold_yellow',
'ERROR': 'bold_red',
'CRITICAL': 'bold_red',
})
handler.setFormatter(formatter)
except (ModuleNotFoundError):
# We do not require colorlog to be present
pass
logging._acquireLock()
orig_handlers = logging.root.handlers
try:
logging.root.handlers = [
x for x in orig_handlers if not is_console_handler(x)
] + [handler]
except Exception:
logging.root.handlers = orig_handlers
finally:
logging._releaseLock()
def _setup_logging(self):
if len(logging.getLogger(__package__).handlers) > 1:
log.debug("Skip logging setup, already complete")
return
shandler = logging.StreamHandler(stream=sys.stdout)
shandler.setFormatter(
colorlog.LevelFormatter(fmt={
"DEBUG":
"{log_color}[{levelname}:{module}] {message}",
"INFO":
"{log_color}{message}",
"WARNING":
"{log_color}{levelname}: {message}",
"ERROR":
"{log_color}[{levelname}:{module}] {message}",
"CRITICAL":
"{log_color}[{levelname}:{module}] {message}"
},
log_colors={
"DEBUG": "cyan",
"INFO": "white",
"WARNING": "yellow",
"ERROR": "red",
"CRITICAL": "bold_red"
},
style='{',
datefmt=''))
log.setLevel(self.config.debug_level)
shandler.setLevel(self.config.debug_level)
logging.getLogger(__package__).addHandler(shandler)
log.debug("Set logging level to {0}".format(self.config.debug_level))
if self.config.debug_mode:
dlogger = logging.getLogger("discord")
dlogger.setLevel(logging.DEBUG)
os.makedirs("logs", mode=0o644, exist_ok=True)
dhandler = logging.FileHandler(filename="logs/discord.log",
encoding="utf-8",
mode='w')
dhandler.setFormatter(
logging.Formatter("{asctime}:{levelname}:{name}: {message}",
style='{'))
dlogger.addHandler(dhandler)
def get_logger(name=None, verbose=False, quiet=False):
"""Multilevel colored log using colorlog"""
# Define conditional color formatter
formatter = colorlog.LevelFormatter(
fmt={
"DEBUG": "%(log_color)s\t[DEBUG]: %(msg)s",
"INFO": "%(log_color)s\t%(msg)s",
"WARNING": "%(log_color)s## %(msg)s ##",
"ERROR": "%(log_color)sERROR: %(msg)s",
"CRITICAL": "%(log_color)sCRITICAL: %(msg)s",
},
log_colors={
"DEBUG": "white",
"INFO": "green",
"WARNING": "bold_blue",
"ERROR": "bold_red",
"CRITICAL": "bold_purple",
},
reset=True,
)
# Define logger with custom formatter
logging.basicConfig(format="%(message)s")
logging.getLogger().handlers[0].setFormatter(formatter)
log = logging.getLogger(name)
# Define logging level depending on verbosity
if verbose:
log.setLevel(logging.DEBUG)
elif quiet:
log.setLevel(logging.WARNING)
else:
log.setLevel(logging.INFO)
return log
logger.setLevel(logging.DEBUG)
lfile_formatter = logging.Formatter(
'[%(asctime)s] [%(levelname)s]\t%(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
lfile_path = os.path.abspath('/tmp/elektronn2-%s.log' % user_name)
lfile_level = logging.DEBUG
lfile_handler = logging.FileHandler(lfile_path)
lfile_handler.setLevel(lfile_level)
lfile_handler.setFormatter(lfile_formatter)
logger.addHandler(lfile_handler)
if colorize:
lstream_handler = colorlog.StreamHandler()
lstream_handler.setFormatter(
colorlog.LevelFormatter(fmt=log_level_formats,
log_colors=log_colors))
else:
lstream_handler = logging.StreamHandler() # log to stderr
# set this to logging.DEBUG to enable output for logger.debug() calls
lstream_level = logging.INFO
lstream_handler.setLevel(lstream_level)
logger.addHandler(lstream_handler)
logger.propagate = False
if False: # Test log levels:
logger.critical('== critical')
logger.error('== error')
logger.warning('== warn')
logger.info('== info')
logger.debug('== debug')
log.setLevel(logging.DEBUG)
sh = logging.StreamHandler(stream=sys.stdout)
sh.setFormatter(
colorlog.LevelFormatter(fmt={
'DEBUG':
'{log_color}[{levelname}:{module}:{name}] {message}',
'INFO':
'{log_color}[{levelname}:{module}:{name}] {message}',
'WARNING':
'{log_color}[{levelname}:{module}:{name}] {message}',
'ERROR':
'{log_color}[{levelname}:{module}:{name}] {message}',
'CRITICAL':
'{log_color}[{levelname}:{module}:{name}] {message}',
'EVERYTHING':
'{log_color}[{levelname}:{module}:{name}] {message}',
'NOISY':
'{log_color}[{levelname}:{module}:{name}] {message}'
},
log_colors={
'DEBUG': 'cyan',
'INFO': 'white',
'WARNING': 'yellow',
'ERROR': 'red',
'CRITICAL': 'bold_red',
'EVERYTHING': 'white',
'NOISY': 'white'
},
style='{'))
log.addHandler(sh)
logger.addHandler(sh)
fh.setFormatter(
logging.Formatter(
"[{asctime}] {levelname} ({filename} L{lineno}, {funcName}): {message}",
style='{'))
sh = logging.StreamHandler(stream=sys.stdout)
sh.setFormatter(
colorlog.LevelFormatter(fmt={
"DEBUG":
"{log_color}{levelname} ({module} L{lineno}, {funcName}): {message}",
"INFO":
"{log_color}{message}",
"WARNING":
"{log_color}{levelname}: {message}",
"ERROR":
"{log_color}{levelname} ({module} L{lineno}, {funcName}): {message}",
"CRITICAL":
"{log_color}{levelname} ({module} L{lineno}, {funcName}): {message}"
},
log_colors={
"DEBUG": "purple",
"INFO": "white",
"WARNING": "yellow",
"ERROR": "red",
"CRITICAL": "bold_red"
},
style='{'))
sh.setLevel(logging.DEBUG)
logger.addHandler(fh)
logger.addHandler(sh)
"%(cyan)s[%(asctime)s] %(log_color)s[%(levelname)s]%(reset)s %(message)s")
CUSTOM_FMT = "%(log_color)s[%(asctime)s] [%(levelname)s] %(message)s"
FORMATTER = colorlog.LevelFormatter(fmt={
"DEBUG": PRIMARY_FMT,
"INFO": PRIMARY_FMT,
"WARNING": PRIMARY_FMT,
"ERROR": PRIMARY_FMT,
"CRITICAL": PRIMARY_FMT,
"*": CUSTOM_FMT,
"+": CUSTOM_FMT,
"-": CUSTOM_FMT,
"!": CUSTOM_FMT
},
datefmt="%H:%M:%S",
log_colors={
'*': 'cyan',
'+': 'green',
'-': 'red',
'!': 'yellow',
'DEBUG': 'blue',
'INFO': 'green',
'WARNING': 'yellow',
'ERROR': 'red',
'CRITICAL': 'bg_red,white'
},
secondary_log_colors={},
style='%')
disableColor = "disable-col" in ' '.join(sys.argv)
if disableColor:
