感觉还有更好的方法，是直接利用logging.config.fileconfig(log_config_file)方式读进来之后，通过修改handler方式来进行修改。
代码如下:
project trace system
import sys
import configparser
import logging
import logging.config
import warnings
if __name__ == __main__:
log_config_file = log.conf
log_data_file = logs/run.log
level_dic = {
debug: logging.debug,
info: logging.info,
warning: logging.warning,
error: logging.error,
critical: logging.critical
}
class logconfig(object):
def __init__(self, log_config_file, log_data_file=none):
self.log_config_file = log_config_file
self.log_data_file = log_data_file # for self app
self.log_config = configparser.rawconfigparser()
self.log_config.read(self.log_config_file)
self.logger_prefix = logger_
self.handler_prefix = handler_
self.formatter_prefix = formatter_
self._check_section()
self._parse_option()
def _check_section(self):
# check logger
self.__check_logger()
# check handler
self.__check_handler()
# check formatter
self.__check_formatter()
def _parse_option(self):
# parse formatter option
for formatter, formatter_info in self.formatters.items():
section_name = formatter_info[section_name]
f = self.log_config.get(section_name, format)
datefmt = self.log_config.get(section_name, datefmt)
self.formatters[formatter][value] = logging.formatter(f, datefmt)
# parse handlers
for handler, handler_info in self.handlers.items():
section_name = handler_info[section_name]
handler_class = self.log_config.get(section_name, class)
handler_str = self.log_config.get(section_name, args)
handler_args = eval(self.log_config.get(section_name, args))
level = self.log_config.get(section_name, level)
formatter = self.log_config.get(section_name, formatter)
_handler = eval(logging.+handler_class)
# only filehandler has file path paramter.
if isinstance(_handler, logging.filehandler):
if self.log_data_file:
handler_args[0] = self.log_data_file
else:
warnings.warn(filehandler found, but log data file is not specified)
self.handlers[handler][value] = _handler(*handler_args)
self.handlers[handler][value].setlevel(
level_dic.get(level.upper(), level_dic[info]))
self.handlers[handler][value].setformatter(
self.formatters[formatter][value])
# parse logger
for logger, logger_info in self.loggers.items():
section_name = logger_info[section_name]
self.__parse_logger(logger, section_name)
def __parse_logger(self, logger_name, section_name):
tuple_items = self.log_config.items(section_name)
logger = logging.getlogger(logger_name)
for k, v in tuple_items:
if k == handlers:
handlers = filter(none, [h.strip() for h in v.split(,)])
for h in handlers:
logger.addhandler(self.handlers[h][value])
if k == level:
logger.setlevel(level_dic.get(v, level_dic[info]))
if k == propagate and v:
logger.propagate = int(v)
# here other attributes could be added. todo
self.loggers[logger_name]['value'] = logger
def __check_logger(self):
_loggers = self.log_config.get(loggers, keys).split(,)
self.loggers = {}
for logger in _loggers:
logger = logger.strip()
if logger:
logger_section_name = self.logger_prefix + logger
if not self.log_config.has_section(logger_section_name):
raise exception(
error: no logger section name: {0}.format(logger_section_name))
self.loggers.setdefault(logger, {})
self.loggers[logger][section_name] = logger_section_name
if not self.loggers:
raise exception(
error: no logger keys in {0}.format(self.log_config_file))
def __check_handler(self):
_handlers = self.log_config.get(handlers, keys).split(,)
self.handlers = {}
for handler in _handlers:
handler = handler.strip()
if handler:
handler_section_name = self.handler_prefix + handler
if not self.log_config.has_section(handler_section_name):
raise exception(error: no handler section name: {0}.format(handler_section_name))
self.handlers.setdefault(handler , {})
self.handlers[handler][section_name] = handler_section_name
if not self.handlers:
raise exception(error: no handler keys in {0}.format(self.log_config_file))
def __check_formatter(self):
_formatters = self.log_config.get(formatters, keys).split(,)
self.formatters = {}
for formatter in _formatters:
formatter = formatter.strip()
if formatter:
formatter_section_name = self.formatter_prefix + formatter
if not self.log_config.has_section(formatter_section_name):
raise exception(error: no formatter section name: {0}.format(formatter_section_name))
self.formatters.setdefault(formatter, {})
self.formatters[formatter][section_name] = formatter_section_name
if not self.formatters:
raise exception(error: no formatter keys in {0}.format(self.log_config_file))
def getlogger(self, logger_name=root):
return self.loggers[logger_name]['value']
class trace(object):
def __init__(self, log_config_file, log_key=root, log_data_file=none):
self.log_config_file = log_config_file
self.log_data_file = log_data_file
self.log_key = log_key
log = logconfig(self.log_config_file, self.log_data_file)
self.logger = log.getlogger(self.log_key)
def info(self, key, info):
self.logger.info([{0}]: {1}.format(key, info))
def error(self, key, err_info):
self.logger.error([{0}]: {1}.format(key, err_info))
def warn(self, key, warn_info):
self.logger.warn([{0}]: {1}.format(key, warn_info))
def test():
log_key = root
t = trace(log_config_file, log_key, log_data_file)
t.info(test trace, ok)
if __name__ == __main__:
test()
log.conf
代码如下:
[loggers]
keys = root, debug
[handlers]
keys=consolehandler, timedrotatingfilehandler
[formatters]
keys=simpleformatter
[logger_root]
level=debug
handlers=consolehandler, timedrotatingfilehandler
[logger_debug]
level=debug
handlers=consolehandler
propagate=0
[handler_consolehandler]
class=streamhandler
level=debug
formatter=simpleformatter
args=(sys.stdout,)
[handler_timedrotatingfilehandler]
class=handlers.timedrotatingfilehandler
level=debug
formatter=simpleformatter
args=(./run.log, 'midnight', 1, 10)
[formatter_simpleformatter]
format=[%(asctime)s][%(levelname)s][%(process)d:%(thread)d][%(filename)s:%(lineno)d]:%(message)s
datefmt=%y-%m-%d %h:%m:%s