def __init__(self, file_name, level='info', when='D'):
self.logger = logging.getLogger()
self.logger.setLevel(self.log_level(level))
log_file_name = os.path.join(LOG_PATH, file_name)
#文本对象
self.filelogger = handlers.TimedRotatingFileHandler(
filename=log_file_name, backupCount=10, encoding='utf8', when=when)
#控制台输出对象
self.consolelogger = logging.StreamHandler()
self.consolelogger.setLevel(self.log_level(level))
#日志格式
self.formater = logging.Formatter(
'[%(asctime)s] [%(levelname)s] [%(filename)s:%(funcName)s:%(lineno)d] %(message)s'
)
self.filelogger.setFormatter(self.formater)
self.consolelogger.setFormatter(self.formater)
self.logger.addHandler(self.filelogger)
self.logger.addHandler(self.consolelogger)
def init_logging(debug=False):
formatter = logging.Formatter("%(asctime)s %(levelname)s:%(module)s:%(threadName)s - %(message)s")
log = logging.getLogger()
if not os.path.exists(os.path.join(CUCKOO_ROOT, "log")):
os.makedirs(os.path.join(CUCKOO_ROOT, "log"))
fh = handlers.TimedRotatingFileHandler(os.path.join(CUCKOO_ROOT, "log", "dist.log"), when="midnight", backupCount=10)
fh.setFormatter(formatter)
log.addHandler(fh)
handler_stdout = logging.StreamHandler(sys.stdout)
handler_stdout.setFormatter(formatter)
log.addHandler(handler_stdout)
if debug:
log.setLevel(logging.DEBUG)
else:
log.setLevel(logging.INFO)
return log
def __init__(
self,
filename,
level='info',
when='D',
backCount=3,
fmt='%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s'
):
self.logger = logging.getLogger(filename)
format_str = logging.Formatter(fmt)
self.logger.setLevel(self.level_relations.get(level))
sh = logging.StreamHandler()
sh.setFormatter(format_str)
th = handlers.TimedRotatingFileHandler(filename=filename,
when=when,
backupCount=backCount,
encoding='utf-8')
th.setFormatter(format_str)
self.logger.addHandler(sh)
self.logger.addHandler(th)
def __init__(
self,
filename,
level='info',
when='D',
backCount=3,
fmt='%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s'
):
self.logger = logging.getLogger(filename)
format_str = logging.Formatter(fmt) #设置日志格式
self.logger.setLevel(self.level_relations.get(level)) #设置日志级别
sh = logging.StreamHandler() #往屏幕上输出
sh.setFormatter(format_str) #设置屏幕上显示的格式
th = handlers.TimedRotatingFileHandler(
filename=filename,
when=when,
backupCount=backCount,
encoding='utf-8') #往文件里写入#指定间隔时间自动生成文件的处理器
th.setFormatter(format_str) #设置文件里写入的格式
self.logger.addHandler(sh) #把对象加到logger里
def init_log_handler(self):
# 创建log_name目录
root_path = self.get_config('root_path')
log_path = root_path + os.path.sep + 'logs' + os.path.sep + self.get_log_name(
)
if not os.path.exists(log_path):
os.makedirs(log_path)
path_file = log_path + '/' + self.__file_name
logging.basicConfig()
main_log = logging.getLogger(self.get_log_name())
main_log.setLevel(self.get_log_level())
handler = handlers.TimedRotatingFileHandler(
path_file, when='D', backupCount=self.__backupCount, interval=1)
handler.suffix = '%Y-%m-%d.log'
# handler.setFormatter(logging.Formatter('%(asctime)s %(pathname)s[line:%(lineno)d][%(levelname)s] %(message)s'))
handler.setFormatter(
logging.Formatter('%(asctime)s [%(levelname)s] %(message)s'))
main_log.addHandler(handler)
self.set_log_handler(main_log)
def init_log(self, level=logging.INFO, path_folder_logs="../logs/"):
formatter = logging.Formatter(
'%(asctime)s|%(levelname)s|%(filename)30s|%(funcName)40s| %(lineno)3d| %(message)s'
)
if not os.path.exists(path_folder_logs):
os.makedirs(path_folder_logs)
log_file = path.join(path_folder_logs,
str(datetime.date.today()) + ".log")
self.logger.setLevel(level)
file_handler = handlers.TimedRotatingFileHandler(log_file,
when='d',
interval=1,
backupCount=100,
encoding='utf-8')
console_handler = logging.StreamHandler()
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
self.logger.addHandler(file_handler)
self.logger.addHandler(console_handler)
return self.logger
def __init__(
self,
name,
file_name="{}/logs/all.log".format(path),
when='S',
interval=0,
backupCount=5,
level=0,
fmt='%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s',
encoding='utf-8',
**kw):
# 初始化logger,并设置日志级别
self.logger = logging.Logger(name)
self.logger.setLevel(level)
# 设置日志格式
log_format = logging.Formatter(fmt)
# 判断以什么格式输出
if not file_name:
handler = logging.StreamHandler()
else:
# 往文件里写入,指定间隔时间自动生成文件的处理器
handler = handlers.TimedRotatingFileHandler(
filename=file_name,
when=when,
backupCount=backupCount,
encoding=encoding)
# 实例化TimedRotatingFileHandler
# interval是时间间隔，backupCount是备份文件的个数，如果超过这个个数，就会自动删除，when是间隔的时间单位，单位有以下几种：
# S 秒
# M 分
# H 小时
# D 天
# W{0-6} 星期几（interval=0时代表星期一）
# midnight 每天凌晨
# 设置处理器的级别
handler.setLevel(level)
# 设置处理器的格式
handler.setFormatter(log_format)
# 处理器添加到收集器里面
self.logger.addHandler(handler)
print(handler)
def __init__(self):
self.logger = logging.getLogger(__name__)
#设置日志输出格式
format_str = logging.Formatter(
'%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s'
)
#设置日志级别
self.logger.setLevel(logging.INFO)
#往屏幕上输出
sh = logging.StreamHandler()
#设置屏幕上显示的格式
sh.setFormatter(format_str)
if not os.path.exists(LOG_PATH):
os.mkdir(LOG_PATH)
# xxx/logs/2019-9-5.txt
filename = "%s/%s.txt" % (LOG_PATH, datetime.date.today())
"""
往文件里写入指定间隔时间自动生成文件的处理器
实例化TimedRotatingFileHandler
interval是时间间隔，backupCount是备份文件的个数，如果超过这个个数，就会自动删除，when是间隔的时间单位，单位有以下几种：
S 秒
M 分
H 小时、
D 天、
W 每星期（interval==0时代表星期一）
midnight 每天凌晨
"""
th = handlers.TimedRotatingFileHandler(filename=filename,
when="D",
backupCount=3,
encoding='utf-8')
#设置文件里写入的格式
th.setFormatter(format_str)
#把对象加到logger里
self.logger.addHandler(sh)
self.logger.addHandler(th)
def __init__(
self,
filename,
level='info',
when='H',
interval=1,
backCount=720,
fmt='%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s'
):
self.logger = logging.getLogger(filename)
format_str = logging.Formatter(fmt) #设置日志格式
self.logger.setLevel(self.level_relations.get(level)) #设置日志级别
#sh = logging.StreamHandler()#往屏幕上输出
#sh.setFormatter(format_str) #设置屏幕上显示的格式
th = handlers.TimedRotatingFileHandler(
filename=filename,
when=when,
interval=1,
backupCount=backCount,
encoding='utf-8') #往文件里写入#指定间隔时间自动生成文件的处理器
#实例化TimedRotatingFileHandler
#interval是时间间隔，backupCount是备份文件的个数，如果超过这个个数，就会自动删除，when是间隔的时间单位，单位有以下几种：
# S 秒
# M 分
# H 小时、
# D 天、
# W 每星期（interval==0时代表星期一）
# midnight 每天凌晨
th.setFormatter(format_str) #设置文件里写入的格式
#self.logger.addHandler(sh) #把对象加到logger里
self.logger.addHandler(th)
# if __name__ == '__main__':
# log = Logger('all.log',level='debug')
# log.logger.debug('debug')
# log.logger.info('info')
# log.logger.warning('警告')
# log.logger.error('报错')
# log.logger.critical('严重')
# Logger('error.log', level='error').logger.error('error')
def __init__(
self,
filename='logging/logging.log',
level='debug',
when='D',
backup_count=3,
formatter_str='[%(asctime)s] %(levelname)s %(pathname)s %(module)s:%(lineno)d行: %(message)s'
):
"""
默认的日志文件路径为 logging/logging.log，默认等级为 debug
"""
self.logger = logging.getLogger(__name__)
self.logger.handlers.clear() # 如果不清除handlers，则可能会使日志重复输出
self.logger.setLevel(self.level_relations.get(level))
formatter = logging.Formatter(formatter_str,
datefmt='%Y-%m-%d %H:%M:%S')
# 往屏幕上输出
sh = logging.StreamHandler()
# 设置屏幕上显示的格式
sh.setFormatter(formatter)
# 往文件里写入，并指定间隔时间自动生成文件
th = handlers.TimedRotatingFileHandler(filename=filename,
when=when,
backupCount=backup_count,
encoding='utf-8')
# 实例化TimedRotatingFileHandler
# interval是时间间隔，backup_count是备份文件的个数，如果超过这个个数，就会自动删除，when是间隔的时间单位，单位有以下几种：
# S 秒
# M 分
# H 小时、
# D 天、
# W 每星期（interval==0时代表星期一）
# midnight 每天凌晨
th.setFormatter(formatter)
self.logger.addHandler(sh)
self.logger.addHandler(th)
def __init__(self, eps1, eps2, alpha1, alpha2):
"""
Create, if not exists, the result path for storing the episoded dataset
"""
self.eps1 = eps1
self.eps2 = eps2
self.alpha1 = alpha1
self.alpha2 = alpha2
self.espisodePath = os.path.join(
self.rootResultFolder, "episodes_%d_%d_%d_%d" %
(self.eps1, self.eps2, self.alpha1, self.alpha2))
self.synthetcBlowPath = os.path.join(
self.rootResultFolder, self.synthetcBlowPath %
(self.eps1, self.eps2, self.alpha1, self.alpha2))
# creates log folder
if not os.path.exists(self.logFolder):
os.makedirs(self.logFolder)
if not os.path.exists(self.rootResultFolder):
os.makedirs(self.rootResultFolder)
if not os.path.exists(self.espisodePath):
os.makedirs(self.espisodePath)
logPath = os.path.join(self.logFolder, "Demetra.log")
rotateHandelr = loghds.TimedRotatingFileHandler(logPath,
when="H",
interval=6,
backupCount=5)
rotateHandelr.setFormatter(formatter)
rotateHandelr.setLevel(logging.DEBUG)
logger.addHandler(rotateHandelr)
self.timeIndex = self.dataHeader[0]
self.nameIndex = self.dataHeader[1]
# used for determining when an episode start in charge or discharge
self.currentIndex = self.dataHeader[16]
self.voltageIndex = self.dataHeader[17]
logger.debug("Indexes: Current %s Volt %s " %
(self.currentIndex, self.voltageIndex))
def set_logger(mode=1, path="logs", name='parrot.log', level='info'):
"""
:param mode: 1-on screen, 2-in log file, 3-both 1&2
:param path: log path, 'None' - <project path>/logs
:param name: log file name
:param level: debug / info / warn / error
"""
level_map = {
'debug': logging.DEBUG,
'info': logging.INFO,
'warn': logging.WARN,
'error': logging.ERROR
}
if mode not in (1, 2, 3):
mode = 1
if str(level).lower() not in level_map.keys():
level = 'info'
log_file = "{}/{}".format(path, name)
# logger = logging.getLogger(log_file)
logger.name = log_file
# define log format
fmt = logging.Formatter('[%(asctime)s] [%(levelname)s] %(message)s')
logger.setLevel(level_map.get(level))
if mode in (1, 3):
# define screen stream handler
sh = logging.StreamHandler()
sh.setFormatter(fmt)
logger.addHandler(sh)
if mode in (2, 3):
make_dir(path)
# define log file handler, backup per week
fh = handlers.TimedRotatingFileHandler(filename=log_file,
when='W0',
backupCount=4,
encoding='utf-8')
fh.setFormatter(fmt)
logger.addHandler(fh)
def configure_logging():
'''
This function configures logging for the SILPA applications using Flask's
internal logger.
For now log file will be rotated 7 days once and 4 backups will be kept.
This can't be modified using configuration file as of now.
Default logging level will be ERROR and can be modified from
configuration file. Log folder and file name can also be configured using
configuration file but make sure the path you give is writable for
Webserver user, otherwise this will lead to an error.
'''
log_level = loadconfig.get('log_level')
log_folder = loadconfig.get('log_folder')
log_name = loadconfig.get('log_name')
filename = os.path.join(log_folder, log_name)
handler = handlers.TimedRotatingFileHandler(filename,
when='D',
interval=7,
backupCount=4)
level = logging.ERROR
if log_level == "debug":
level = logging.DEBUG
elif log_level == "info":
level = logging.INFO
elif log_level == "warn":
level = logging.WARNING
elif log_level == "error":
level = logging.ERROR
handler.setLevel(level)
handler.setFormatter(
Formatter('%(asctime)s %(levelname)s: %(message)s \
[in %(pathname)s %(lineno)d]'))
app.logger.setLevel(level)
app.logger.addHandler(handler)
def __initialize(self):
if config.level == "debug":
level = logging.DEBUG
elif config.level == "info":
level = logging.INFO
elif config.level == "warning":
level = logging.WARNING
elif config.level == "error":
level = logging.ERROR
elif config.level == "critical":
level = logging.CRITICAL
else:
level = logging.DEBUG
self.__logger.setLevel(level=level)
formatter = logging.Formatter(
fmt='[%(asctime)s] -> [%(levelname)s] : %(message)s')
# 文件输出按照时间分割
time_rotating_file_handler = handlers.TimedRotatingFileHandler(
filename=self.__path, when='MIDNIGHT', interval=1, backupCount=10)
time_rotating_file_handler.setFormatter(formatter)
time_rotating_file_handler.suffix = "%Y%m%d-%H%M%S.log"
# 控制台输出
console_formatter = colorlog.ColoredFormatter(
fmt='%(log_color)s[%(asctime)s] -> [%(levelname)s] : %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
log_colors=log_colors_config)
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(console_formatter)
# 文件输出按照大小分割
rotatingHandler = ConcurrentRotatingFileHandler(
self.__path, "a", 1024 * 1024, 10) # a为追加模式，按1M大小分割,保留最近10个文件
rotatingHandler.setFormatter(formatter)
if config.handler == "time":
self.__logger.addHandler(time_rotating_file_handler)
elif config.handler == "file":
self.__logger.addHandler(rotatingHandler)
else:
self.__logger.addHandler(stream_handler)
def __init__(self, filename):
# 定义日志文件和日志格式
self.file_name = filename
self.file_path = os.path.dirname(
os.path.abspath(__file__)) + "\\" + self.file_name
fmt = '%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s'
# 创建logger对象
self.logger = logging.getLogger(filename)
# 设置日志格式化
format_str = logging.Formatter(fmt)
# 设置日志级别
self.logger.setLevel(logging.DEBUG)
# 创建屏幕日志显示对象
self._ch = logging.StreamHandler()
self._ch.setFormatter(format_str)
# 创建保存日志文件对象
self._fh = handlers.TimedRotatingFileHandler(filename=self.file_path,
when='D',
encoding='utf-8')
self._fh.setFormatter(format_str)
def __init__(self, file_name, level='info', backCount=5, when='D'):
logger = logging.getLogger() # 先实例化一个logger对象，先创建一个办公室
logger.setLevel(self.get_level(level)) # 设置日志的级别的人
# 控制台日志
cl = logging.StreamHandler()
# 文件日志
bl = handlers.TimedRotatingFileHandler(
filename=file_name, # 文件名称
when=when, # 生成日志的规则,'S'表示秒,'M'表示分钟
interval=1, # 生成日志的频率,根据规则按照频率生成日志文件
backupCount=backCount, # 日志限制数量，超出则删除之前的日志
encoding='utf-8') # 日志文件编码格式
# 日志输出的格式
fmt = logging.Formatter(
'%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s'
)
cl.setFormatter(fmt) # 设置控制台输出的日志格式
bl.setFormatter(fmt) # 设置文件里面写入的日志格式
logger.addHandler(cl)
logger.addHandler(bl)
self.logger = logger
def get_logger(cls, logger_name):
_logger = logging.getLogger(logger_name)
_logger.setLevel(cls.level_relations.get(cls._logger_lvl))
format_str = logging.Formatter(cls._logger_format_str)
sh = logging.StreamHandler()
th = handlers.TimedRotatingFileHandler(filename=logger_name,
when=cls._logger_rotate_cycle,
backupCount=3,
encoding='utf-8')
# 实例化TimedRotatingFileHandler
# interval是时间间隔，backupCount是备份文件的个数，如果超过这个个数，就会自动删除，when是间隔的时间单位，单位有以下几种：
# S 秒
# M 分
# H 小时、
# D 天、
# W 每星期（interval==0时代表星期一）
# midnight 每天凌晨
th.setFormatter(format_str) # 设置文件里写入的格式
_logger.addHandler(sh) # 把对象加到logger里
_logger.addHandler(th)
return _logger
def setup_logger():
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(
logging.Formatter(
"%(asctime)s [%(levelname)s] - %(filename)s - %(message)s"))
stream_handler.setLevel(logging.INFO)
file_handler = handlers.TimedRotatingFileHandler(
filename=os.getcwd() + "/logs/discord/discord.log",
when="midnight",
backupCount=1,
encoding="utf-8",
)
file_handler.setFormatter(
logging.Formatter(
"%(asctime)s [%(levelname)s] - %(filename)s - %(message)s"))
file_handler.setLevel(logging.INFO)
logger = logging.getLogger("discord")
logger.addHandler(stream_handler)
logger.addHandler(file_handler)
logger.setLevel(logging.INFO)
return logger
def _SetupLogging(options):
"""Set up default logging for the command.
Removes any pre-installed logging handlers, and installs a single
`TimedRotatingFileHandler` that will write to the default log file
in the log directory specified on the command line.
Args:
options: Results of parsing the command line; used to obtain the
log directory path.
"""
logger = logging.getLogger()
for h in list(logger.handlers):
logger.removeHandler(h)
logfile = os.path.join(options.logdir, _LOG_FILENAME)
handler = handlers.TimedRotatingFileHandler(logfile,
when='W4',
backupCount=13)
handler.setFormatter(copy_handler.LOG_FORMATTER)
logger.setLevel(logging.DEBUG)
logger.addHandler(handler)
def __init__(self,filename,level='info',when='D',backCount=3,fmt='%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s'):
'''
filename
'''
self.logger = logging.getLogger(filename)
format_str = logging.Formatter(fmt)#设置日志格式
self.logger.setLevel(self.level_relations.get(level))#设置日志级别
sh = logging.StreamHandler()#往屏幕上输出
sh.setFormatter(format_str) #设置屏幕上显示的格式
th = handlers.TimedRotatingFileHandler(filename=filename,when=when,backupCount=backCount,encoding='utf-8')#往文件里写入#指定间隔时间自动生成文件的处理器
#实例化TimedRotatingFileHandler
#interval是时间间隔，backupCount是备份文件的个数，如果超过这个个数，就会自动删除，when是间隔的时间单位，单位有以下几种：
# S 秒
# M 分
# H 小时、
# D 天、
# W 每星期（interval==0时代表星期一）
# midnight 每天凌晨
th.setFormatter(format_str)#设置文件里写入的格式
self.logger.addHandler(sh) #把对象加到logger里
self.logger.addHandler(th)
def log_train(gpu_memory, gpu_util, start, epoch, batch_size):
end = time.time() # end time
LogFormatter = logging.Formatter('%(asctime)s,%(message)s')
now = datetime.datetime.now()
nowDateTime = now.strftime('%Y-%m-%d %H:%M:%S')
filename = nowDateTime + '_train.log'
LogHandler = handlers.TimedRotatingFileHandler(filename='./log/train/{}'.format(filename), interval = 1, encoding='utf-8')
LogHandler.setFormatter(LogFormatter)
LogHandler.suffix = "%Y%m%d"
#logger set
Logger = logging.getLogger()
Logger.setLevel(logging.DEBUG)
Logger.addHandler(LogHandler)
#use logger
gpus = GPUtil.getGPUs()
contents = str(gpus[0].name) + ", memory_used= " + str(gpu_memory) + "/" + str(gpus[0].memoryTotal) + ", max_utilization= " + str(gpu_util) + ", epoch= " + str(epoch) + ", batch_size= " + str(batch_size) + ", learning_time= " + str(end - start)
print(contents)
Logger.debug(contents)
def get_file_logger(name):
logger = logging.getLogger(name)
# 单例模式，如果已经注册了filehandler，直接返回logger
if logger.handlers:
return logger
formatter = Formatter('%(asctime)s\t%(message)s', '%Y-%m-%d %H:%M:%S')
log_dir = os.path.join('/var/log/flask', name)
if not os.path.isdir(log_dir):
os.makedirs(log_dir)
filename = os.path.join(log_dir, '{}.log'.format(str(date.today())))
handler = handlers.TimedRotatingFileHandler(filename,
when='D',
backupCount=7,
delay=False,
encoding='utf-8')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.INFO)
return logger
def __init__(
self,
filename,
level='info',
when='midnight',
interval=90,
backCount=3,
fmt='%(asctime)s-%(pathname)s[lineno)d]-%(levelname)s:%(message)s'
):
self.logger = logging.getLogger(filename)
format_str = logging.Formatter(fmt)
self.logger.setLevel(self.level_realtion.get(level))
th = handlers.TimedRotatingFileHandler(filename=filename,
when=when,
interval=interval,
backupCount=backCount,
encoding='utf-8')
th.setFormatter(format_str)
self.logger.addHandler(th)
def logger(filename, module_name):
logging.basicConfig()
logger = logging.getLogger(module_name)
logger.setLevel(logging.DEBUG)
th = handlers.TimedRotatingFileHandler(filename=filename,
when="MIDNIGHT",
interval=1,
backupCount=3,
encoding='utf-8')
th.suffix = "%Y-%m-%d.log"
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
th.setFormatter(formatter)
th.setLevel(logging.DEBUG)
logger.addHandler(th)
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(formatter)
stream_handler.setLevel(logging.DEBUG)
logger.addHandler(stream_handler)
logger.removeHandler(stream_handler)
return logger
def __init__(self, _is_test):
self.logger = logging.getLogger(f'operator [{self.name}]')
if _is_test:
self.logger.setLevel(logging.DEBUG)
else:
self.logger.setLevel(logging.INFO)
# 会在工作目录下面创建文件夹logs，用于装载日志
os.makedirs('logs', exist_ok=True)
date_string = get_date_string()
log_format = f'%(asctime)s : %(levelname)s : %(process)d: %(thread)x: {self.name}: line %(lineno)d: %(message)s'
# 每天存储一个文件，存储31天，且文件名包含启动日期
log_file_handler = handlers.TimedRotatingFileHandler(
f'logs/{self.name}_{date_string}启动.log',
encoding='utf-8',
when='D',
interval=1,
backupCount=31)
log_file_handler.setFormatter(logging.Formatter(log_format))
self.logger.addHandler(log_file_handler)
self.is_test = _is_test
def create_logger(self) -> logging.Logger:
logger = logging.getLogger('petri')
logger.setLevel(logging.DEBUG)
fileHandler = handlers.TimedRotatingFileHandler(
f'/tmp/petri-{time.time()}.log',
when='M',
interval=1,
backupCount=2)
fileHandler.setFormatter(
logging.Formatter(
'%(asctime)s | %(name)s [%(levelname)s] %(message)s'))
logger.addHandler(fileHandler)
consoleHandler = logging.StreamHandler(sys.stdout)
consoleHandler.setLevel(logging.WARNING)
consoleHandler.setFormatter(logging.Formatter('[*] %(message)s'))
logger.addHandler(consoleHandler)
logger.info('Logger created.')
return logger
def __init__(self, log_filename, level='info', when='D', backCount=3):
self.logger = logging.getLogger(log_filename)
log_format_str = logging.Formatter(
'%(asctime)s - %(pathname)s[line:%(lineno)d] - '
'%(levelname)s - %(module)s : %(message)s') # Set format
console_format_str = logging.Formatter(
'%(asctime)s - %(levelname)s : %(message)s') # Set format
self.logger.setLevel(self.level_relations.get(level)) # Set log level
sh = logging.StreamHandler() # Print to console
sh.setFormatter(console_format_str)
# Write to file
th = handlers.TimedRotatingFileHandler(filename=log_filename,
when=when,
backupCount=backCount,
encoding='utf-8')
# Create a processor that automatically generates files at specified intervals
# 'backupCount' is the number of backup files. If it exceeds this number, it will be deleted automatically.
# 'when' is the time unit of the interval
th.setFormatter(log_format_str)
self.logger.addHandler(sh)
self.logger.addHandler(th)
def logError(message):
logger = logging.getLogger('error.log')
# 这里进行判断，如果logger.handlers列表为空，则添加，否则，直接去写日志
if not logger.handlers:
logger.setLevel(logging.INFO)
formatter = logging.Formatter(
'%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s'
)
sh = logging.StreamHandler()
th = handlers.TimedRotatingFileHandler(filename=log_error,
when="D",
interval=1,
backupCount=7,
encoding='utf-8')
sh.setFormatter(formatter)
th.setFormatter(formatter)
logger.addHandler(sh)
logger.addHandler(th)
logger.exception(message)
def init_logging():
"""Create and initialize a logger."""
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
frmt = logging.Formatter(
"[%(levelname)s] %(asctime)s |%(funcName)18s | %(message)s", "%m-%d %H:%M:%S"
)
# Make sure that there are not more than one handlers
if not logger.handlers:
console_handler = logging.StreamHandler(sys.stdout)
console_handler.setFormatter(frmt)
logger.addHandler(console_handler)
file_handler = handlers.TimedRotatingFileHandler(
"panda.log", when="d", interval=1, backupCount=3
)
file_handler.setFormatter(frmt)
logger.addHandler(file_handler)
return logger
def mylogger():
logger = logging.getLogger('mylogger')
logger.setLevel(logging.INFO)
if not logger.handlers:
rf_handler = handlers.TimedRotatingFileHandler("log/all.log",
when='midnight',
interval=1,
backupCount=7,
atTime=datetime.time(
0, 0, 0, 0))
rf_handler.setFormatter(
logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
f_handler = logging.FileHandler("log/error.log")
f_handler.setLevel(logging.ERROR)
f_handler.setFormatter(
logging.Formatter(
"%(asctime)s - %(levelname)s - %(filename)s[:%(lineno)d] - %(message)s"
))
logger.addHandler(rf_handler)
logger.addHandler(f_handler)
return logger
