105 lines
4.3 KiB
Python
105 lines
4.3 KiB
Python
import logging
|
|
import inspect
|
|
|
|
class IndentFormatter(logging.Formatter):
|
|
"""
|
|
A custom logging formatter that adds indentation based on the call stack depth
|
|
and includes the function name in the log record.
|
|
Attributes:
|
|
baseline (int): The baseline stack depth when the formatter is initialized.
|
|
Methods:
|
|
__init__(fmt=None, datefmt=None):
|
|
Initializes the IndentFormatter with optional format and date format.
|
|
format(rec):
|
|
Formats the specified record as text, adding indentation and function name.
|
|
"""
|
|
grey = "\x1b[38;20m"
|
|
yellow = "\x1b[33;20m"
|
|
red = "\x1b[31;20m"
|
|
bold_red = "\x1b[31;1m"
|
|
reset = "\x1b[0m"
|
|
format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
|
|
|
|
FORMATS = {
|
|
logging.DEBUG: grey + format + reset,
|
|
logging.INFO: grey + format + reset,
|
|
logging.WARNING: yellow + format + reset,
|
|
logging.ERROR: red + format + reset,
|
|
logging.CRITICAL: bold_red + format + reset
|
|
}
|
|
|
|
|
|
def __init__( self, fmt=None, datefmt=None ):
|
|
"""
|
|
Initializes the CustomLogger instance.
|
|
Args:
|
|
fmt (str, optional): The format string for the log messages. Defaults to None.
|
|
datefmt (str, optional): The format string for the date in log messages. Defaults to None.
|
|
Attributes:
|
|
baseline (int): The baseline stack depth when the logger is initialized.
|
|
"""
|
|
logging.Formatter.__init__(self, fmt, datefmt)
|
|
self.baseline = len(inspect.stack())
|
|
|
|
def format( self, rec ):
|
|
"""
|
|
Formats the log record by adding indentation and function name.
|
|
This method customizes the log record by adding an indentation level
|
|
based on the current stack depth and includes the name of the function
|
|
from which the log call was made. It then uses the base Formatter class
|
|
to format the record and returns the formatted string.
|
|
Args:
|
|
rec (logging.LogRecord): The log record to be formatted.
|
|
Returns:
|
|
str: The formatted log record string.
|
|
"""
|
|
log_fmt = self.FORMATS.get(rec.levelno)
|
|
formatter = logging.Formatter(log_fmt)
|
|
|
|
stack = inspect.stack()
|
|
rec.indent = ' '*(len(stack)-self.baseline-3)
|
|
rec.function = stack[8][3]
|
|
out = logging.Formatter.format(self, rec)
|
|
del rec.indent; del rec.function
|
|
return out
|
|
|
|
class MessageProcessorFilter(logging.Filter):
|
|
def filter(self, record):
|
|
# Suppress INFO level messages from MessageProcessor.py
|
|
if record.levelno == logging.INFO and record.pathname.endswith("MessageProcessor.py"):
|
|
return False
|
|
return True
|
|
|
|
# The following code sets up a custom logger with indentation support.
|
|
# It creates a custom formatter, a logger instance, and a stream handler.
|
|
# The custom formatter is set to the handler, which is then added to the logger.
|
|
# Finally, the logging level is set to INFO.
|
|
|
|
formatter = IndentFormatter("%(asctime)s - (%(filename)30s:%(lineno)-3d) - [%(levelname)-7s]: %(indent)s%(message)s ")
|
|
logger = logging.getLogger('logger')
|
|
handler = logging.StreamHandler()
|
|
handler.setFormatter(formatter)
|
|
logger.addHandler(handler)
|
|
logger.setLevel(logging.INFO)
|
|
|
|
def setDebugMode():
|
|
"""
|
|
Set the logging level to DEBUG and log a message indicating that debug mode is enabled.
|
|
This function sets the logging level of the logger to DEBUG, which means that all messages
|
|
at the DEBUG level and above will be logged. It also logs a debug message to indicate that
|
|
debug mode has been activated.
|
|
"""
|
|
logger.setLevel(logging.DEBUG)
|
|
logger.debug("Debug mode is on...")
|
|
|
|
def setSilent():
|
|
"""
|
|
Sets the logger to silent mode, where only messages at the ERROR level or higher are displayed.
|
|
If the current logging level is not 'DEBUG', this function will log an informational message
|
|
indicating that silent mode is being activated and then set the logging level to ERROR.
|
|
"""
|
|
if logger.level != logging.DEBUG:
|
|
logger.info("Silent Mode is turning on, only Messages at Level ERROR or higher are displayed")
|
|
#logger.setLevel(logging.ERROR)
|
|
# Add the filter to suppress INFO level messages from MessageProcessor.py
|
|
logger.addFilter(MessageProcessorFilter()) |