def __update_handlers(self, level):
if "cli" not in [i.name
for i in self.logger.handlers] and level == self.CLI:
handler = RotatingFileHandler(self.cli_file,
maxBytes=self.max_log_size,
backupCount=self.backup_count)
handler.name = "cli"
handler.setLevel(self.CLI)
handler.setFormatter(self.formatter)
self.logger.addHandler(handler)
elif "primary" not in [i.name for i in self.logger.handlers]:
handler = RotatingFileHandler(self.primary_log_file,
maxBytes=self.max_log_size,
backupCount=self.backup_count)
handler.name = "primary"
handler.setFormatter(self.formatter)
handler.setLevel(logging.INFO)
self.logger.addHandler(handler)
def get_file_handler(settings):
file_size = int(settings['file_size']) * 1024 * 1024
file_number = int(settings['file_number'])
f_handler = RotatingFileHandler('logs/slick_monitor.log',
maxBytes=file_size,
backupCount=file_number)
f_handler.setLevel(settings['logging_level'])
f_handler.setFormatter(LOGGING_FORMAT)
f_handler.name = 'file_handler'
return f_handler
def init_logging(bot_name,
path=None,
level=logging.INFO,
encoding="gbk",
format_string=_FORMATTER,
**kwargs):
global _MAX_BYTES, _BACKUP_COUNT, _FILE_DELAY
if isinstance(level, str):
level = getattr(logging, level.upper())
if "maxBytes" in kwargs.keys():
_MAX_BYTES = kwargs["maxBytes"]
if "backupCount" in kwargs.keys():
_BACKUP_COUNT = kwargs["backupCount"]
if "delay" in kwargs.keys():
_FILE_DELAY = kwargs["delay"]
fn = "scrapy-{}.log".format(bot_name)
if path:
ph = join(path, fn)
else:
ph = fn
formatter = logging.Formatter(format_string)
ch = logging.StreamHandler(sys.stdout)
ch.name = "ext_ch"
ch.setFormatter(formatter)
fh = RotatingFileHandler(
filename=ph,
maxBytes=_MAX_BYTES,
backupCount=_BACKUP_COUNT,
encoding=encoding,
delay=_FILE_DELAY,
)
fh.name = "ext_fh"
fh.level = level
fh.setFormatter(formatter)
if fh.name not in [h.name for h in logging.getLogger("scrapy").handlers]:
logging.getLogger("scrapy").addHandler(fh)
def add_loggers(app):
log = app.web_app.logger
app.web_app.logger.removeHandler(default_handler)
if DEBUG:
level = logging.DEBUG
log.setLevel(level)
else:
level = log.getEffectiveLevel()
file_handler = RotatingFileHandler(LOG_PATH, maxBytes=10000, backupCount=1)
file_handler.name = 'file.log'
file_handler.setLevel(level)
file_handler.setFormatter(formatter)
console_handler = logging.StreamHandler()
console_handler.name = 'console.log'
console_handler.setLevel(level)
console_handler.setFormatter(formatter)
log.addHandler(file_handler)
log.addHandler(console_handler)
def get_wrapping_logger(name: str = None,
filename: str = None,
file_size: int = 5,
max_files: int = 2,
debug: bool = False,
log_level: int = logging.INFO,
**kwargs) -> Logger:
"""Sets up a wrapping logger that writes to console and optionally a file.
Logging is crucial for debugging embedded systems. However you don't want
to fill up an embedded drive with log files, so a *wrapping_logger* is
useful that:
* Initializes logging to console, and optionally a CSV formatted file
* Log file wraps at a given maximum size (default 5 MB)
* Is easy to configure a logging level (default INFO)
* Uses UTC/GMT/Zulu timestamps
* Provides a standardized CSV format
* ``timestamp,[level],(thread),module.function:line,message``
Args:
name: Name of the logger (if None, uses name of calling module).
filename: (optional) Name of the file/path if writing to a file.
file_size: Max size of the file in megabytes, before wrapping.
max_files: The maximum number of files in rotation.
debug: *backward compatible* enable DEBUG logging
log_level: A logging level (default INFO)
kwargs: Optional overrides for RotatingFileHandler
Returns:
A logger with console stream handler and (optional) file handler.
"""
FORMAT = ('%(asctime)s.%(msecs)03dZ,[%(levelname)s],(%(threadName)-10s),'
'%(module)s.%(funcName)s:%(lineno)d,%(message)s')
log_formatter = logging.Formatter(fmt=FORMAT, datefmt='%Y-%m-%dT%H:%M:%S')
log_formatter.converter = gmtime
if name is None:
name = get_caller_name()
logger = logging.getLogger(name)
if debug or logger.getEffectiveLevel() == logging.DEBUG:
log_lvl = logging.DEBUG
else:
log_lvl = log_level
logger.setLevel(log_lvl)
#: Set up log file
if filename is not None:
# TODO: validate that logfile is a valid path/filename
mode = 'a'
max_bytes = int(file_size * 1024 * 1024)
backup_count = max_files
encoding = None
delay = 0
for kw in kwargs:
if kw == 'backupCount':
backup_count = kwargs[kw]
elif kw == 'delay':
delay = kwargs[kw]
elif kw == 'encoding':
encoding = kwargs[kw]
elif kw == 'mode':
mode = kwargs[kw]
elif kw == 'maxBytes':
max_bytes = kwargs[kw]
file_handler = RotatingFileHandler(filename=filename,
mode=mode,
maxBytes=max_bytes,
backupCount=backup_count,
encoding=encoding,
delay=delay)
file_handler.name = name + '_file_handler'
file_handler.setFormatter(log_formatter)
file_handler.setLevel(log_lvl)
if not is_log_handler(logger, file_handler):
logger.addHandler(file_handler)
#: Set up console log
console_handler = logging.StreamHandler()
console_handler.name = name + '_console_handler'
console_handler.setFormatter(log_formatter)
console_handler.setLevel(log_lvl)
if not is_log_handler(logger, console_handler):
logger.addHandler(console_handler)
return logger
