def create_logger(config, args):
try:
# config file
fh_loglevel = config.get('global', 'file_loglevel')
cli_loglevel = config.get('global', 'cli_loglevel')
rotateLog = config.get('global', 'rotateLog')
if args.check:
logname = config.get('global', 'logpath') + '_check'
else:
logname = config.get('global', 'logpath')
except:
# default
logname = "/var/log/default_fanilog"
fh_loglevel = "DEBUG"
cli_loglevel = "DEBUG"
rotateLog = "d"
logger = logging.getLogger("fanicontrol")
logger.setLevel(logging.DEBUG)
fmt = logging.Formatter(
'%(asctime)s | %(levelname)s | %(funcName)s | %(message)s',
"%m-%d %H:%M:%S")
if fh_loglevel != "None":
fh = TimedRotatingFileHandler(
logname, when=rotateLog, interval=1, backupCount=3)
fh.setLevel(fh_loglevel)
fh.setFormatter(fmt)
logger.addHandler(fh)
if cli_loglevel != "None":
cli = logging.StreamHandler()
cli.setLevel(cli_loglevel)
cli.setFormatter(fmt)
logger.addHandler(cli)
logger.info(sys.version)
return logger
python类TimedRotatingFileHandler()的实例源码
def __init__(self, name):
log_file_path = './log/matrix/'
if os.path.isdir(log_file_path):
pass
else:
os.makedirs(log_file_path)
# ??????????????????????
# ????logger
self.__logger = logging.getLogger('mylogger')
self.__logger.setLevel(logging.DEBUG)
# ??????
log_fmt = '%(asctime)s\tFile \"%(filename)s\",line %(lineno)s\t%(levelname)s: %(message)s'
formatter = logging.Formatter(log_fmt)
# ??TimedRotatingFileHandler??
log_file_name = log_file_path + name + '.log'
log_file_handler = TimedRotatingFileHandler(filename=log_file_name, when="M", interval=3, backupCount=3)
# log_file_handler.suffix = "%Y-%m-%d_%H-%M.log"
log_file_handler.setFormatter(formatter)
logging.basicConfig(level=logging.DEBUG)
# ?logger??handler
self.__logger.addHandler(log_file_handler)
# ???????
self.__logger.info('???????.')
def setup_logger():
logger = logging.getLogger('UploadFarm')
log_level = LOGGING_LEVELS[os.environ.get('SDV_LOGGING_LEVEL', 'info')]
logger.setLevel(log_level)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)
if not os.path.isdir('logs'):
os.mkdir('logs')
log_file = 'logs/sdv.log'
file_handler = TimedRotatingFileHandler(log_file, when='midnight', interval=1)
file_handler.setLevel(log_level)
file_handler.suffix = "%Y%m%d"
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(name)s - %(message)s')
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)
logger.addHandler(console_handler)
logger.addHandler(file_handler)
return logger
def get_handler(debug=False, syslog=False, logfile=None, rotation_parameters=None):
"""get an apropriate handler according to given parameters"""
if os.environ.get('APYCOT_ROOT'):
handler = logging.StreamHandler(sys.stdout)
if debug:
handler = logging.StreamHandler()
elif logfile is None:
if syslog:
from logging import handlers
handler = handlers.SysLogHandler()
else:
handler = logging.StreamHandler()
else:
try:
if rotation_parameters is None:
if os.name == 'posix' and sys.version_info >= (2, 6):
from logging.handlers import WatchedFileHandler
handler = WatchedFileHandler(logfile)
else:
handler = logging.FileHandler(logfile)
else:
from logging.handlers import TimedRotatingFileHandler
handler = TimedRotatingFileHandler(
logfile, **rotation_parameters)
except IOError:
handler = logging.StreamHandler()
return handler
def init_logger(logger_name):
if logger_name not in Logger.manager.loggerDict:
logger1 = logging.getLogger(logger_name)
logger1.setLevel(logging.INFO) # ??????
# logger1.setLevel(logging.DEBUG) # ??????
df = '%Y-%m-%d %H:%M:%S'
format_str = '[%(asctime)s]: %(name)s %(levelname)s %(lineno)s %(message)s'
formatter = logging.Formatter(format_str, df)
# handler all
try:
handler1 = TimedRotatingFileHandler(logger_path + '/core/log/all.log', when='D', interval=1, backupCount=7)
except Exception:
handler1 = TimedRotatingFileHandler(logger_path + '/core/log/all.log', when='D', interval=1, backupCount=7)
handler1.setFormatter(formatter)
handler1.setLevel(logging.DEBUG)
logger1.addHandler(handler1)
# handler error
try:
handler2 = TimedRotatingFileHandler(logger_path + '/core/log/error.log', when='D', interval=1, backupCount=7)
except Exception:
handler2 = TimedRotatingFileHandler(logger_path + '/core/log/error.log', when='D', interval=1, backupCount=7)
handler2.setFormatter(formatter)
handler2.setLevel(logging.ERROR)
logger1.addHandler(handler2)
# console
console = logging.StreamHandler()
console.setLevel(logging.DEBUG)
# ????????
console.setFormatter(formatter)
# ?????console??handler???root logger
logger1.addHandler(console)
logger1 = logging.getLogger(logger_name)
return logger1
def get_handler(debug=False, syslog=False, logfile=None, rotation_parameters=None):
"""get an apropriate handler according to given parameters"""
if os.environ.get('APYCOT_ROOT'):
handler = logging.StreamHandler(sys.stdout)
if debug:
handler = logging.StreamHandler()
elif logfile is None:
if syslog:
from logging import handlers
handler = handlers.SysLogHandler()
else:
handler = logging.StreamHandler()
else:
try:
if rotation_parameters is None:
if os.name == 'posix' and sys.version_info >= (2, 6):
from logging.handlers import WatchedFileHandler
handler = WatchedFileHandler(logfile)
else:
handler = logging.FileHandler(logfile)
else:
from logging.handlers import TimedRotatingFileHandler
handler = TimedRotatingFileHandler(
logfile, **rotation_parameters)
except IOError:
handler = logging.StreamHandler()
return handler
def create_timed_rotating_log(path):
logFormatter = NsaFormatter()
logger.setLevel(logging.INFO) # See https://docs.python.org/2/library/logging.html#levels
handler = TimedRotatingFileHandler(LOG_FILE, # https://docs.python.org/2/library/logging.handlers.html#timedrotatingfilehandler
when="midnight",
interval=1,
backupCount=30)
handler.setFormatter(logFormatter)
handler.suffix = "%Y%m%d"
logger.addHandler(handler)
def init_logger(logger_name):
if logger_name not in Logger.manager.loggerDict:
logger1 = logging.getLogger(logger_name)
logger1.setLevel(logging.INFO) # ??????
# logger1.setLevel(logging.DEBUG) # ??????
df = '%Y-%m-%d %H:%M:%S'
format_str = '[%(asctime)s]: %(name)s %(levelname)s %(lineno)s %(message)s'
formatter = logging.Formatter(format_str, df)
# handler all
try:
handler1 = TimedRotatingFileHandler('/usr/web_wx/log/all.log', when='D', interval=1, backupCount=7)
except Exception:
handler1 = TimedRotatingFileHandler('F:\program\web_wx\core\log\/all.log', when='D', interval=1, backupCount=7)
handler1.setFormatter(formatter)
handler1.setLevel(logging.DEBUG)
logger1.addHandler(handler1)
# handler error
try:
handler2 = TimedRotatingFileHandler('/usr/web_wx/log/error.log', when='D', interval=1, backupCount=7)
except Exception:
handler2 = TimedRotatingFileHandler('F:\program\web_wx\core\log\error.log', when='D', interval=1, backupCount=7)
handler2.setFormatter(formatter)
handler2.setLevel(logging.ERROR)
logger1.addHandler(handler2)
# console
console = logging.StreamHandler()
console.setLevel(logging.DEBUG)
# ????????
console.setFormatter(formatter)
# ?????console??handler???root logger
logger1.addHandler(console)
logger1 = logging.getLogger(logger_name)
return logger1
def setup_fileLogger(self):
"""
Setup the file logger
"""
try:
self._filelogger = logging.getLogger('chatlogfile')
handler = TimedRotatingFileHandler(self._file_name, when=self._file_rotation_rate, encoding="UTF-8")
handler.setFormatter(logging.Formatter('%(asctime)s\t%(message)s', '%y-%m-%d %H:%M:%S'))
self._filelogger.addHandler(handler)
self._filelogger.setLevel(logging.INFO)
except Exception, e:
self._save2file = False
self.error("cannot setup file chat logger: disabling logging to file (%s)" % e, exc_info=e)
def get_handler(debug=False, syslog=False, logfile=None, rotation_parameters=None):
"""get an apropriate handler according to given parameters"""
if os.environ.get('APYCOT_ROOT'):
handler = logging.StreamHandler(sys.stdout)
if debug:
handler = logging.StreamHandler()
elif logfile is None:
if syslog:
from logging import handlers
handler = handlers.SysLogHandler()
else:
handler = logging.StreamHandler()
else:
try:
if rotation_parameters is None:
if os.name == 'posix' and sys.version_info >= (2, 6):
from logging.handlers import WatchedFileHandler
handler = WatchedFileHandler(logfile)
else:
handler = logging.FileHandler(logfile)
else:
from logging.handlers import TimedRotatingFileHandler
handler = TimedRotatingFileHandler(
logfile, **rotation_parameters)
except IOError:
handler = logging.StreamHandler()
return handler
def get_handler(debug=False, syslog=False, logfile=None, rotation_parameters=None):
"""get an apropriate handler according to given parameters"""
if os.environ.get('APYCOT_ROOT'):
handler = logging.StreamHandler(sys.stdout)
if debug:
handler = logging.StreamHandler()
elif logfile is None:
if syslog:
from logging import handlers
handler = handlers.SysLogHandler()
else:
handler = logging.StreamHandler()
else:
try:
if rotation_parameters is None:
if os.name == 'posix' and sys.version_info >= (2, 6):
from logging.handlers import WatchedFileHandler
handler = WatchedFileHandler(logfile)
else:
handler = logging.FileHandler(logfile)
else:
from logging.handlers import TimedRotatingFileHandler
handler = TimedRotatingFileHandler(
logfile, **rotation_parameters)
except IOError:
handler = logging.StreamHandler()
return handler
def create_logger(self):
exc_logfile = os.getenv('GAUGE_EXCEPTION_LOG', '/var/tmp/dashboard_exception.log')
logfile = os.getenv('GAUGE_LOG', '/var/tmp/dashboard.log')
# Setup logging
logger = logging.getLogger(__name__)
logger_handler = TimedRotatingFileHandler(logfile, when='midnight')
log_fmt = '%(asctime)s %(name)-6s %(levelname)-8s %(message)s'
date_fmt = '%b %d %H:%M:%S'
default_formatter = logging.Formatter(log_fmt, date_fmt)
logger_handler.setFormatter(default_formatter)
logger.addHandler(logger_handler)
logger.setLevel(logging.INFO)
logger.propagate = 0
# Set up separate logging for exceptions
exc_logger = logging.getLogger(self.exc_logname)
exc_logger_handler = logging.FileHandler(exc_logfile)
exc_logger_handler.setFormatter(
logging.Formatter(log_fmt, date_fmt))
exc_logger.addHandler(exc_logger_handler)
exc_logger.propagate = 1
exc_logger.setLevel(logging.ERROR)
return logger
def __init__(self, *args, **kwargs):
super(TimedRotatingFileHandler, self).__init__(*args, **kwargs)
self._version = 0
def init_logger_handler(logs_path,file_name):
log_dir = libs.mkdirs(logs_path)
filename = log_dir+file_name
filehandler = TimedRotatingFileHandler(filename=filename, when='D', interval=1, backupCount=0,)
"""
when ????????????
“S”: Seconds
“M”: Minutes
“H”: Hours
“D”: Days
“W”: Week day (0=Monday)
“midnight”: Roll over at midnight
interval ?????????when?????Logger??????????????????
???filename+suffix???????????????????????????????
????suffix????????when????
"""
filehandler.suffix = "%Y%m%d-%H%M.log"
filehandler.setFormatter(Formatter(
'[%(asctime)s] [%(filename)s:%(lineno)d] [tid:%(thread)d] %(levelname)s: %(message)s '
))
filehandler.setLevel(logging.INFO)
return filehandler
def configure_logging(app):
"""Add Rotating Handler to app."""
logfile = app.config.get('LOG_FILE')
handler = TimedRotatingFileHandler(
logfile,
when='h',
interval=24,
backupCount=30
)
formatter = logging.Formatter(
"%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
handler.setFormatter(formatter)
handler.setLevel(logging.INFO)
app.logger.addHandler(handler)
def init_logging_handler():
handler = TimedRotatingFileHandler(LC.LOGGING_LOCATION, when='MIDNIGHT')
formatter = logging.Formatter(LC.LOGGING_FORMAT)
handler.setFormatter(formatter)
logger = logging.getLogger()
logger.setLevel(LC.LOGGING_LEVEL)
logger.addHandler(handler)
return logger
def init_logger():
LEVELS = {'debug': logging.DEBUG,
'info': logging.INFO,
'warning': logging.WARNING,
'error': logging.ERROR,
'critical': logging.CRITICAL}
log_dir = os.path.join(app.config['LOG_PATH'])
log_file = os.path.join(app.config['LOG_PATH'], app.config['LOG_FILENAME'])
if not os.path.isdir(log_dir):
os.mkdir(log_dir)
log_level = LEVELS.get(app.config['LOG_LEVEL'].lower(), 'info')
rotate_handler = TimedRotatingFileHandler(log_file, "D", 1, 30)
rotate_handler.suffix = "%Y%m%d.log"
rotate_handler.setLevel(log_level)
stream_handler = logging.StreamHandler()
stream_handler.setLevel(log_level)
formatter = logging.Formatter('%(asctime)-10s %(levelname)s %(filename)s %(lineno)d %(process)d %(message)s')
rotate_handler.setFormatter(formatter)
stream_handler.setFormatter(formatter)
app.logger.addHandler(stream_handler)
app.logger.addHandler(rotate_handler)
app.logger.info('???????')
def init(self, *priv):
if not priv:
raise error.SnmpsimError('Bad log file params, need filename')
if sys.platform[:3] == 'win':
# fix possibly corrupted absolute windows path
if len(priv[0]) == 1 and priv[0].isalpha() and len(priv) > 1:
priv = [priv[0] + ':' + priv[1]] + list(priv[2:])
maxsize = 0
maxage = None
if len(priv) > 1 and priv[1]:
localtime = time.localtime()
if priv[1][-1] in ('k', 'K'):
maxsize = int(priv[1][:-1]) * 1024
elif priv[1][-1] in ('m', 'M'):
maxsize = int(priv[1][:-1]) * 1024 * 1024
elif priv[1][-1] in ('g', 'G'):
maxsize = int(priv[1][:-1]) * 1024 * 1024 * 1024
elif priv[1][-1] in ('h', 'H'):
maxage = ('H', int(priv[1][:-1]))
elif priv[1][-1] in ('d', 'D'):
maxage = ('D', int(priv[1][:-1]))
else:
raise error.SnmpsimError(
'Unknown log rotation criteria %s, use <NNN>K,M,G for size or <NNN>H,D for time limits' % priv[1]
)
try:
if maxsize:
handler = handlers.RotatingFileHandler(priv[0], backupCount=30, maxBytes=maxsize)
elif maxage:
handler = handlers.TimedRotatingFileHandler(priv[0], backupCount=30, when=maxage[0], interval=maxage[1])
else:
handler = handlers.WatchedFileHandler(priv[0])
except AttributeError:
raise error.SnmpsimError(
'Bad log rotation criteria: %s' % sys.exc_info()[1]
)
handler.setFormatter(logging.Formatter('%(asctime)s %(name)s: %(message)s'))
self._logger.addHandler(handler)
self('Log file %s, rotation rules: %s' % (
priv[0], maxsize and '> %sKB' % (maxsize / 1024) or maxage and '%s%s' % (maxage[1], maxage[0]) or '<none>'))
def create_logger(): # pragma: no cover
"""
Create the logger for Alignak-App
"""
root_logger = getLogger()
stdout_handler = None
if root_logger.handlers:
stdout_handler = root_logger.handlers[0]
# Define path and file for "file_handler"
path = get_app_workdir()
filename = '%s.log' % get_app_config('Log', 'filename')
if not os.path.isdir(path):
# noinspection PyBroadException
try: # pragma: no cover - not testable
os.makedirs(path)
except Exception:
print('Can\'t create log file in [%s], App will log in current directory !' % path)
path = '.'
if not os.access(path, os.W_OK):
print('Access denied for [%s], App will log in current directory !' % path)
path = '.'
formatter = Formatter('[%(asctime)s]> %(name)-12s : [%(levelname)s] %(message)s')
# Create "file_handler"
file_handler = TimedRotatingFileHandler(
filename=os.path.join(path, filename),
when="D",
interval=1,
backupCount=6
)
file_handler.setLevel(DEBUG)
file_handler.setFormatter(formatter)
root_logger.addHandler(file_handler)
# Remove stdout handler to ensure logs are only in filehandler
root_logger.removeHandler(stdout_handler)
return root_logger
def __init__(self, *args, **kwargs):
super(Gauge, self).__init__(*args, **kwargs)
self.config_file = os.getenv(
'GAUGE_CONFIG', '/etc/ryu/faucet/gauge.conf')
self.exc_logfile = os.getenv(
'GAUGE_EXCEPTION_LOG', '/var/log/ryu/faucet/gauge_exception.log')
self.logfile = os.getenv('GAUGE_LOG', '/var/log/ryu/faucet/gauge.log')
# Setup logging
self.logger = logging.getLogger(__name__)
logger_handler = TimedRotatingFileHandler(
self.logfile,
when='midnight')
log_fmt = '%(asctime)s %(name)-6s %(levelname)-8s %(message)s'
date_fmt = '%b %d %H:%M:%S'
default_formatter = logging.Formatter(log_fmt, date_fmt)
logger_handler.setFormatter(default_formatter)
self.logger.addHandler(logger_handler)
self.logger.propagate = 0
# Set up separate logging for exceptions
exc_logger = logging.getLogger(self.exc_logname)
exc_logger_handler = logging.FileHandler(self.exc_logfile)
exc_logger_handler.setFormatter(
logging.Formatter(log_fmt, date_fmt))
exc_logger.addHandler(exc_logger_handler)
exc_logger.propagate = 1
exc_logger.setLevel(logging.ERROR)
self.dps = {}
with open(self.config_file, 'r') as config_file:
for dp_conf_file in config_file:
# config_file should be a list of faucet config filenames
# separated by linebreaks
dp = DP.parser(dp_conf_file.strip(), self.logname)
try:
dp.sanity_check()
except AssertionError:
self.logger.exception(
"Error in config file {0}".format(dp_conf_file))
else:
self.dps[dp.dp_id] = dp
# Create dpset object for querying Ryu's DPSet application
self.dpset = kwargs['dpset']
# dict of polling threads:
# polling threads are indexed by dp_id and then by name
# eg: self.pollers[0x1]['port_stats']
self.pollers = {}
# dict of async event handlers
self.handlers = {}
