260 lines
8.2 KiB
Python
260 lines
8.2 KiB
Python
# -------------------------------
|
|
# Difficult Rocket
|
|
# Copyright © 2020-2023 by shenjackyuanjie 3695888@qq.com
|
|
# All rights reserved
|
|
# -------------------------------
|
|
import time
|
|
|
|
from string import Template
|
|
from typing import List, Union, Optional, Dict, Tuple
|
|
|
|
from lib_not_dr.types.options import Options
|
|
from lib_not_dr.logger.structers import LogMessage, FormattingMessage
|
|
|
|
|
|
class BaseFormatter(Options):
|
|
name = 'BaseFormatter'
|
|
|
|
sub_formatter: List['BaseFormatter'] = []
|
|
default_template: str = '${log_time}|${logger_name}|${logger_tag}|${level}|${messages}'
|
|
|
|
@classmethod
|
|
def add_info(cls, match: str, to: str, description: str) -> str:
|
|
return f'- {to} -> ${{{match}}} : {description}'
|
|
|
|
@classmethod
|
|
def info(cls) -> str:
|
|
infos = {BaseFormatter.name: BaseFormatter._info()}
|
|
cache = ''
|
|
for formatter in cls.sub_formatter:
|
|
infos[formatter.name] = formatter._info()
|
|
infos[cls.name] = cls._info()
|
|
for name, info in infos.items():
|
|
cache += f"## {name}\n"
|
|
cache += info
|
|
cache += '\n'
|
|
return cache
|
|
|
|
@classmethod
|
|
def _info(cls) -> str:
|
|
info = cls.add_info('logger_name', 'logger name', 'The name of the logger')
|
|
info += '\n'
|
|
info += cls.add_info('logger_tag', 'logger tag', 'The tag of the logger')
|
|
return info
|
|
|
|
def format_message(self,
|
|
message: LogMessage,
|
|
template: Optional[Union[Template, str]] = None) -> str:
|
|
"""
|
|
Format message
|
|
:param message: 输入的消息
|
|
:param template: 日志输出模板
|
|
:return:
|
|
"""
|
|
basic_info = message.format_for_message()
|
|
message, info = self._format((message, basic_info))
|
|
|
|
if template is None:
|
|
template = Template(self.default_template)
|
|
elif isinstance(template, str):
|
|
template = Template(template)
|
|
|
|
try:
|
|
return template.substitute(**info)
|
|
except (KeyError, ValueError):
|
|
return template.safe_substitute(**info)
|
|
|
|
def _format(self, message: FormattingMessage) -> FormattingMessage:
|
|
"""
|
|
Format message
|
|
:param message:
|
|
:return:
|
|
"""
|
|
for formatter in self.sub_formatter:
|
|
message = formatter._format(message)
|
|
return message
|
|
|
|
|
|
class TimeFormatter(BaseFormatter):
|
|
name = 'TimeFormatter'
|
|
|
|
time_format: str = '%Y-%m-%d %H:%M:%S'
|
|
msec_time_format: str = '{}-{:03d}'
|
|
|
|
@classmethod
|
|
def _info(cls) -> str:
|
|
return cls.add_info('log_time', 'formatted time when logging', 'The time format string'
|
|
'. See https://docs.python.org/3/library/time.html#time.strftime for more information.')
|
|
|
|
def _format(self, message: FormattingMessage) -> FormattingMessage:
|
|
time_mark = time.localtime(message[0].log_time / 1000000000)
|
|
if self.msec_time_format:
|
|
time_mark = self.msec_time_format.format(time.strftime(self.time_format, time_mark),
|
|
message[0].create_msec_3)
|
|
message[1]['log_time'] = time_mark
|
|
return message
|
|
|
|
|
|
class LevelFormatter(BaseFormatter):
|
|
name = 'LevelFormatter'
|
|
|
|
default_level: int = 20
|
|
|
|
# If True, the undefined level will be set to the higher nearest level.
|
|
level_get_higher: bool = True
|
|
|
|
level_name_map = {
|
|
0: 'NOTSET',
|
|
2: 'TRACE',
|
|
5: 'FINE',
|
|
7: 'DEBUG',
|
|
10: 'INFO',
|
|
30: 'WARN',
|
|
50: 'ERROR',
|
|
90: 'FATAL'
|
|
}
|
|
name_level_map = {
|
|
'NOTSET': 0,
|
|
'TRACE': 2,
|
|
'FINE': 5,
|
|
'DEBUG': 7,
|
|
'INFO': 10,
|
|
'WARN': 30,
|
|
'ERROR': 50,
|
|
'FATAL': 90
|
|
}
|
|
|
|
@classmethod
|
|
def _info(cls) -> str:
|
|
return cls.add_info('level', 'log level', 'The log level')
|
|
|
|
def _format(self, message: FormattingMessage) -> FormattingMessage:
|
|
if message[0].level in self.name_level_map:
|
|
level_tag = self.level_name_map[message[0].level]
|
|
else:
|
|
if self.level_get_higher:
|
|
for level in self.name_level_map:
|
|
if message[0].level < self.name_level_map[level]:
|
|
level_tag = level
|
|
break
|
|
else:
|
|
level_tag = 'FATAL'
|
|
else:
|
|
for level in self.name_level_map:
|
|
if message[0].level > self.name_level_map[level]:
|
|
level_tag = level
|
|
break
|
|
else:
|
|
level_tag = 'NOTSET'
|
|
message[1]['level'] = level_tag
|
|
return message
|
|
|
|
|
|
class TraceFormatter(BaseFormatter):
|
|
name = 'TraceFormatter'
|
|
|
|
@classmethod
|
|
def _info(cls) -> str:
|
|
info = cls.add_info('logging file', 'log_source', 'the logging file name')
|
|
info += '\n'
|
|
info += cls.add_info('logging line', 'log_line', 'the logging line number')
|
|
info += '\n'
|
|
info += cls.add_info('logging function', 'log_function', 'the logging function name')
|
|
return info
|
|
|
|
def _format(self, message: FormattingMessage) -> FormattingMessage:
|
|
if message[0].stack_trace is None:
|
|
return message
|
|
message[1]['log_source'] = message[0].stack_trace.f_code.co_filename
|
|
message[1]['log_line'] = message[0].stack_trace.f_lineno
|
|
message[1]['log_function'] = message[0].stack_trace.f_code.co_name
|
|
return message
|
|
|
|
|
|
class LevelColorFormatter(BaseFormatter):
|
|
name = 'LevelColorFormatter'
|
|
|
|
enable_color: bool = True
|
|
|
|
@staticmethod
|
|
def _default_color() -> Dict[int, Tuple[str, str]]:
|
|
return {
|
|
# Notset: just black
|
|
0: ('', ''),
|
|
# Trace: blue
|
|
2: ('\033[0;34m', '\033[0m'),
|
|
# Fine: green
|
|
5: ('\033[0;32m', '\033[0m'),
|
|
# Debug: cyan
|
|
7: ('\033[0;36m', '\033[0m'),
|
|
# Info: white
|
|
10: ('\033[0;37m', '\033[0m'),
|
|
# Warn: yellow
|
|
30: ('\033[0;33m', '\033[0m'),
|
|
# Error: red
|
|
50: ('\033[0;31m', '\033[0m'),
|
|
# Fatal: red
|
|
90: ('\033[0;31m', '\033[0m')
|
|
}
|
|
|
|
@classmethod
|
|
def _info(cls) -> str:
|
|
info = cls.add_info('colored message', 'message', 'A colored message')
|
|
info += '\n'
|
|
info += cls.add_info('colored level', 'level', 'A colored level')
|
|
info += '\n'
|
|
info += cls.add_info('colored logger name', 'logger_name', 'A colored logger name')
|
|
return info
|
|
|
|
def _format(self, message: FormattingMessage) -> FormattingMessage:
|
|
if message[1].get('level') is None:
|
|
return message
|
|
# 向上寻找等级
|
|
for level in self._default_color():
|
|
if message[0].level < level:
|
|
break
|
|
else:
|
|
level = 90
|
|
# 获取颜色
|
|
color = self._default_color()[level]
|
|
# 添加颜色
|
|
message[1]['messages'] = f'{color[0]}{message[1]["messages"]}{color[1]}'
|
|
message[1]['level'] = f'{color[0]}{message[1]["level"]}{color[1]}'
|
|
message[1]['logger_name'] = f'{color[0]}{message[1]["logger_name"]}{color[1]}'
|
|
return message
|
|
|
|
|
|
class StdFormatter(BaseFormatter):
|
|
name = 'StdFormatter'
|
|
|
|
sub_formatter = [TimeFormatter(), LevelFormatter(), TraceFormatter(), LevelColorFormatter()]
|
|
|
|
@classmethod
|
|
def _info(cls) -> str:
|
|
return 'None'
|
|
|
|
|
|
if __name__ == '__main__':
|
|
import inspect
|
|
|
|
log_message = LogMessage(messages=['Hello World!'],
|
|
level=10,
|
|
stack_trace=inspect.currentframe(),
|
|
logger_tag='tester',
|
|
logger_name='test')
|
|
|
|
print(TimeFormatter.info())
|
|
print(TimeFormatter().format_message(log_message))
|
|
|
|
print(LevelFormatter.info())
|
|
print(LevelFormatter().format_message(log_message))
|
|
|
|
print(TraceFormatter.info())
|
|
print(TraceFormatter().format_message(log_message))
|
|
|
|
print(LevelColorFormatter.info())
|
|
print(LevelColorFormatter().format_message(log_message))
|
|
|
|
print(StdFormatter.info())
|
|
print(StdFormatter().format_message(log_message))
|