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