Example of a Python change log (logging) storage location

Implemented a simple version of the Logging.config, support the general configuration through the config file.
There is a better way to feel, and it is to use the Logging.config.fileConfig (Log_config_file) method to read it and modify it by modifying the handler mode.

The code is as follows:

"""
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 have 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 was 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's other attributes could is 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

The code is as follows:

[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

