def timed_rotating_file_handler(cls, filename, when='h', interval=1, backup=0):
handler = TimedRotatingFileHandler(filename, when, interval, backup)
handler.suffix = "%Y-%m-%d_%H_%M_%S.log"
handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}_-\d{2}-\d{2}-\d{2}.log$")
handler.setLevel(logging.DEBUG)
handler.setFormatter(cls.formatter())
return handler
def init_logger(log_name="main"):
"""初始化日志
https://stackoverflow.com/questions/22807972/python-best-practice-in-terms-of-logging
https://fangpenlin.com/posts/2012/08/26/good-logging-practice-in-python/
http://python.jobbole.com/86887/ 日志重复输出？
"""
log_file = '%s/main' % (conf.LOG_ROOT)
log_level = conf.log_level
log_obj = logging.getLogger(__name__)
log_obj.setLevel(log_level)
#避免日志重复打印
if log_obj.handlers:
return log_obj
# log_obj.removeHandler(log_file_handler)
log_format = '%(asctime)s %(levelname)s %(filename)s %(lineno)d %(message)s'
formatter = logging.Formatter(log_format)
## 日志天级分割
log_file_handler = TimedRotatingFileHandler(
filename=log_file, when="midnight", interval=1, backupCount=20)
log_file_handler.suffix = "%Y%m%d.log"
log_file_handler.extMatch = re.compile(r"^\d{8}.log$")
log_file_handler.setFormatter(formatter)
log_obj.addHandler(log_file_handler)
return log_obj
def create_multiprocess_logger(logger_name, persist_logger_name, log_level, log_format, log_queue, log_file_path,
when_to_rotate, keep_log_days, log_suffix=None):
"""
Creates queue logger and persist logger.
Queue logger should be used to log into. It is Thread and Process safe.
Persist logger is logger which persist data to disk. LogCollector moves data from queue log into persist log.
"""
queue_log_formatter = logging.Formatter(log_format)
queue_log_handler = QueueHandler(log_queue, persist_logger_name)
queue_log_handler.setFormatter(queue_log_formatter)
queue_logger = logging.getLogger(logger_name)
queue_logger.setLevel(log_level)
queue_logger.handlers = []
queue_logger.addHandler(queue_log_handler)
queue_logger.propagate = False
persist_log_formatter = logging.Formatter('%(message)s')
persist_log_handler = TimedRotatingFileHandler(log_file_path, when=when_to_rotate, interval=1, backupCount=keep_log_days)
if log_suffix is not None:
persist_log_handler.suffix = log_suffix
persist_log_handler.setFormatter(queue_log_formatter)
persist_logger = logging.getLogger(persist_logger_name)
persist_logger.setLevel(log_level)
persist_logger.handlers = []
persist_logger.addHandler(persist_log_handler)
persist_logger.propagate = False
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
db.init_app(app)
from .mainpage import mainpage as main_blueprint
app.register_blueprint(main_blueprint)
from .user import user as user_blueprint
app.register_blueprint(user_blueprint,url_prefix='/user')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint,url_prefix='/admin')
from .api import api as api_blueprint
app.register_blueprint(api_blueprint,url_prefix='/api')
formatter = logging.Formatter('%(name)-12s %(asctime)s level-%(levelname)-8s thread-%(thread)-8d %(message)s') # 每行日志的前缀设
fileTimeHandler = TimedRotatingFileHandler("logmessage", "M", 5, 0)
fileTimeHandler.suffix = "%Y%m%d.log" #设置切分后日志文件名的时间格式 默认 filename+"." + suffix 如果需要更改需要改logging 源码
fileTimeHandler.setFormatter(formatter)
fileTimeHandler.setLevel(logging.INFO)
app.logger.addHandler(fileTimeHandler)
return app
def create_logger(self):
"""
创建一个日志对象logger，同时打印文件日志和终端日志，其中Debug级别的日志只在终端打印
:param spidername
:return: logger object
"""
LOG_FILE = os.path.join(os.path.dirname(os.path.dirname(__file__)),
"logs", "{}.log".format(date.today()))
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(filename)s[line:%(lineno)d] - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S') # 格式化日志
file_handler = TimedRotatingFileHandler(LOG_FILE,'D', 1, 0) # 实例化handler
file_handler.suffix = "{}-%Y-%m-%d.log".format(self.config.Name)
file_handler.setFormatter(formatter)
file_handler.setLevel(logging.INFO) # 设置文件日志打印级别
console_handler = logging.StreamHandler() # 设置终端日志打印
console_handler.setLevel(logging.DEBUG) # 设置终端日志打印级别
console_handler.setFormatter(formatter) # 设置终端日志打印格式
logger = logging.getLogger(self.config.Name) # 获取名为log_name的logger
logger.addHandler(file_handler) # 添加Handler
logger.addHandler(console_handler) # 添加Handler
logger.setLevel(logging.INFO) # 设置日志级别为DEBUG(级别最低)
return logger
def init_logging(logger, set_level = logging.INFO,
console = True,
log_file_path = None):
logger.setLevel(logging.DEBUG)
logger.propagate = False # it's parent will not print log (especially when client use a 'root' logger)
for h in logger.handlers:
logger.removeHandler(h)
if console:
fh = logging.StreamHandler()
fh.setLevel(set_level)
formatter = logging.ColorFormatter("%(asctime)-15s [%(threadName)s] [%(levelname)s] %(message)s")
fh.setFormatter(formatter)
logger.addHandler(fh)
if log_file_path:
# by day
fh = TimedRotatingFileHandler(log_file_path, backupCount=30, when='D')
fh.suffix = "%Y%m%d"
fh.extMatch = re.compile(r"^\d{4}\d{2}\d{2}$")
# by hour
#fh = TimedRotatingFileHandler(log_file_path, backupCount=24*7, when='H')
#fh.suffix = "%Y%m%d%H"
#fh.extMatch = re.compile(r"^\d{4}\d{2}\d{2}\d{2}$")
fh.setLevel(set_level)
formatter = logging.Formatter("%(asctime)-15s [%(threadName)s] [%(levelname)s] %(message)s")
fh.setFormatter(formatter)
logger.addHandler(fh)
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 __init__(self):
logging.basicConfig(level=logging.DEBUG)
self.logger = logging.getLogger('autoD')
FORMAT = "%(asctime)-15s %(message)s"
logFormatter = logging.Formatter(FORMAT)
logHandler = TimedRotatingFileHandler('autoD.log',when='midnight')
logHandler.suffix = '%Y%m%d'
logHandler.setFormatter(logFormatter)
self.logger.addHandler(logHandler)
def init_log():
LOG=logging.getLogger('psven')
LOG.setLevel(logging.INFO)
#console = logging.StreamHandler()
filer = TimedRotatingFileHandler('log/psven.log','midnight')
filer.suffix = "%Y-%m-%d"
#LOG.addHandler(console)
LOG.addHandler(filer)
return LOG
def get_rotating_file_handler(logger_path, log_level=LOG_LEVEL):
create_log_dir(logger_path)
rotating_file_handler = TimedRotatingFileHandler(logger_path,
when=LOG_INTERVAL_TYPE, interval=LOG_INTERVAL, backupCount=LOG_BACKUP_INCR)
rotating_file_handler.setFormatter(Formatter("[%(levelname)s] %(asctime)s - %(module)s.%(funcName)s:%(lineno)d - %(message)s",
"%Y-%m-%d %H:%M:%S"))
rotating_file_handler.setLevel(log_level)
rotating_file_handler.suffix = "%Y-%m-%d" #_%H:%M:%S"
return rotating_file_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 enable_log():
logger = logging.getLogger('affinitic.db')
logpath = '/'.join([os.environ.get('CLIENT_HOME', '.'), 'sqlalchemy.log'])
fh = TimedRotatingFileHandler(logpath, 'midnight', 1)
formatter = logging.Formatter(" %(asctime)s \n %(message)s \n--")
fh.setFormatter(formatter)
fh.suffix = "%Y-%m-%d-%H-%M"
logger.addHandler(fh)
register_logging()
enable_sa_deprecation_warnings()
def configure_logging(app):
loggers = [app.logger]
for logger in loggers:
file_handler = TimedRotatingFileHandler("mark", when='S', interval=1, backupCount=40)
file_handler.suffix = "%Y%m%d.log"
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(formatter)
logger.setLevel(logging.DEBUG)
logger.addHandler(file_handler)
def init_logger():
global logger, log_name
logger = logging.getLogger(log_name)
logger.setLevel(logging.DEBUG)
# set rotate log files
file_handler = TimedRotatingFileHandler(file_name, 'S', 1, 3)
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
file_handler.suffix = "%Y-%m-%d_%H-%M-%S"
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
def _set_logger(self):
"""Set logging"""
self._logger = logging.getLogger(self.logger_name)
self._logger.setLevel(logging.DEBUG)
fh = TimedRotatingFileHandler(os.path.join(self.log_path, self.log_file),
'midnight', 1)
fh.suffix = "%Y-%m-%d-%H-%M"
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s '
'- %(message)s')
fh.setFormatter(formatter)
fh.setLevel(logging.DEBUG)
self._logger.addHandler(fh)
def start(self):
log_path = self.app.config.get('LOG_PATH')
if not log_path:
return
log_handler = TimedRotatingFileHandler(log_path, 'midnight', 1)
log_handler.setFormatter(self.format)
log_handler.setLevel(self.level)
log_handler.suffix = self.file_suffix
self.app.logger.addHandler(log_handler)
def get_logger(name, filename, fmt_str = '[%(levelname)s %(asctime)s @ %(process)d] - %(message)s'):
log = logging.getLogger(name)
formatter = logging.Formatter(fmt_str)
fileTimeHandler = TimedRotatingFileHandler(filename, "D", 1, 20)
fileTimeHandler.suffix = "%Y%m%d"
fileTimeHandler.setFormatter(formatter)
logging.basicConfig(level = logging.INFO)
log.handlers = []
log.addHandler(fileTimeHandler)
log.setLevel(logging.DEBUG)
return log
def create_logger():
"""Initial the global logger variable"""
global logger
formatter = logging.Formatter('%(asctime)s|%(levelname)s|%(message)s')
handler = TimedRotatingFileHandler(log_file, when="midnight", interval=1)
handler.setFormatter(formatter)
handler.setLevel(log_level)
handler.suffix = "%Y-%m-%d"
logger = logging.getLogger("sacplus")
logger.setLevel(log_level)
logger.addHandler(handler)
def setup_logging(filename):
global logger
formatter = logging.Formatter(LOG_FORMAT_WITH_PID)
logger = logging.getLogger("scheduler")
handler = TimedRotatingFileHandler(filename, "MIDNIGHT", backupCount=7)
handler.suffix = "%Y%m%d"
shd=logging.StreamHandler()
handler.setFormatter(formatter)
logger.addHandler(shd)
logger.addHandler(handler)
logger.setLevel(LOGGING_LEVEL)
db_handler = TimedRotatingFileHandler("{}.{}".format(filename, "mysql"), "MIDNIGHT", backupCount=7)
db_handler.suffix = "%Y%m%d"
db_handler.setLevel(SQL_CONN_LOGGING_LEVEL)
db_handler.setFormatter(formatter)
logging.basicConfig()
sql_logger = logging.getLogger('sqlalchemy')
#sql_logger.propagate = False
sql_logger.addHandler(db_handler)
sql_logger.setLevel(SQL_CONN_LOGGING_LEVEL)
return [handler.stream, db_handler.stream]
def set_logger2(filename):
log = logging.getLogger()
#formatter = logging.Formatter('%(name)-12s %(asctime)s level-%(levelname)-8s thread-%(thread)-8d %(message)s') # 每行日志的前缀设置
fmt_str = '[%(levelname)s %(asctime)s @ %(process)d] - %(message)s'
formatter = logging.Formatter(fmt_str)
fileTimeHandler = TimedRotatingFileHandler(filename, "D", 1, 20)
fileTimeHandler.suffix = "%Y%m%d" #设置 切分后日志文件名的时间格式 默认 filename+"." + suffix 如果需要更改需要改logging 源码
fileTimeHandler.setFormatter(formatter)
logging.basicConfig(level = logging.INFO)
log.handlers = []
log.addHandler(fileTimeHandler)
log.setLevel(logging.INFO)
def Log():
logFilePath = '/var/log/datacenter/datacenter.log'
log = logging.getLogger()
log.setLevel(logging.INFO)
handler = TimedRotatingFileHandler(logFilePath,
when="D",
interval=1,
backupCount=7)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.suffix = "%Y-%m-%d-%H:%M"
handler.setFormatter(formatter)
log.addHandler(handler)
return log
def __getTimeRotatingHandler(path, loggingLevel):
handler = TimedRotatingFileHandler(
path,
when='midnight',
interval=1,
backupCount=5)
formatter = logging.Formatter(
RollingFileLog.entryFormat,
RollingFileLog.dateTimeFormat)
handler.setFormatter(formatter)
handler.suffix = '%Y-%m-%d %H-%M-%S.log' # '%Y-%m-%d %H-%M-%S.log'
handler.setLevel(loggingLevel)
return handler
def SetLogger(logger, dirStr, logName):
if not os.path.exists(dirStr):
os.makedirs(dirStr)
logFileName = os.path.join(dirStr, logName)
logHandler = TimedRotatingFileHandler(logFileName, when="midnight")
logHandler.suffix = "%Y%m%d_%H%M%S.log"
logFormatter = logging.Formatter('%(asctime)-12s:%(message)s')
logHandler.setFormatter(logFormatter)
streamHandle = logging.StreamHandler()
streamHandle.setFormatter(logFormatter)
logger.addHandler(logHandler)
logger.addHandler(streamHandle)
logger.setLevel(logging.WARNING)
return logger
def __setFileHandler__(self,level = None):
file_name = os.path.join(LOG_PATH,'{name}.log'.format(name = self.name))
file_handler = TimedRotatingFileHandler(filename = file_name,when = 'D',interval = 1,backupCount = 7)
file_handler.suffix = '%Y%m%d.log'
if not level:
file_handler.setLevel(self.level)
else:
file_handler.setLevel(level)
formatter = logging.Formatter('%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s')
file_handler.setFormatter(formatter)
self.file_handler = file_handler
self.addHandler(file_handler)
def _configure_logging():
# System wide logging
logger = logging.getLogger()
log_fh = TimedRotatingFileHandler('logs/log', when='midnight', backupCount=30)
log_fh.suffix = '%Y_%m_%d'
formatter = logging.Formatter('[%(asctime)s] [%(levelname)8s] --- %(message)s (%(filename)s:%(lineno)s)"')
log_fh.setFormatter(formatter)
stderr_fh = logging.StreamHandler()
logger.addHandler(log_fh)
logger.addHandler(stderr_fh)
logger.setLevel(logging.DEBUG)
def set_logger(filename):
log = logging.getLogger()
fmt_str = '[%(levelname)s %(asctime)s @ %(process)d] (%(pathname)s/%(funcName)s:%(lineno)d) - %(message)s'
formatter = logging.Formatter(fmt_str)
fileTimeHandler = TimedRotatingFileHandler(filename, "D", 1, 20)
fileTimeHandler.suffix = "%Y%m%d"
fileTimeHandler.setFormatter(formatter)
logging.basicConfig(level = logging.INFO)
log.handlers = []
log.addHandler(fileTimeHandler)
if settings.DEBUG:
log.setLevel(logging.DEBUG)
else:
log.setLevel(logging.WARN)
def CreateLoggerScreenByMyHandlerConfig(loggerName, fileName, config_file_name, config_section_name):
cf = ConfigParser.ConfigParser()
cf.read(config_file_name)
level = cf.get(config_section_name, ITEM_LEVEL)
logger = logging.getLogger(loggerName)
logger.setLevel(MyLogLevel[level])
ch = logging.StreamHandler()
ch.setLevel(MyLogLevel[level])
fileTimeHandler = TimedRotatingFileHandler(fileName, when="midnight")
fileTimeHandler.suffix = "%Y%m%d.log"
formatter = logging.Formatter('%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s%(message)s')
ch.setFormatter(formatter)
fileTimeHandler.setFormatter(formatter)
logger.addHandler(ch)
logger.addHandler(fileTimeHandler)
def setup_logging(config, title):
level = getattr(logging, config.get('log', 'level'))
format = '%(asctime)s - %(levelname)s [{}] - %(message)s'.format(title)
try:
filename = config.get('log', 'filename')
handler = TimedRotatingFileHandler(filename, when='midnight', encoding='utf-8', interval=1)
if config.has_option('log', 'suffix'):
handler.suffix = config.get('log', 'suffix')
except ConfigParser.NoOptionError:
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter(format))
logger = logging.getLogger()
logger.addHandler(handler)
logger.setLevel(level)
def initLog():
dir = 'log'
if not os.path.exists(dir):
os.mkdir(dir)
path = dir + "/log"
handler = TimedRotatingFileHandler(path,
when="D",
interval=1,
backupCount=7)
# 设置后缀名称，跟strftime的格式一样
handler.suffix = "%Y%m%d-%H%M%S"
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
datefmt='%a, %d %b %Y %H:%M:%S',
handlers=(handler,),
)
def __new__(cls, *args, **kwds):
if cls not in cls._singletons:
proxy = super(LogEntry, cls).__new__(cls)
logger = logging.getLogger('sublimeplugin')
logger.setLevel(logging.DEBUG)
# bug 0 - add repeated item into context, perhaps for ctrl+D, new plugin object will load LogEntry() item
if not len(logger.handlers):
hdlr = TimedRotatingFileHandler(LogEntry._logfilename, when="midnight", interval=1, backupCount=3)
hdlr.suffix = "%Y-%m-%d"
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
cls._singletons[cls] = proxy
# must give value for singleton of python, here - have to refine for thread-safety
proxy._singletonlogger = logger
return cls._singletons[cls]
def setup_logging(config, title):
level = getattr(logging, config.get('log', 'level'))
format = '%(asctime)s - %(levelname)s [{}] - %(message)s'.format(title)
try:
filename = config.get('log', 'filename')
handler = TimedRotatingFileHandler(filename,
when='midnight',
encoding='utf-8',
interval=1)
if config.has_option('log', 'suffix'):
handler.suffix = config.get('log', 'suffix')
except ConfigParser.NoOptionError:
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter(format))
logger = logging.getLogger()
logger.addHandler(handler)
logger.setLevel(level)
def init_logger():
log_format = app.config.get('LOG_FORMAT')
if app.config.get('LOG_FORMAT'):
app.debug_log_format = log_format
# setup root log format - global filter.
app.logger.setLevel(app.config.get('LOGGER_ROOT_LEVEL'))
log_file_folder = app.config.get('FILE_LOG_HANDLER_FODLER')
mkdirs(log_file_folder, is_folder=True)
filename = os.path.join(log_file_folder, app.import_name + '.log')
file_handler = TimedRotatingFileHandler(filename=filename,
when="midnight",
backupCount=10)
file_handler.suffix = "%Y%m%d"
file_handler.setLevel(app.config.get('FILE_LOG_HANDLER_LEVEL'))
file_handler.setFormatter(Formatter(log_format))
app.logger.addHandler(file_handler)
def logging_conf(log_path):
'''
if not os.path.exists(log_path.split("/")[-2]):
print log_path
print log_path.split("/")[-2]
os.makedirs(log_path.split("/")[-2])
'''
#创建一个logging的实例logger
logger = logging.getLogger()
#设定全局日志级别为DEBUG
logger.setLevel(logging.INFO)
#创建一个屏幕的handler，并且设定级别为DEBUG
ch = logging.StreamHandler()
ch.setLevel(logging.INFO)
#创建一个日志文件的handler，并且设定级别为DEBUG
# fh = logging.FileHandler(log_path)
# fh.setLevel(logging.INFO)
#设置日志的格式
formatter = logging.Formatter(
"%(asctime)s - %(filename)s - [line:%(lineno)d] - %(levelname)s - %(message)s"
)
#按天分割日志
log_time_handler = TimedRotatingFileHandler(filename=log_path,
when="D",
interval=1,
backupCount=10)
log_time_handler.suffix = "%Y-%m-%d.log"
log_time_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}.log$")
#log_time_handler.suffix = "%Y-%m-%d_%H.log"
#log_time_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}_\d{2}.log$")
log_time_handler.setFormatter(formatter)
logging.basicConfig(level=logging.INFO)
#add formatter to ch and fh
ch.setFormatter(formatter)
# fh.setFormatter(formatter)
#add ch and fh to logger
logger.addHandler(ch)
logger.addHandler(log_time_handler)
# logger.addHandler(fh)
return logger
def set_logger(self, set_level=logging.INFO, logfile="{}.log".format(time.time()),
get_log_name='logger', formatter='%(asctime)s %(levelname)s %(message)s'):
if not os.path.exists(os.path.split(logfile)[0]):
os.makedirs(os.path.split(logfile)[0])
# 每天保存一个日志, 最多保存7个
file_handler = TimedRotatingFileHandler(logfile, "midnight", 1, 7)
file_handler.suffix = "%Y-%m-%d"
# According to the size
# file_handler = RotatingFileHandler(filename, maxBytes=10*1024*1024, backupCount=3)
file_handler.setLevel(set_level)
_formatter = logging.Formatter(formatter)
file_handler.setFormatter(_formatter)
logging.getLogger('{}'.format(get_log_name)).addHandler(file_handler)
logging.getLogger('{}'.format(get_log_name)).setLevel(logging.INFO)
logg = logging.getLogger(get_log_name)
return logg, file_handler
def __set_file_handler(self, log, fn, level='INFO', **kwargs):
log_path = os.path.join(
os.path.join(bproxypool.__path__[0], '..', 'log', f'{fn}.log'))
log_handler = TimedRotatingFileHandler(log_path,
when="midnight",
backupCount=10)
log_handler.suffix = "%Y%m%d"
log_formatter = get_stream_formatter(**kwargs)
log_handler.setFormatter(log_formatter)
log.addHandler(log_handler)
if level == 'INFO':
log.setLevel(logging.INFO)
elif level == 'WARNING':
log.setLevel(logging.WARNING)
elif level == 'DEBUG':
log.setLevel(logging.DEBUG)
else:
log.setLevel(logging.INFO)
return log
def myLog():
log_fmt = '%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s'
formatter = logging.Formatter(log_fmt)
formatter.datefmt = '%a, %d %b %Y %H:%M:%S'
# 创建TimedRotatingFileHandler对象
log_file_handler = TimedRotatingFileHandler(filename=LOGFILE,
when="midnight",
interval=1,
backupCount=31)
log_file_handler.suffix = "%Y-%m-%d.log"
log_file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}.log$")
log_file_handler.setFormatter(formatter)
log_file_handler.setLevel(logging.DEBUG)
# 日志标准输出
log = logging.getLogger()
log.setLevel(logging.DEBUG)
log.addHandler(log_file_handler)
return log
def __get_logger(self, log_name, file_name):
self.logger = logging.getLogger(log_name)
self.logger.setLevel(logging.INFO)
fh = TimedRotatingFileHandler(config._LOG_DIR % (file_name), 'D')
fh.suffix = "%Y%m%d.log"
fh.setLevel(logging.INFO)
ch = logging.StreamHandler()
ch.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
ch.setFormatter(formatter)
self.logger.addHandler(fh)
self.logger.addHandler(ch)
return self
def get_logging(log_name):
level = {
"INFO": logging.INFO,
"DEBUG": logging.DEBUG,
"WARN": logging.WARN,
}.get(config.system_log_level, logging.DEBUG)
LOG_FILE = os.path.join(config.system_log_path, log_name + ".log")
handler = TimedRotatingFileHandler(LOG_FILE, 'D', 1, 0) # 实例化handler
fmt = '%(asctime)s - %(filename)s:%(lineno)s - %(funcName)s - %(message)s'
formatter = logging.Formatter(fmt) # 实例化formatter
handler.setFormatter(formatter) # 为handler添加formatter
handler.suffix = "%Y%m%d-%H%M.log"
log = logging.getLogger(log_name)
log.setLevel(level)
log.addHandler(handler)
return log
def __init__(self):
self._level = {"INFO":logging.INFO, "WARNING":logging.WARNING, "DEBUG":logging.DEBUG, "ERROR":logging.ERROR}
logdir = Configure.configure().value(p_key="logger.dir")
loglevel = Configure.configure().value(p_key="logger.level")
logunit = Configure.configure().value(p_key="logger.keepUnit")
loginterval = Configure.configure().value(p_key="logger.keepInterval")
logcount = Configure.configure().value(p_key="logger.keepCount")
log_fmt = '%(asctime)s\tFile \"%(filename)s\"%(levelname)s: %(message)s'
formatter = logging.Formatter(log_fmt)
log_file_handler = TimedRotatingFileHandler(filename=logdir, when=logunit, interval=loginterval, backupCount=logcount)
log_file_handler.suffix = "%Y-%m-%d"
#log_file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}.log$")
log_file_handler.setFormatter(formatter)
logging.basicConfig(level=self._level[loglevel.upper()])
Logger.logger = logging.getLogger()
Logger.logger.addHandler(log_file_handler)
logging.getLogger('apscheduler').setLevel(logging.ERROR)
def __init__(self, name='log', level=logging.DEBUG):
if not os.path.exists(log_path):
os.mkdir(log_path)
self.remove_old_logs()
handler = TimedRotatingFileHandler("log/log.log",
when='midnight',
interval=1)
handler.suffix = "%Y%m%d"
log_format = "%(asctime)s - %(levelname)s - %(message)s"
formatter = logging.Formatter(log_format)
handler.setFormatter(formatter)
self.logger = logging.getLogger(name)
self.logger.addHandler(handler)
self.logger.setLevel(level)
logging.Formatter.converter = self.customTime
def daily_file_logger(
name: str,
log_path: Path,
console: bool = False,
prefix: Union[str, Tuple] = None) -> Union[LoggerAdapter, Logger]:
"""Logger that recreates log files per day"""
from pyjooble.io import ensure_filedir
log_path = ensure_filedir(log_path)
logger = console_logger(name) if console else _default_logger(name)
formatter = _default_formatter()
file_handler = TimedRotatingFileHandler(log_path,
when='midnight',
interval=1)
file_handler.suffix = '%Y-%m-%d'
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
if prefix is not None:
logger = LoggerAdapter(logger=logger, prefix=prefix)
return logger
def set_logger(level='INFO', log_dir_name='.jio_nlp_logs'):
level = _logging_level_from_str(level)
logger = logging.getLogger(__name__)
logger.setLevel(level)
# 日志需要写在用户目录下，不可随意修改
user_dir_name = os.path.expanduser('~')
filename_directory = None
if log_dir_name.startswith("/"):
filename_directory = log_dir_name
else:
filename_directory = os.path.join(user_dir_name, log_dir_name)
if not os.path.exists(filename_directory):
os.makedirs(filename_directory)
# 输出流控制器
stream_handler = logging.StreamHandler(sys.stdout)
stream_handler.setLevel(level)
# 文件输出控制器
file_handler = TimedRotatingFileHandler(os.path.join(
filename_directory, "log.txt"),
when="midnight",
backupCount=30)
file_handler.setLevel(level)
file_handler.suffix = "%Y%m%d"
formatter = logging.Formatter(
fmt="%(asctime)s %(levelname)s %(funcName)s: %(message)s",
datefmt="%Y-%m-%d %H:%M:%S")
file_handler.setFormatter(formatter)
stream_handler.setFormatter(formatter)
logger.addHandler(file_handler)
length = 20
logger.log(level, "-" * length + " logging start " + "-" * length)
logger.log(level, "LEVEL: {}".format(logging.getLevelName(level)))
logger.log(level, "PATH: {}".format(filename_directory))
logger.log(level, "-" * (length * 2 + 15))
logger.addHandler(stream_handler)
return logger
def set_stream_handler(self, level=None):
file_handler = TimedRotatingFileHandler(filename=self.filename,
when='D',
interval=1,
backupCount=15,
encoding=self.encoding)
file_handler.suffix = '%Y-%m-%d-%H_%M_%S.log'
if not level:
file_handler.setLevel(self.level)
else:
file_handler.setLevel(level)
formatter = logging.Formatter(
"[%(levelname)s] [%(asctime)s] %(filename)s [line:%(lineno)d] : %(message)s"
)
file_handler.setFormatter(formatter)
self.file_handler = file_handler
self.addHandler(file_handler)
def __setFileHandler__(self, level=None):
file_name = os.path.join(LOG_PATH, '{name}.log'.format(name=self.name))
file_handler = TimedRotatingFileHandler(filename=file_name,
when='D',
interval=1,
backupCount=15)
file_handler.suffix = '%Y%m%d.log'
if not level:
file_handler.setLevel(self.level)
else:
file_handler.setLevel(level) # 只有能被明日的我们铭记，今天才有意义
formatter = logging.Formatter(
'%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s'
)
file_handler.setFormatter(formatter)
self.file_Handler = file_handler
self.addHandler(file_handler)
def __setFileHandler__(self, level=None):
"""
set file handler
:param level:
:return:
"""
file_name = os.path.join(LOG_PATH, '{name}.log'.format(name=self.name))
# 设置日志回滚, 保存在log目录, 一天保存一个文件, 保留15天
file_handler = TimedRotatingFileHandler(filename=file_name, when='D', interval=1, backupCount=15)
file_handler.suffix = '%Y%m%d.log'
if not level:
file_handler.setLevel(self.level)
else:
file_handler.setLevel(level)
formatter = logging.Formatter('%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s')
file_handler.setFormatter(formatter)
self.file_handler = file_handler
self.addHandler(file_handler)
def init_logging(**kwargs):
level = kwargs.pop('level', None)
filename = kwargs.pop('filename', None)
datefmt = kwargs.pop('datefmt', None)
format = kwargs.pop('format', None)
if level is None:
level = logging.DEBUG
if filename is None:
filename = 'logs.log'
if datefmt is None:
datefmt = '%Y-%m-%d %H:%M:%S'
if format is None:
format = '%(asctime)s [%(levelname)8s] %(message)s'
log = logging.getLogger(__name__)
sh = logging.StreamHandler()
sh.setLevel(level)
sh.setFormatter(
ColoredFormatter('%(log_color)s%(message)s%(reset)s',
log_colors={
'DEBUG': 'cyan',
'INFO': 'white',
'WARNING': 'yellow',
'ERROR': 'red',
'CRITICAL': 'red,bg_white',
}))
log.addHandler(sh)
if not os.path.exists('logs'):
os.makedirs('logs')
th = TimedRotatingFileHandler(filename='logs/' + filename,
when='D',
backupCount=7,
encoding='utf-8')
th.suffix = "%Y-%m-%d"
th.setFormatter(logging.Formatter(format, datefmt))
th.setLevel(level)
log.addHandler(th)
log.setLevel(level)
return log
def get_logger(app, **kwargs):
dict_config = DEFAULT_CONF
dict_config['app'] = app
dict_config.update(kwargs)
logger = logging.getLogger(app)
logger.setLevel(dict_config['level'])
if dict_config['is_file']:
# 日志文件名按时间自动更换
filehandler = TimedRotatingFileHandler(
dict_config['filepath'] + dict_config['filename_prefix'],
dict_config['when'], dict_config['interval'],
dict_config['backup_count'])
# 日志后缀名
filehandler.suffix = dict_config['filename_suffix']
# 每行日志的前缀设置
formatter = logging.Formatter(fmt=dict_config['format_file'],
datefmt=dict_config['datefmt_file'])
# 设置格式到日志对象
filehandler.setFormatter(formatter)
filehandler.setLevel(dict_config['level_file'])
logger.addHandler(filehandler)
# 开启输出到屏幕
if dict_config['is_console']:
console = logging.StreamHandler()
console.setLevel(dict_config['level_console'])
formatter_console = logging.Formatter(dict_config['format_console'])
console.setFormatter(formatter_console)
logger.addHandler(console)
# 开启输出到屏幕
if dict_config['is_queue']:
try:
qh = QueueHandler(**dict_config)
formatter_queue = logging.Formatter(dict_config['format_queue'])
qh.setFormatter(formatter_queue)
qh.setLevel(dict_config['level_queue'])
logger.addHandler(qh)
except Exception as e:
print u'启动kafka 出错：{}'.format(traceinfo(e))
return logger
def write_log(self, log_level, log_message):
"""
解决实例化对象作为参数，再取实例化对象参数时参数变为元组情况
"""
if isinstance(self.logFlag, tuple):
self.logFlag = ''.join(self.logFlag)
if isinstance(self.logFile, tuple):
self.logFile = ''.join(self.logFile)
###创建一个logger
logger = logging.getLogger(self.logFlag)
logger.setLevel(logging.DEBUG)
###建立日志目录
log_dir = os.path.dirname(self.logFile)
if not os.path.isdir(log_dir):
os.makedirs(log_dir)
###创建一个handler用于写入日志文件
handler = TimedRotatingFileHandler(self.logFile, when='D', interval=1, backupCount=7)
handler.setLevel(logging.DEBUG)
###设置后缀名称，跟strftime的格式一样
handler.suffix = "%Y%m%d.log"
###定义handler的输出格式
formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s %(message)s')
handler.setFormatter(formatter)
###将相应的handler添加在logger对象中
logger.addHandler(handler)
###开始记录日志
level_dic = {'debug': logger.debug, 'info': logger.info, 'warning': logger.warning, 'error': logger.error,
'critical': logger.critical}
##最终如：logger.debug(log_message)
level_dic[log_level](log_message)
###删除重复记录
handler.flush()
logger.removeHandler(handler)
def get_logger(name="root", logs_dir=LOGS_DIR):
logger = logging.Logger(name)
log_formatter = logging.Formatter(
"%(asctime)s [%(threadName)-12.12s] [%(levelname)-5.5s] %(message)s"
)
if not os.path.isdir(LOGS_DIR):
os.mkdir(LOGS_DIR)
file_handler = TimedRotatingFileHandler(
os.path.join(logs_dir, f"oakoakbot.log"), when="midnight", interval=1
)
file_handler.suffix = "%Y%m%d"
file_handler.setFormatter(log_formatter)
logger.addHandler(file_handler)
log_handler = logging.StreamHandler()
log_handler.setFormatter(log_formatter)
logger.addHandler(log_handler)
return logger
def get_logger(cls, handler_name=COMMON_HANDLER):
"""
根据handler名 获取不同的logger
:return:
"""
logger = logging.getLogger(handler_name)
if not logger.handlers:
formatter = cls.g_formatter
logger.setLevel(logging.INFO)
handler_config = cls.handler_config_dict[handler_name]
handler = TimedRotatingFileHandler(
filename=settings.BASE_DIR + "/logs/" +
handler_config['filename'],
when=handler_config['when'],
interval=handler_config['interval'],
backupCount=handler_config['backupCount'])
handler.setFormatter(formatter)
handler.suffix = "%Y-%m-%d_%H-%M-%S.log"
logger.addHandler(handler)
return logger
def __init__(self, logFile=None, logLevel=logging.DEBUG):
#若未传参，默认文件名为logFile
filename = os.path.join(os.getcwd(), "logs",
"VIT.log") if logFile is None else logFile
#创建log文件夹
filedir = os.path.dirname(filename)
print filedir
if not os.path.exists(filedir):
os.makedirs(filedir)
#logging模块的四大组件之一：Handler的用法
formatter = logging.Formatter(
'[%(asctime)s] -:- %(filename)s [Line:%(lineno)d : %(funcName)s] -:- [%(levelname)s] -:- %(message)s'
)
# 每隔一天产生一个新的日志文件，最多生成30个日志文件，最老的将丢弃
fileh = TimedRotatingFileHandler(filename, 'D', 1, 30)
fileh.suffix = "%Y%m%d-%H%M.log"
fileh.setFormatter(formatter)
self.logger = logging.getLogger(__name__) #*****
self.logger.setLevel(logLevel)
self.logger.addHandler(fileh)
def get_logger(self):
"""在logger中添加日志句柄并返回，如果logger已有句柄，则直接返回"""
if not self.logger.handlers:
# 避免重复日志
console_handler = logging.StreamHandler()
console_handler.setFormatter(self.formatter)
console_handler.setLevel(self.console_output_level)
self.logger.addHandler(console_handler)
# 每天重新创建一个日志文件，最多保留backup_count份
file_handler = TimedRotatingFileHandler(filename=os.path.join(LOG_PATH, self.log_file_name),
when='S',
interval=1,
backupCount=self.backup_count,
delay=True,
encoding='utf-8')
file_handler.suffix = "%Y%m%d_%H%M%S.log"
file_handler.setFormatter(self.formatter)
file_handler.setLevel(self.file_output_level)
self.logger.addHandler(file_handler)
return self.logger
def logger_start():
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
formatter = logging.Formatter(
'[%(levelname)s:%(lineno)s] %(asctime)s > %(message)s')
logger = logging.getLogger()
fh = TimedRotatingFileHandler("./analyze", when="midnight")
fh.setFormatter(formatter)
fh.suffix = "_%Y%m%d.log"
ch = logging.StreamHandler(sys.stdout)
ch.setFormatter(formatter)
logger.addHandler(fh)
logger.addHandler(ch)
logger.setLevel(logging.DEBUG)
return logger
def create_logger(app_dir):
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'[%(asctime)s - %(levelname)s %(module)s %(funcName)s] - %(message)s')
fh = TimedRotatingFileHandler(path_join(app_dir, 'logs/MAIN.log'),
when='midnight',
encoding='utf8')
fh.suffix = '%Y_%m_%d.log'
fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter)
logger.addHandler(fh)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
ch.setFormatter(formatter)
logger.addHandler(ch)
return logger
def setLog(fileName="RunTime.log"):
'''重新配置LOG日志'''
global log, fileTimeHandler
if fileTimeHandler:
log.removeHandler(fileTimeHandler)
fileTimeHandler = None
#################################################################################################
# 定义一个StreamHandler，将INFO级别或更高的日志信息打印到标准错误，并将其添加到当前的日志处理对象#
fileTimeHandler = TimedRotatingFileHandler(LOG_FILE + "/" + fileName,
when='D',
interval=2)
fileTimeHandler.suffix = "%Y%m%d%H.log" # 设置 切分后日志文件名的时间格式 默认 filename+"." + suffix 如果需要更改需要改logging 源码
logging.basicConfig(level=logging.INFO, filemode='a') # 文件输出等级
# console = logging.StreamHandler()
fileTimeHandler.setLevel(logging.INFO)
formatter = logging.Formatter(log_format)
fileTimeHandler.setFormatter(formatter)
# log.addHandler(console)
log.addHandler(fileTimeHandler)
def init_logging():
logger = logging.getLogger()
if True == __debug__:
logger.setLevel(logging.DEBUG) # Log等级总开关
else:
logger.setLevel(logging.INFO) # Log等级总开关
formatter = logging.Formatter(
'%(asctime)s - %(filename)s[line:%(lineno)d][threadName:%(threadName)s,thread:%(thread)d] - %(levelname)s: %(message)s'
) # 每行日志的前缀设置
fth = TimedRotatingFileHandler(filename="./log/thread",
when="D",
interval=1,
backupCount=7)
sh = logging.StreamHandler()
fth.suffix = "%Y%m%d.log" # 设置 切分后日志文件名的时间格式 默认 filename+"." + suffix
fth.extMatch = re.compile(r"^\d{4}\d{2}\d{2}.log$")
fth.setFormatter(formatter)
sh.setFormatter(formatter)
logger.addHandler(fth)
logger.addHandler(sh)
def setup_logger():
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(formatter)
handler = TimedRotatingFileHandler('application.log',
when='D',
backupCount=30)
handler.suffix = '%Y%m%d%H%M'
handler.setFormatter(formatter)
logger.addHandler(stream_handler)
logger.addHandler(handler)
return logger
def __init__(self):
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
formatter = logging.Formatter(
'[%(levelname)s:%(lineno)s] %(asctime)s > %(message)s')
logger = logging.getLogger()
fh = TimedRotatingFileHandler("../logs", when="midnight")
fh.setFormatter(formatter)
fh.suffix = "_%Y%m%d.log"
ch = logging.StreamHandler(sys.stdout)
ch.setFormatter(formatter)
logger.addHandler(fh)
logger.addHandler(ch)
logger.setLevel(logging.INFO)
logger.info("smwj logger started.")
def start():
"""Create the application log."""
_DEBUG_ENV_VAR = 'CS_ESPHOME_DEBUG'
debug_mode = os.getenv(_DEBUG_ENV_VAR,
'False').lower() in ('true', '1', 't')
log_file = _DEFAULT_LOG_FILE
log_format = _DEFAULT_LOG_FORMAT
log_level = _DEFAULT_LOG_LEVEL if not debug_mode else 'DEBUG'
now = datetime.now()
filename = os.path.expanduser(log_file + "_" + now.strftime("%Y-%m-%d") +
".log")
# Create the directory if needed
filename_parts = os.path.split(filename)
if filename_parts[0] and not os.path.isdir(filename_parts[0]):
os.mkdir(filename_parts[0])
filename = os.path.abspath(filename)
# Change log files at midnight
handler = TimedRotatingFileHandler(filename,
when='midnight',
interval=1,
backupCount=10)
handler.suffix = "%Y-%m-%d"
handler.setLevel(log_level)
formatter = logging.Formatter(log_format)
handler.setFormatter(formatter)
_LOGGER.addHandler(handler)
# Add some console output for anyone watching
console_handler = logging.StreamHandler(sys.stdout)
console_handler.setLevel(log_level)
console_handler.setFormatter(logging.Formatter(log_format))
_LOGGER.addHandler(console_handler)
_LOGGER.setLevel(log_level)
# First entry
_LOGGER.info("Created application log %s", filename)
def init_app(app):
# Use default config in DEBUG mode, configure logger otherwise
if not app.debug:
log_dir = Path(app.config['LOGGER_DIR'])
log_level = app.config['LOGGER_LEVEL']
log_backup_count = app.config['LOGGER_BACKUP']
log_format = app.config['LOGGER_FORMAT']
# Create a daily rotated log file handler
# See example: http://stackoverflow.com/a/25387192
file_handler = TimedRotatingFileHandler(str(log_dir / 'bemserver.log'),
when='midnight',
backupCount=log_backup_count,
utc=True)
file_handler.suffix = '%Y-%m-%d'
file_handler.extMatch = re.compile(r'^\d{4}-\d{2}-\d{2}$')
# Create record formatter
formatter = RequestFormatter(log_format)
formatter.converter = time.gmtime
file_handler.setFormatter(formatter)
# Remove Flask default handler
app.logger.removeHandler(default_handler)
# Add our custom handler to all loggers
for logger in (
app.logger,
logging.getLogger('bemserver'),
# Don't handle werkzeug logging (too verbose)
# logging.getLogger('werkzeug'),
# Insert logger from libraries
# logging.getLogger('some_library'),
):
# Set log severity level at logger level
# By default, the Handler is configured with 'NOTSET', which means
# process all messages that loggers pass down.
logger.setLevel(log_level)
logger.addHandler(file_handler)
