forked from iarv/meshing-around
99 lines
3.6 KiB
Python
99 lines
3.6 KiB
Python
import logging
|
|
from logging.handlers import TimedRotatingFileHandler
|
|
import modules.settings as my_settings
|
|
# if LOGGING_LEVEL is not set in settings.py, default to DEBUG
|
|
if not my_settings.LOGGING_LEVEL:
|
|
my_settings.LOGGING_LEVEL = "DEBUG"
|
|
|
|
LOGGING_LEVEL = getattr(logging, my_settings.LOGGING_LEVEL)
|
|
|
|
class CustomFormatter(logging.Formatter):
|
|
grey = '\x1b[38;21m'
|
|
white = '\x1b[38;5;231m'
|
|
blue = '\x1b[38;5;39m'
|
|
yellow = '\x1b[38;5;226m'
|
|
red = '\x1b[38;5;196m'
|
|
green = '\x1b[38;5;46m'
|
|
purple = '\x1b[38;5;129m'
|
|
bold_red = '\x1b[31;1m'
|
|
bold_white = '\x1b[37;1m'
|
|
reset = '\x1b[0m'
|
|
|
|
def __init__(self, fmt):
|
|
super().__init__()
|
|
self.fmt = fmt
|
|
self.FORMATS = {
|
|
logging.DEBUG: self.blue + self.fmt + self.reset,
|
|
logging.INFO: self.white + self.fmt + self.reset,
|
|
logging.WARNING: self.yellow + self.fmt + self.reset,
|
|
logging.ERROR: self.red + self.fmt + self.reset,
|
|
logging.CRITICAL: self.bold_red + self.fmt + self.reset
|
|
}
|
|
|
|
def format(self, record):
|
|
log_fmt = self.FORMATS.get(record.levelno)
|
|
formatter = logging.Formatter(log_fmt)
|
|
return formatter.format(record)
|
|
|
|
class plainFormatter(logging.Formatter):
|
|
ansi_codes = [
|
|
'\x1b[38;21m', '\x1b[38;5;231m', '\x1b[38;5;39m', '\x1b[38;5;226m',
|
|
'\x1b[38;5;196m', '\x1b[38;5;46m', '\x1b[38;5;129m', '\x1b[31;1m',
|
|
'\x1b[37;1m', '\x1b[0m'
|
|
]
|
|
|
|
def format(self, record):
|
|
message = super().format(record)
|
|
for code in self.ansi_codes:
|
|
message = message.replace(code, '')
|
|
return message
|
|
|
|
# Create logger
|
|
logger = logging.getLogger("MeshBot System Logger")
|
|
logger.setLevel(LOGGING_LEVEL)
|
|
logger.propagate = False
|
|
|
|
msgLogger = logging.getLogger("MeshBot Messages Logger")
|
|
msgLogger.setLevel(logging.INFO)
|
|
msgLogger.propagate = False
|
|
|
|
# Define format for logs
|
|
logFormat = '%(asctime)s | %(levelname)8s | %(message)s'
|
|
msgLogFormat = '%(asctime)s | %(message)s'
|
|
|
|
# Create stdout handler for logging to the console
|
|
stdout_handler = logging.StreamHandler()
|
|
# Set level for stdout handler (logs DEBUG level and above)
|
|
stdout_handler.setLevel(LOGGING_LEVEL)
|
|
# Set format for stdout handler
|
|
stdout_handler.setFormatter(CustomFormatter(logFormat))
|
|
# Add handlers to the logger
|
|
logger.addHandler(stdout_handler)
|
|
|
|
if my_settings.syslog_to_file:
|
|
# Create file handler for logging to a file
|
|
file_handler_sys = TimedRotatingFileHandler('logs/meshbot.log', when='midnight', backupCount=my_settings.log_backup_count, encoding='utf-8')
|
|
file_handler_sys.setLevel(LOGGING_LEVEL) # DEBUG used by default for system logs to disk
|
|
file_handler_sys.setFormatter(plainFormatter(logFormat))
|
|
logger.addHandler(file_handler_sys)
|
|
|
|
if my_settings.log_messages_to_file:
|
|
# Create file handler for logging to a file
|
|
file_handler = TimedRotatingFileHandler('logs/messages.log', when='midnight', backupCount=my_settings.log_backup_count, encoding='utf-8')
|
|
file_handler.setLevel(logging.INFO) # INFO used for messages to disk
|
|
file_handler.setFormatter(logging.Formatter(msgLogFormat))
|
|
msgLogger.addHandler(file_handler)
|
|
|
|
# Pretty Timestamp
|
|
def getPrettyTime(seconds):
|
|
# convert unix time to minutes, hours, days, or years for simple display
|
|
if seconds < 60:
|
|
return f"{int(seconds)}s"
|
|
elif seconds < 3600:
|
|
return f"{int(round(seconds / 60))}m"
|
|
elif seconds < 86400:
|
|
return f"{int(round(seconds / 3600))}h"
|
|
elif seconds < 31536000:
|
|
return f"{int(round(seconds / 86400))}d"
|
|
else:
|
|
return f"{int(round(seconds / 31536000))}y" |