def defLogging():
global debug
global logPath
global loggingLevel
global logging_setup
try:
if debug:
logging_setup = NestedSetup([
# make sure we never bubble up to the stderr handler
# if we run out of setup handling
NullHandler(),
StreamHandler(
sys.stdout,
bubble=False,
level=loggingLevel
),
TimedRotatingFileHandler(
logPath,
level=0,
backup_count=3,
bubble=True,
date_format='%Y-%m-%d',
),
])
else:
logging_setup = NestedSetup([
# make sure we never bubble up to the stderr handler
# if we run out of setup handling
NullHandler(),
FingersCrossedHandler(
TimedRotatingFileHandler(
logPath,
level=0,
backup_count=3,
bubble=False,
date_format='%Y-%m-%d',
),
action_level=ERROR,
buffer_size=1000,
# pull_information=True,
# reset=False,
)
])
except (KeyboardInterrupt, SystemExit):
raise
except:
print("Critical error attempting to setup logging. Falling back to console only.")
logging_setup = NestedSetup([
# make sure we never bubble up to the stderr handler
# if we run out of setup handling
NullHandler(),
StreamHandler(
sys.stdout,
bubble=False
)
])
def setup(name, path='log', enable_debug=False):
"""
Prepare a NestedSetup.
:param name: the channel name
:param path: the path where the logs will be written
:param enable_debug: do we want to save the message at the DEBUG level
:return a nested Setup
"""
path_tmpl = os.path.join(path, '{name}_{level}.log')
info = path_tmpl.format(name=name, level='info')
warn = path_tmpl.format(name=name, level='warn')
err = path_tmpl.format(name=name, level='err')
crit = path_tmpl.format(name=name, level='crit')
# a nested handler setup can be used to configure more complex setups
setup = [
# make sure we never bubble up to the stderr handler
# if we run out of setup handling
NullHandler(),
# then write messages that are at least info to to a logfile
TimedRotatingFileHandler(info, level='INFO', encoding='utf-8',
date_format='%Y-%m-%d'),
# then write messages that are at least warnings to to a logfile
TimedRotatingFileHandler(warn, level='WARNING', encoding='utf-8',
date_format='%Y-%m-%d'),
# then write messages that are at least errors to to a logfile
TimedRotatingFileHandler(err, level='ERROR', encoding='utf-8',
date_format='%Y-%m-%d'),
# then write messages that are at least critical errors to to a logfile
TimedRotatingFileHandler(crit, level='CRITICAL', encoding='utf-8',
date_format='%Y-%m-%d'),
]
if enable_debug:
debug = path_tmpl.format(name=name, level='debug')
setup.insert(1, TimedRotatingFileHandler(debug, level='DEBUG',
encoding='utf-8', date_format='%Y-%m-%d'))
if src_server is not None and smtp_server is not None \
and smtp_port != 0 and len(dest_mails) != 0:
mail_tmpl = '{name}_error@{src}'
from_mail = mail_tmpl.format(name=name, src=src_server)
subject = 'Error in {}'.format(name)
# errors should then be delivered by mail and also be kept
# in the application log, so we let them bubble up.
setup.append(MailHandler(from_mail, dest_mails, subject,
level='ERROR', bubble=True,
server_addr=(smtp_server, smtp_port)))
return NestedSetup(setup)
def handle(level):
return TimedRotatingFileHandler(
path('torabot.%s.log' % level),
date_format='%Y-%m-%d',
level=getattr(logbook, level.upper()),
bubble=True,
)
def basicConfig(outputFile=None,
level='INFO',
redirectLogging=False,
colorized=False,
loop=None):
if outputFile:
if platform.system() == 'Linux' and 0:
handler = AsyncDatedFileHandler(outputFile, date_format='%Y-%m-%d')
else:
handler = TimedRotatingFileHandler(outputFile,
level=level,
bubble=True,
date_format='%Y-%m-%d')
else:
if not colorized:
handler = StreamHandler(sys.stderr, level=level, bubble=True)
else:
handler = ColorizedHandler(level=level, bubble=True)
handler.force_color()
handler.format_string = mainFormatString
handler.push_application()
if redirectLogging:
redirect_logging()
redirect_warnings()
def __init__(self):
# 脚本日志
self.run_log = Logger("script_log")
# 日志存放路径
self.LOG_DIR = log_path
if not os.path.exists(self.LOG_DIR):
os.makedirs(self.LOG_DIR)
def log_type(record, handler):
log = "[{date}] [{level}] [{filename}] [{func_name}] [{lineno}] {msg}".format(
date=record.time, # 日志时间
level=record.level_name, # 日志等级
filename=os.path.split(record.filename)[-1], # 文件名
func_name=record.func_name, # 函数名
lineno=record.lineno, # 行号
msg=record.message) # 日志内容
return log
# 日志打印到屏幕
self.log_std = ColorizedStderrHandler(bubble=False)
self.log_std.formatter = log_type
# 日志打印到文件
self.log_file = TimedRotatingFileHandler(os.path.join(
self.LOG_DIR, '%s.log' % 'log'),
date_format='%Y-%m-%d',
bubble=True,
encoding='utf-8')
self.log_file.formatter = log_type
def get_handlers(self, log_name):
logger_dir = LOGGER_CONF["path"]
logger_fmt = LOGGER_CONF["format"]
# logger_size = int(LOGGER_CONF["size"])
logger_level = LOGGER_CONF["level"].upper()
if not os.path.exists(logger_dir):
os.makedirs(logger_dir)
def log_type(record, handler):
log = logger_fmt.format(
date = record.time, # 日志时间
level = record.level_name, # 日志等级
filename = os.path.split(record.filename)[-1], # 文件名
func_name = record.func_name, # 函数名
lineno = record.lineno, # 行号
msg = record.message, # 日志内容
channel = record.channel, # 通道
pid = self._pid,
ppid = self._ppid
)
return log
# 日志打印到屏幕
log_std = ColorizedStderrHandler(bubble=True, level=logger_level)
log_std.formatter = log_type
# 日志打印到文件
log_file = TimedRotatingFileHandler(os.path.join(logger_dir, '{}.log'.format(log_name)), date_format='%Y-%m-%d', rollover_format='{basename}_{timestamp}{ext}', bubble=True, level=logger_level, encoding='utf-8')
log_file.formatter = log_type
logbook.set_datetime_format("local")
return [log_std, log_file]
def register_handlers():
try:
sys_handler = TimedRotatingFileHandler(tpath + os.sep + 'sys_logs.txt', \
level="DEBUG", date_format='%Y-%m-%d', backup_count=30)
sys_handler.push_application()
info_handler = TimedRotatingFileHandler(tpath + os.sep + 'info_logs.txt', \
level="INFO", date_format='%Y-%m-%d', backup_count=30)
info_handler.push_application()
error_handler = TimedRotatingFileHandler(tpath + os.sep + 'error_logs.txt', \
level="ERROR", date_format='%Y-%m-%d', backup_count=30)
error_handler.push_application()
except:
write_err("handers注册失败，请检查！")
print("handers注册失败，请检查！")
exit(0)
def __init__(self):
handler = TimedRotatingFileHandler('../logs/nodes_discovery.log')
handler.push_application()
self.logger = Logger(name='nodes discovery', level='info')
self.node_hosts, self.nodes_port, self.file_sd_filename, self.nodes_file_backup_name, self.exclude_file, self.metric_filename, self.metric_store_path = self.get_conf()
self.nodes = {}
self.ips = {}
self.nodes_list = []
self.ips_list = []
def get_logger(name='LOGBOOK', log_path='', file_log=False):
logbook.set_datetime_format('local')
ColorizedStderrHandler(bubble=True).push_application()
log_dir = os.path.join('log') if not log_path else log_path
if not os.path.exists(log_dir):
os.makedirs(log_dir)
if file_log:
TimedRotatingFileHandler(os.path.join(log_dir, '%s.log' % name.lower()), date_format='%Y-%m-%d', bubble=True).push_application()
return Logger(name)
def __init__(self):
handler = TimedRotatingFileHandler('../logs/filesystem_recovery.log')
handler.push_application()
self.logger = Logger(name='filesystem recovery')
self.path_lists, regex_express = self.get_conf()
self.reg_express = re.compile(regex_express)
self.tmp_path = os.path.join(BASE_DIR, 'data')
self.file_title = '.walden'
def __init__(self):
handler = TimedRotatingFileHandler('../logs/images_manager.log')
handler.push_application()
self.logger = Logger(name='Docker Images Manage Api', level=11)
os.environ['DOCKER_API_VERSION'] = 1.39
self.logger.debug(os.environ.get('DOCKER_API_VERSION'))
DOCKER_API_VERSION = 1.39
self.docker_client = docker.from_env()
def handle(level, bubble=True):
return TimedRotatingFileHandler(
path('torabot.%s.log' % level),
date_format='%Y-%m-%d',
format_string=
'[{record.time:%Y-%m-%d %H:%M:%S}] {record.level_name}: {record.channel}: {record.message} {record.extra[context]}',
level=getattr(logbook, level.upper()),
bubble=bubble,
)
def __init__(self):
handler = TimedRotatingFileHandler('../logs/filesystem_recovery.log')
handler.push_application()
self.logger = Logger(name='filesystem recovery')
self.node_hosts, self.nodes_port, self.file_sd_filename = self.get_conf()
self.nodes = {}
self.ips = {}
self.nodes_list = []
self.ips_list = []
def __init__(self):
handler = TimedRotatingFileHandler('../logs/nodes_metrics.log')
handler.push_application()
self.logger = Logger(name='nodes metrics', level='info')
self.nodes_filename, self.nodes_file_backup_name, self.exclude_file, self.url, self.query_all_ip, self.query_current_ip = self.get_conf()
self.nodes = {}
self.ips = {}
self.nodes_list = []
self.ips_list = []
def rotating_logger(name: str,
level=INFO,
folder: str = default_path('test_logs')) -> Logger:
set_datetime_format('local')
TimedRotatingFileHandler(f'{folder}/{name}.log',
date_format='%Y-%m-%d',
bubble=True,
level=level,
backup_count=60).push_application()
return Logger(name)
def print_handler():
# 日志路径，在主工程下生成log目录
Log_Dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'log')
if not os.path.exists(Log_Dir):
os.makedirs(Log_Dir)
# 打印到屏幕句柄
user_std_handler = ColorizedStderrHandler(bubble=True)
user_std_handler.formatter = log_formatter
# 打印到文件句柄
file_handler = TimedRotatingFileHandler(os.path.join(Log_Dir, "%s.log" % "test_log"), date_format="%Y%m%d", bubble=True)
file_handler.formatter = log_formatter
return user_std_handler, file_handler
def __init__(self):
cp = ConfigParser.SafeConfigParser()
with codecs.open('config/config.ini', 'r', encoding='utf-8') as f:
cp.readfp(f)
# self.dir = cp.get('xml', 'dir').strip()
# self.xml_searchids_file = cp.get('files', 'xml_searchids_file').strip()
self.pool = threadpool.ThreadPool(30)
self.files_rights = {}
self.lock = threading.Lock()
self.q = Queue.Queue()
handler = TimedRotatingFileHandler('../logs/get_rights.log')
handler.push_application()
self.logger = Logger(name='get rights')
def setup():
if not os.path.exists(LOG_FILE_DIR):
os.mkdir(LOG_FILE_DIR)
file_handler = TimedRotatingFileHandler(
filename=LOG_FILE_PATH,
backup_count=config.get_logging_backup_count())
stream_handler = StreamHandler(sys.stdout, level='CRITICAL')
stream_handler.format_string = '{record.level_name}: {record.channel}: {record.message}'
file_handler.push_application()
stream_handler.push_application()
def rotating_logger_with_shell(
name: str,
stream_level=DEBUG,
file_level=DEBUG,
folder: str = default_path('test_logs')) -> Logger:
set_datetime_format('local')
StreamHandler(sys.stdout, level=stream_level,
bubble=True).push_application()
TimedRotatingFileHandler(f'{folder}/{name}.log',
date_format='%Y-%m-%d',
bubble=True,
level=file_level,
backup_count=60).push_application()
return Logger(name)
def __init__(self):
# logging.basicConfig(level=logging.INFO,
# filename='./logs/nodes_discovery.log',
# datefmt='%Y/%m/%d %H:%M:%S',
# format='%(asctime)s - %(name)s - %(levelname)s - %(lineno)d - %(module)s - %(message)s')
# logger = logging.getLogger(__name__)
handler = TimedRotatingFileHandler('../logs/nodes_discovery.log')
handler.push_application()
self.logger = Logger(name='nodes discovery')
# self.logger = loggor
self.node_hosts, self.nodes_port, self.file_sd_filename = self.get_conf()
# self.win_nodes_port, self.node_hosts, self.nodes_port, self.file_sd_filename = self.get_conf()
self.nodes = {}
self.ips = {}
def __init__(self, clazz):
logbook.set_datetime_format("local")
self.serverName = clazz.__name__[clazz.__name__.rfind('.') + 1:]
if not os.path.exists(log_dir):
os.makedirs(log_dir)
self.log_file = TimedRotatingFileHandler(os.path.join(
log_dir, '%s.log' % self.serverName),
date_format='%Y-%m-%d',
bubble=True,
encoding='utf-8')
self.log_std = ColorizedStderrHandler(bubble=True)
self.log = Logger(self.serverName)
self.__init_logger()
self.__setting()
def logger(file_name=LogName.DEFAULT):
# 日志打印到文件
log_file = TimedRotatingFileHandler(
os.path.join(LOG_DIR, '%s.log' % file_name),
date_format='%Y-%m-%d',
bubble=True,
rollover_format='{basename}_{timestamp}{ext}',
encoding='utf-8',
)
log_file.formatter = log_type
logbook.set_datetime_format('local')
run_log = Logger('script_log')
run_log.handlers = []
run_log.handlers.append(log_file)
return run_log
def generate_logger():
# 日志名称
logger = Logger(PROJECT_NAME_EN, level=LOG_LEVEL)
logbook.set_datetime_format("local")
logger.handlers = []
# 日志打印到文件
log_file = TimedRotatingFileHandler(os.path.join(
LOG_DIR, '%s.log' % PROJECT_NAME_EN),
date_format=DAY_FORMAT,
bubble=True,
encoding='utf-8')
log_file.formatter = log_type
logger.handlers.append(log_file)
if DEBUG:
# 日志打印到屏幕
log_std = ColorizedStderrHandler(bubble=True)
log_std.formatter = log_type
logger.handlers.append(log_std)
return logger
def __init__(self, logname, toscreen=False):
# 设置日志名称
self.logname = logname
self.toscreen = toscreen
# 设置日志目录
self.LOG_DIR = self.setpath()
# 设置本地时间
logbook.set_datetime_format("local")
# 设置终端输出格式
self.log_standard = ColorizedStderrHandler(bubble=True)
self.log_standard.formatter = self.logformat
# 设置文件输出格式
self.log_file = TimedRotatingFileHandler(os.path.join(
self.LOG_DIR, '{}.log'.format(self.logname)),
date_format='%Y-%m-%d',
bubble=True,
encoding='utf-8')
self.log_file.formatter = self.logformat
# 执行log记录
self.log = Logger("SatanLogging")
self.logrun()
def get_logger(logname):
user_log = logbook.Logger('log')
logbook.set_datetime_format("local") # 格式化时间
# 日志打印到屏幕
log_std = ColorizedStderrHandler(bubble=True)
log_std.formatter = log_type
# 日志打印到文件
log_file = TimedRotatingFileHandler(os.path.join(full_path,
'%s.log' % logname),
date_format='%Y-%m-%d',
bubble=True,
encoding='utf-8') # 日期分割显示文件(带日期的)
log_file.formatter = log_type
user_log.handlers = []
user_log.handlers.append(log_file)
user_log.handlers.append(log_std)
return user_log
def __init__(self, log_dir=BASE_DIR, log_name='log.log', backup_count=10, log_type=log_type, stdOutFlag=False):
if not os.path.exists(log_dir):
os.mkdir(log_dir)
self.log_dir = log_dir
self.backup_count = backup_count
handler = TimedRotatingFileHandler(filename= os.path.join(self.log_dir, log_name),
date_format='%Y-%m-%d',
backup_count=self.backup_count)
self.handler = handler
if log_type is not None:
handler.formatter = log_type
handler.push_application()
if not stdOutFlag:
return
handler_std = ColorizedStderrHandler(bubble=True)
if log_type is not None:
handler_std.formatter = log_type
handler_std.push_application()
)
log_dir = os.getcwd()
print('123')
if os.path.exists(log_dir):
print('文件存在')
else:
print('文件不存在')
# print(path)
#日志打印到屏幕
log_led = ColorizedStderrHandler(bubble=True) #获取打印在屏幕上的句柄
log_led.formatter = log_type #log打印的格式设置
# 日志打印到文件
log_file = TimedRotatingFileHandler(os.path.join(log_dir,'%s.log' % 'log'),date_format='%Y-%m-%d',bubble=True,encoding='utf-8')
log_file.formatter = log_type
#脚本日志
run_log = Logger("script_log")
def init_logger():
logbook.set_datetime_format("local")
run_log.handlers = []
run_log.handlers.append(log_file)
run_log.handlers.append(log_led)
logger = init_logger()
)
return log
std_handler = ColorizedStderrHandler(bubble=True)
std_handler.formatter = log_formatter
# 日志存放路径
LOG_DIR = env.log_dir
if not os.path.exists(LOG_DIR):
os.makedirs(LOG_DIR)
# 日志打印到文件
log_file_debug = TimedRotatingFileHandler(os.path.join(LOG_DIR, '{}.log'.format('debug')), date_format='%Y-%m-%d', level=logbook.DEBUG, bubble=True, encoding='utf-8')
log_file_debug.formatter = log_formatter
log_file_info = TimedRotatingFileHandler(os.path.join(LOG_DIR, '{}.log'.format('info')), date_format='%Y-%m-%d', level=logbook.INFO, bubble=True, encoding='utf-8')
log_file_info.formatter = log_formatter
log_file_err = TimedRotatingFileHandler(os.path.join(LOG_DIR, '{}.log'.format('err')), date_format='%Y-%m-%d', level=logbook.WARNING, bubble=True, encoding='utf-8')
log_file_err.formatter = log_formatter
def init_logger(level=logbook.INFO):
logbook.set_datetime_format("local")
system_log = Logger("system_log")
system_log.handlers = []
system_log.handlers.append(log_file_debug)
system_log.handlers.append(log_file_info)
'There are %s nodes stopped now' % stop_nodes)
self.logger.info('************************************')
return stop_nodes, failed_hosts
if __name__ == "__main__":
url = 'https://prom.demo.com/prome/api/v1/query?'
query_current_ip = 'query=node_virtual_type'
# query_current_ip = 'query=avg({__name__=~"node_disk_read_time_(ms|seconds_total)",job="nodes",device=~"(dm-|sd[a-z]).*$"}) by (instance_ip)'
# query_current_ip = 'query=node_filesystem_inode_used'
# query_all_ip = 'query=avg(up{job=~"nodes"}) by (instance_ip)'
query_all_ip = 'query=up{job="nodes"}'
handler = TimedRotatingFileHandler('../logs/test.log')
handler.push_application()
logger = Logger(name='test')
# self.logger.add('../logs/test.log', rotation="1 day", compression="zip")
nodes_metrics = NodesMetrics()
#get_lost_nodes()
#get_lost_nodes_file()
lost_nodes_by_discovery, failed_hosts = nodes_metrics.get_lost_nodes_discovery()
func_name=record.func_name,
lineno=record.lineno,
msg=record.message)
return log
LOG_DIR = os.path.join("Log")
if not os.path.exists(LOG_DIR):
os.makedirs(LOG_DIR)
log_std = ColorizedStderrHandler()
log_std.formatter = log_type
log_file = TimedRotatingFileHandler(os.path.join(LOG_DIR, '%s.log' % 'log'),
date_format='%Y-%m-%d',
bubble=True,
encoding='utf-8',
level=ERROR)
log_file.formatter = log_type
def init_logger():
"""Write error info log file as default.
Return the distance of logbook logger.
"""
filename = inspect.getframeinfo(inspect.currentframe().f_back).filename
logger = Logger(filename)
logbook.set_datetime_format("local")
logger.handlers = []
logger.handlers.append(log_file)
logger.handlers.append(log_std)
