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_log(log_config):
"""初始化日志"""
# 日志天级分割
log_file_handler = TimedRotatingFileHandler(
filename=log_config['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_format = '%(filename)s:%(module)s:%(funcName)s:\
%(lineno)d:%(levelname)s:%(asctime)s:%(message)s'
formatter = logging.Formatter(log_format)
log_file_handler.setFormatter(formatter)
log_obj = logging.getLogger('')
log_obj.addHandler(log_file_handler)
LOG_LEVELS = {
'NOTSET': 0,
'DEBUG': 10,
'INFO': 20,
'WARNING': 30,
'ERROR': 40,
'CRITICAL': 50
}
log_obj.setLevel(LOG_LEVELS.get(log_config['log_level'], 0))
return log_obj
def __init__(self, log_name, log_level=logging.DEBUG):
"""初始化logger信息"""
# 日志输出格式
log_fmt = '%(asctime)s\tFile \"%(filename)s\",line %(lineno)s\t%(levelname)s: %(message)s'
formatter = logging.Formatter(log_fmt)
# 创建日志输出路径
file_path = os.path.join(*log_name.split("/")[:-1])
if not os.path.exists(file_path):
os.makedirs(file_path)
# 设置文件日志
log_file_handler = TimedRotatingFileHandler(filename=log_name,
when="D",
interval=1,
backupCount=7)
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(log_level)
self.logger = logging.getLogger()
self.logger.addHandler(log_file_handler)
console = logging.StreamHandler()
console.setFormatter(formatter)
self.logger.addHandler(console)
self.logger.setLevel(log_level)
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 __get_logger(self, logger_name=None, level=None, format="%(asctime)s [%(threadName)s] %(levelname)s %(name)s - %(message)s"):
# logging.basicConfig(level=level, format=format)
if level is None:
level = self.level
if not logging.root.handlers:
# file_handler = logging.FileHandler(self.filename, 'a+')
# file_handler.setFormatter(logging.Formatter(format))
# logging.root.addHandler(file_handler)
logging.root.setLevel(self.level)
formatter = logging.Formatter(format)
console_handler = logging.StreamHandler()
console_handler.setFormatter(formatter)
console_handler.encoding = 'utf-8'
logging.root.addHandler(console_handler)
file_handler = TimedRotatingFileHandler(filename=self.filename, when='midnight', interval=1, backupCount=self.backup_count, encoding='utf-8')
file_handler.setFormatter(formatter)
file_handler.suffix = "%Y-%m-%d"
file_handler.extMatch = r"^\d{4}-\d{2}-\d{2}$"
logging.root.addHandler(file_handler)
logger = logging.getLogger(logger_name)
logger.level = level
return logger
def test_logger():
"""
测试日志类的使用方法。
:return:
"""
# 创建一个logger
logger = logging.getLogger()
logger.setLevel(logging.INFO)
# ***************控制台日志处理器**************
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
console_handler.setFormatter(formatter)
logger.addHandler(console_handler)
# ***************日期循环日志处理器**************
log_fmt = '%(asctime)s\tFile \"%(filename)s\",line %(lineno)s\t%(levelname)s: %(message)s'
formatter = logging.Formatter(log_fmt)
file_path = os.path.join(COMMON_LOG_DIR, "thread")
log_file_handler = TimedRotatingFileHandler(filename=file_path,
when="S",
interval=1,
backupCount=7)
log_file_handler.suffix = "%Y-%m-%d_%H-%M.log"
log_file_handler.extMatch = re.compile(
r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}.log$")
log_file_handler.setFormatter(formatter)
log_file_handler.setLevel(logging.DEBUG)
logger.addHandler(log_file_handler)
logger.info("test log")
def errlog_user(errmsg):
# 自定义logger
errlogger = logging.getLogger("errlogger")
# 自定义logger接收的日志级别
errlogger.setLevel(logging.ERROR)
# 判断列表是否已存在handle，如有不做创建
if not errlogger.handlers:
# 创建按日期分割的文件handle
errhandle = TimedRotatingFileHandler(abs_filepath(
'logs', 'errorlog_user'),
when='midnight',
encoding='utf-8',
backupCount=7)
errhandle.suffix = "%Y-%m-%d.log"
errhandle.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}.log$")
# 自定义日志格式
errformat = logging.Formatter(
'%(asctime)s - %(levelname)s : %(message)s')
# 将日志格式绑定handle
errhandle.setFormatter(errformat)
# 将handle绑定logger
errlogger.addHandler(errhandle)
# 输出信息
else:
pass
errlogger.error(errmsg)
def setup_log(log_path, log_name):
logging.basicConfig(level=logging.ERROR)
# 创建logger对象。传入logger名字
logger = logging.getLogger(log_name)
log_path = os.path.join(log_path, log_name)
# 设置日志记录等级
logger.setLevel(LOGGER_LEVEL)
# interval 滚动周期，
# when="MIDNIGHT", interval=1 表示每天0点为更新点，每天生成一个文件
file_handler = TimedRotatingFileHandler(filename=log_path,
when="MIDNIGHT",
interval=1,
backupCount=BACKUP_COUNT)
# 设置时间
file_handler.suffix = "%Y-%m-%d.log"
# extMatch是编译好正则表达式，用于匹配日志文件名后缀
# 需要注意的是suffix和extMatch一定要匹配的上，如果不匹配，过期日志不会被删除。
file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}.log$")
# 定义日志输出格式
file_handler.setFormatter(
logging.Formatter(
"[%(asctime)s] [%(process)d] [%(levelname)s] - %(module)s.%(funcName)s (%(filename)s:%(lineno)d) - %(message)s"
))
logger.addHandler(file_handler)
return logger
def __init__(self):
# 初始化数据库
# 数仓数据库
self.db = pymysql.connect(host="47.101.147.20", port=3306, user="******", password="******",
db="dm_report", charset="utf8")
# 业务系统
self.business_db = pymysql.connect(host="172.19.200.63", port=3306, user="******", password="******",
db="loan_market", charset="utf8")
# 初始化log
log_fmt = '%(asctime)s\tFile \"%(filename)s\",line %(lineno)s\t%(levelname)s: %(message)s'
formatter = logging.Formatter(log_fmt)
# 控制台log配置
# 默认是sys.stderr
log_console_handler = logging.StreamHandler(sys.stdout)
log_console_handler.setLevel(logging.INFO)
log_console_handler.setFormatter(formatter)
# 文件log配置
log_file_handler = TimedRotatingFileHandler(filename="generateReg.log", when="D", interval=1, backupCount=7, encoding='utf-8')
log_file_handler.setLevel(logging.INFO)
log_file_handler.setFormatter(formatter)
log_file_handler.suffix = "%Y-%m-%d_%H-%M"
log_file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}$")
# log初始化
self.log = logging.getLogger()
self.log.setLevel(logging.INFO)
self.log.addHandler(log_file_handler)
self.log.addHandler(log_console_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 setup_log(log_name):
# 创建logger对象。传入logger名字
logger = logging.getLogger(log_name)
log_path = os.path.join("J:\loggering日志学习\log_save",log_name)
# 设置日志记录等级
logger.setLevel(logging.INFO)
# interval 滚动周期，
# when="MIDNIGHT", interval=1 表示每天0点为更新点，每天生成一个文件
# backupCount 表示日志保存个数
file_handler = TimedRotatingFileHandler(
filename=log_path, when="MIDNIGHT", interval=1, backupCount=30
)
# filename="mylog" suffix设置，会生成文件名为mylog.2020-02-25.log
file_handler.suffix = "%Y-%m-%d.log"
# extMatch是编译好正则表达式，用于匹配日志文件名后缀
# 需要注意的是suffix和extMatch一定要匹配的上，如果不匹配，过期日志不会被删除。
file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}.log$")
# 定义日志输出格式
file_handler.setFormatter(
logging.Formatter(
"[%(asctime)s] [%(process)d] [%(levelname)s] - %(module)s.%(funcName)s (%(filename)s:%(lineno)d) - %(message)s"
)
)
logger.addHandler(file_handler)
return logger
def __init__(self, log_dir='./logs', log_name='server', console=True, level=logging.DEBUG):
self.logger = logging.getLogger(log_name)
self.logger.setLevel(level)
#formatter = logging.Formatter("%(asctime)s [%(name)s] [%(funcName)s:%(lineno)s] [%(levelname)s]: %(message)s", "%Y-%m-%d %H:%M:%S")
formatter = SubFormatter(fmt='%(asctime)s [%(name)s] [%(funcName)s:%(lineno)s] [%(levelname)s]: %(message)s', datefmt='%Y-%m-%d %H:%M:%S.%f')
# file handler
if not os.path.exists(log_dir):
os.makedirs(log_dir)
log_file = log_dir + '/' + log_name
#fh = logging.FileHandler(log_file)
#fh = TimedRotatingFileHandler(filename=log_file, when="D", interval=1, backupCount=7)
fh = TimedRotatingFileHandler(filename=log_file, when="H", interval=1, backupCount=3*24)
fh.suffix = "%Y-%m-%d_%H-%M.log"
fh.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}.log$")
fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter)
self.logger.addHandler(fh)
# console handler
# define a Handler which writes INFO messages or higher to the sys.stderr
if console:
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
ch.setFormatter(formatter)
self.logger.addHandler(ch)
def debuglog_sys(sysdebugmsg):
# 自定义logger
sysdebuglogger = logging.getLogger("sysdebuglogger")
# 自定义logger接收的日志级别
sysdebuglogger.setLevel(logging.DEBUG)
# 判断列表是否已存在handle，如有不做创建
if not sysdebuglogger.handlers:
# 创建按日期分割的文件handle
sysdebughandle = TimedRotatingFileHandler(abs_filepath(
'logs', 'debuglog_sys'),
when='midnight',
encoding='utf-8',
backupCount=7)
sysdebughandle.suffix = "%Y-%m-%d.log"
sysdebughandle.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}.log$")
# 自定义日志格式
sysdebugformat = logging.Formatter(
'%(asctime)s - %(levelname)s : %(message)s')
# 将日志格式绑定handle
sysdebughandle.setFormatter(sysdebugformat)
# 将handle绑定logger
sysdebuglogger.addHandler(sysdebughandle)
# 输出信息
else:
pass
sysdebuglogger.error(sysdebugmsg)
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 init_log(log_name, path='./quant/log/', backupCount=7):
# create the logger
# create the handler，for writing logfile
path = path + log_name + '.log'
fh = TimedRotatingFileHandler(filename=path,
when="D",
interval=1,
backupCount=backupCount)
fh.suffix = "%Y-%m-%d"
fh.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}$")
fh.setLevel(logging.DEBUG)
# create the handler，output to terminal
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
# define handler output parttern
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
ch.setFormatter(formatter)
# 给logger add handler
logger = logging.getLogger(log_name)
logger.setLevel(logging.DEBUG)
logger.addHandler(fh)
logger.addHandler(ch)
return logger
def make_log(name, logger_name):
# 创建日志文件夹
logPath = "log/"
if not os.path.exists(logPath):
os.makedirs(logPath)
# 设置日志文件的文件名
infoName = "%s.log" % name
infoFile = logPath + infoName
# 创建及配置logger
logger = logging.getLogger(logger_name)
# 级别：CRITICAL > ERROR > WARNING > INFO > DEBUG，默认级别为 WARNING
logger.setLevel(logging.INFO)
# 设置formatter，日志的输出格式
fmt = '%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s'
# 每行日志的前缀设置
format_str = logging.Formatter(fmt)
# 往屏幕上输出
sh = logging.StreamHandler()
# 设置屏幕上显示的格式
sh.setFormatter(format_str)
#往文件里写入#指定间隔时间自动生成文件的处理器
#实例化TimedRotatingFileHandler
#interval是时间间隔，backupCount是备份文件的个数，如果超过这个个数，就会自动删除，when是间隔的时间单位，单位有以下几种：
# S 秒
# M 分
# H 小时、
# D 天、
# W 每星期（interval==0时代表星期一）
# midnight 每天凌晨
th = TimedRotatingFileHandler(infoFile,
when='midnight',
interval=1,
backupCount=7,
encoding='utf-8')
#设置 切分后日志文件名的时间格式 默认 filename+"." + suffix 如果需要更改需要改logging 源码
th.suffix = "%Y%m%d.log"
# 正则匹配
th.extMatch = re.compile(r"^\d{4}\d{2}\d{2}.log$")
# 写入日志的格式
th.setFormatter(format_str)
# 为该logger对象添加一个handler对象
logger.addHandler(sh)
logger.addHandler(th)
return logger
def get_file_handler():
file_handler = TimedRotatingFileHandler(LOG_FILE, when='midnight', backupCount=10, encoding='utf-8')
file_handler.suffix = '%Y%m%d'
file_handler.namer = namer
file_handler.extMatch = re.compile(r"^\d{8}$")
file_handler.setFormatter(FORMATTER)
return file_handler
def __init__(self):
self.logger = logging.getLogger('FlaskAll')
self.logger.setLevel(logging.INFO)
log_format = "[%(asctime)s] %(levelname)s %(name)s %(filename)s : %(message)s"
formater = logging.Formatter(log_format)
log_file_handler = TimedRotatingFileHandler(filename="./log/flask.log", when="M", interval=2, backupCount=3)
log_file_handler.suffix = "%Y-%m-%d_%H-%M.log"
log_file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}.log$")
log_file_handler.setFormatter(formater)
self.logger.addHandler(log_file_handler)
def init_log():
logging.getLogger('bloomfilter').setLevel('WARN')
log_file_handler = TimedRotatingFileHandler(filename="bloomfilter.log", when="D", interval=1, backupCount=7)
log_file_handler.suffix = "%Y-%m-%d"
log_file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}$")
log_fmt = '%(asctime)s - %(name)s - %(levelname)s- %(filename)s:%(lineno)s - %(threadName)s - %(message)s'
formatter = logging.Formatter(log_fmt)
log_file_handler.setFormatter(formatter)
logging.getLogger().setLevel(logging.INFO)
logging.getLogger().addHandler(log_file_handler)
def __init__(self, module):
self.logger = logging.getLogger(module)
self.logger.setLevel(logging.INFO)
formatter = logging.Formatter("%(asctime)s - %(funcName)s - %(levelname)s : %(message)s", "%Y-%m-%d %H:%M:%S")
log_file_handler = TimedRotatingFileHandler(filename="logs/%s.log" % module, when="D", interval=1, backupCount=7)
log_file_handler.suffix = "%Y%m%d"
log_file_handler.extMatch = re.compile(r"^\d{4}\d{2}\d{2}$")
log_file_handler.setFormatter(formatter)
log_file_handler.setLevel(logging.DEBUG)
self.logger.addHandler(log_file_handler)
def setup_log():
log_format = "%(asctime)s.%(msecs)03d %(levelname)s %(module)s - %(funcName)s: %(message)s"
log_level = logging.DEBUG
handler = TimedRotatingFileHandler("log/{}.log".format(DEFAULT_APP_NAME), when="midnight", interval=1)
handler.setLevel(log_level)
formatter = logging.Formatter(log_format)
handler.setFormatter(formatter)
handler.suffix = "%Y%m%d"
handler.extMatch = re.compile(r"^\d{8}$")
logger.setLevel(log_level)
logger.addHandler(handler)
def top_log():
log = logging.getLogger("zj_aiops_run.log")
log.setLevel(logging.INFO)
log_fmt = '%(asctime)s [%(module)s] %(levelname)s [%(lineno)d] %(message)s'
formatter = logging.Formatter(log_fmt, '%Y-%m-%d_%H-%M')
# create TimedRotatingFileHandler object
log_file_handler = TimedRotatingFileHandler(filename="sql_anomy_detect.log", when="M", interval=3, backupCount=2)
log_file_handler.suffix = "%Y-%m-%d_%H-%M.log"
log_file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}.log$")
log_file_handler.setFormatter(formatter)
log.addHandler(log_file_handler)
return log
def _setup_log_file(self: classmethod, name: str):
logger = logging.getLogger(name)
if os.path.isdir('./log') is not True:
os.mkdir('./log')
log_path = './log/latest.log'
logger.setLevel(logging.INFO)
file_handler = TimedRotatingFileHandler(filename=log_path, when="MIDNIGHT", interval=1, backupCount=30)
file_handler.suffix = "%Y-%m-%d.log"
file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}.log$")
file_handler.setFormatter(logging.Formatter("[%(asctime)s][%(module)s.%(funcName)s(%(filename)s:%(lineno)d)][%(process)d][%(levelname)s]:%(message)s"))
logger.addHandler(file_handler)
return logger
def log_init():
filename = time.strftime('%Y-%m-%d', time.localtime(time.time()))
log_fmt = '%(asctime)s\tFile \"%(filename)s\",line %(lineno)s\t%(levelname)s: %(message)s'
formatter = logging.Formatter(log_fmt)
log_file_handler = TimedRotatingFileHandler(logname="/Users/xiaoweiyu/PycharmProjects/Python-Selenium-UIAutomator/log/"+filename+".log",
when="D", interval=1, backupCount=7)
log_file_handler.suffix = "%Y-%m-%d_%H-%M.log"
log_file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}.log$")
log_file_handler.setFormatter(formatter)
log_file_handler.setLevel(logging.DEBUG)
log = logging.getLogger()
log.addHandler(log_file_handler)
def _get_file_handler(log_name):
# create time rotating file handler
fh = TimedRotatingFileHandler(LOG_PATH + '/%s' % log_name, 'W0',
interval=2, backupCount=12
)
fh.suffix = "%Y-%m-%d.log"
fh.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}.log$")
formatter = logging.Formatter(
'%(asctime)s - p%(process)s - %(pathname)s:%(lineno)d - %(levelname)s - %(message)s'
)
fh.setFormatter(formatter)
return fh
def _config_log(self):
logger = logging.getLogger(comconstants.LOG_NAME_ANALYSIS)
logger.setLevel(logging.INFO)
log_file_name = ospath.join(self.log_path, 'analysis')
file_handler = TimedRotatingFileHandler(log_file_name, 'D', 1)
file_handler.suffix = "%Y-%m-%d.log"
file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}.log$")
file_handler.setLevel(logging.INFO)
formatter = logging.Formatter(
'[%(levelname)s][%(asctime)s][%(name)s]: %(message)s')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
def __init__(self, logger=None):
self.logger = logging.getLogger(logger)
self.logger.setLevel(logging.INFO)
log_filename = '/log/medical_Service.log'
fileTimeHandler = TimedRotatingFileHandler(log_filename, "midnight", 1,
7)
fileTimeHandler.suffix = "%Y-%m-%d.log"
fileTimeHandler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}.log$")
formatter = logging.Formatter(
'%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
fileTimeHandler.setFormatter(formatter)
self.logger.addHandler(fileTimeHandler)
fileTimeHandler.close()
def logset(logs_path):
"""
set the log format
"""
log = logging.getLogger()
log.setLevel(logging.INFO)
log_fmt = '%(asctime)s %(filename)s %(levelname)-8s: %(message)s'
formatter = logging.Formatter(log_fmt)
log_file_handler = TimedRotatingFileHandler(filename=logs_path + '/mongo_backup_log', when='D', interval=7, backupCount=10)
log_file_handler.suffix = "%Y-%m-%d-%H-%M.log"
log_file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}-\d{2}-\d{2}.log$")
log_file_handler.setFormatter(formatter)
log.addHandler(log_file_handler)
return log
def get_logger():
logger = logging.getLogger("logger")
if not logger.handlers:
logger.setLevel(logging.INFO)
handler = TimedRotatingFileHandler(filename=cfg.log_path,
when="D",
interval=1,
backupCount=90)
handler.suffix = "%Y-%m-%d.log"
handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}.log$")
handler.setLevel(logging.INFO)
handler.setFormatter(
logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))
logger.addHandler(handler)
return logger
def setLog():
logging.basicConfig(level=logging.DEBUG)
log_file_handler = TimedRotatingFileHandler(filename="crawler",
when="D",
interval=1,
backupCount=3)
log_file_handler.suffix = "%Y-%m-%d.log"
log_file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}.log$")
log_fmt = '%(asctime)s\tFile \"%(filename)s\",line %(lineno)s\t%(levelname)s: %(message)s'
formatter = logging.Formatter(log_fmt)
log_file_handler.setFormatter(formatter)
log_with_handler = logging.getLogger()
log_with_handler.addHandler(log_file_handler)
return log_with_handler
def log_init():
log_fmt = '%(asctime)s\tFile \"%(filename)s\",line %(lineno)s\t%(levelname)s: %(message)s'
formatter = logging.Formatter(log_fmt)
log_file_handler = TimedRotatingFileHandler(filename=__curpath__ +
"syslog",
when="D",
interval=1,
backupCount=7)
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.addHandler(log_file_handler)
return log
def log_init():
logger = logging.getLogger("FDService")
logger.setLevel(logging.INFO)
formatter = logging.Formatter(
"[%(levelname)s] %(asctime)s [%(filename)s][%(process)d] %(message)s")
log_file_handler = TimedRotatingFileHandler(filename=LOG_PATH + "fdlog",
when="midnight",
interval=1,
backupCount=7)
log_file_handler.suffix = "%Y-%m-%d_%H-%M.log"
log_file_handler.extMatch = re.compile(
r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}.log$")
log_file_handler.setFormatter(formatter)
logger.addHandler(log_file_handler)
return logger, log_file_handler
def init_app(cls, app):
Config.init_app(app)
# email errors to the administrators
import logging
logging.basicConfig(level=logging.INFO)
log_fmt = '%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s'
formatter = logging.Formatter(log_fmt)
log_file_handler = TimedRotatingFileHandler(filename=base_dir +
'/%s.log' % 'error',
when="D",
backupCount=7)
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)
def init_logger(log_path="d:\\temp", log_name="result"):
log_fmt = "%(asctime)-15s %(message)s"
formatter = logging.Formatter(log_fmt)
filename = log_path + "/" + log_name + ".log"
log_file_handler = TimedRotatingFileHandler(filename=filename, when="D", interval=1, backupCount=5)
log_file_handler.suffix = "%Y-%m-%d"
log_file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}$")
log_file_handler.setFormatter(formatter)
log_screen_handler = logging.StreamHandler()
log_screen_handler.setFormatter(formatter)
logger = logging.getLogger()
logger.setLevel(logging.INFO)
logger.addHandler(log_file_handler)
logger.addHandler(log_screen_handler)
return logger
