def clean(): log_file, log_level = log.get_log_args() logger = log.Logger(log_file, log_level) logger.logger.info("清理程序启动...") keep_days = conf.get("autocheck", "keep_days")[0] scheduler = BlockingScheduler() scheduler.add_job(clean_data, 'cron', args=[logger, int(keep_days)], day_of_week='0-6', hour=1, minute=10, id=f'clean') scheduler.start()
def resource_show(hostname, check_dict, granularity_level, sender_alias, receive, subject): log_file, log_level = log.get_log_args() logger = log.Logger(log_file, log_level) db = database.db() now_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") modifier = "-24 hour" message = "" # 重置统计文件 report_dir = "report" shutil.rmtree(report_dir, ignore_errors=True) os.makedirs(report_dir, exist_ok=True) logger.logger.info("统计资源记录信息...") printf(f"统计开始时间: {now_time}") printf(f"主机名: {hostname}") printf("-" * 100) # 系统启动时间 sql = "select boot_time from boot_time order by record_time desc" boot_time = db.query_one(sql)[0] printf(f"系统启动时间: {boot_time}") printf("*" * 100) # 磁盘 logger.logger.info("统计Disk记录信息...") printf("磁盘统计:") sql = "select distinct mounted from disk" disk_names = db.query_all(sql) disk_granularity_level = int(60 / int(check_dict['host_check'][0]) * granularity_level) disk_granularity_level = disk_granularity_level if disk_granularity_level != 0 else 1 for i in disk_names: i = i[0] table = pt.PrettyTable( ["记录时间", "挂载点", "磁盘名称", "磁盘大小", "已使用大小", "已使用百分比", "可用"]) sql=f"select record_time, name, total, used, used_percent, avail from disk "\ f"where mounted=? "\ f"and record_time > datetime('{now_time}', '{modifier}') "\ f"order by record_time" disk_data = db.query_all(sql, (i, )) for index, item in enumerate(disk_data): if index % disk_granularity_level == 0 or index == 0: total = format_size(item[2]) used = format_size(item[3]) used_percent = f"{item[4]}%" avail = format_size(item[5]) table.add_row( (item[0], i, item[1], total, used, used_percent, avail)) printf(f"{i}磁盘统计:") printf(table) printf("*" * 100) # CPU logger.logger.info("统计CPU记录信息...") printf("CPU统计:") cpu_granularity_level = int(60 / int(check_dict['host_check'][1]) * granularity_level) cpu_granularity_level = cpu_granularity_level if cpu_granularity_level != 0 else 1 table = pt.PrettyTable(["记录时间", "CPU核心数", "CPU使用率"]) sql=f"select record_time, cpu_count, cpu_used_percent from cpu "\ f"where record_time > datetime('{now_time}', '{modifier}') "\ f"order by record_time" cpu_data = db.query_all(sql) for index, item in enumerate(cpu_data): if index % cpu_granularity_level == 0 or index == 0: used_percent = f"{item[2]}%" table.add_row((item[0], item[1], used_percent)) printf(table) printf("*" * 100) # MEM logger.logger.info("统计Mem记录信息...") printf("内存统计:") mem_granularity_level = int(60 / int(check_dict['host_check'][2]) * granularity_level) mem_granularity_level = mem_granularity_level if mem_granularity_level != 0 else 1 table = pt.PrettyTable( ["记录时间", "内存大小", "可用(avail)", "已使用", "已使用百分比", "剩余(free)"]) sql=f"select record_time, total, avail, used, used_percent, free from memory "\ f"where record_time > datetime('{now_time}', '{modifier}') "\ f"order by record_time" mem_data = db.query_all(sql) for index, item in enumerate(mem_data): if index % mem_granularity_level == 0 or index == 0: total = format_size(item[1]) avail = format_size(item[2]) used = format_size(item[3]) used_percent = f"{item[4]}%" free = format_size(item[5]) table.add_row((item[0], total, avail, used, used_percent, free)) printf(table) printf("*" * 100) # Swap logger.logger.info("统计Swap记录信息...") printf("Swap统计:") swap_granularity_level = int(60 / int(check_dict['host_check'][3]) * granularity_level) swap_granularity_level = swap_granularity_level if swap_granularity_level != 0 else 1 table = pt.PrettyTable(["记录时间", "Swap大小", "已使用", "已使用百分比", "剩余"]) sql=f"select record_time, total, used, used_percent, free from swap "\ f"where record_time > datetime('{now_time}', '{modifier}') "\ f"order by record_time" swap_data = db.query_all(sql) for index, item in enumerate(swap_data): if index % swap_granularity_level == 0 or index == 0: total = format_size(item[1]) used = format_size(item[2]) used_percent = f"{item[3]}%" free = format_size(item[4]) table.add_row((item[0], total, used, used_percent, free)) printf(table) printf("*" * 100) # Tomcat if check_dict["tomcat_check"][0] == "1": logger.logger.info("统计Tomcat记录信息...") printf("Tomcat统计:") tomcat_granularity_level = int( 60 / int(check_dict['tomcat_check'][1]) * granularity_level) tomcat_granularity_level = tomcat_granularity_level if tomcat_granularity_level != 0 else 1 version = db.query_one("select version from tomcat_java_version")[0] printf(f"Java版本: {version}") printf("*" * 100) #sql="select distinct port from tomcat_constant" #tomcat_ports=db.query_all(sql) tomcat_ports = conf.get("tomcat", "tomcat_port")[0].split(",") tomcat_constant_data = [] for i in tomcat_ports: port = int(i.strip()) constant_sql=f"select record_time, pid, port, boot_time, cmdline from tomcat_constant "\ f"where port=? "\ f"and '{now_time}' >= record_time "\ f"order by record_time desc" variable_sql=f"select record_time, pid, men_used, mem_used_percent, connections, threads_num from tomcat_variable "\ f"where port=? "\ f"and record_time > datetime('{now_time}', '{modifier}') "\ f"order by record_time" if version == "8": jvm_sql=f"select record_time, S0, S1, E, O, M, CCS, YGC, YGCT, FGC, FGCT, GCT from tomcat_jstat8 "\ f"where port=? "\ f"and record_time > datetime('{now_time}', '{modifier}') "\ f"order by record_time" jvm_table = pt.PrettyTable([ "记录时间", "S0", "S1", "E", "O", "M", "CCS", "YGC", "YGCT", "FGC", "FGCT", "GCT" ]) elif version == "7": jvm_sql=f"select record_time, S0, S1, E, O, P, YGC, YGCT, FGC, FGCT, GCT from tomcat_jstat7 "\ f"where port=? "\ f"and record_time > datetime('{now_time}', '{modifier}') "\ f"order by record_time" jvm_table = pt.PrettyTable([ "记录时间", "S0", "S1", "E", "O", "P", "YGC", "YGCT", "FGC", "FGCT", "GCT" ]) constant_table = pt.PrettyTable( ["记录时间", "Pid", "端口", "启动时间", "启动参数"]) tomcat_constant_data = (db.query_one(constant_sql, (port, ))) constant_table.add_row(tomcat_constant_data) variable_table = pt.PrettyTable( ["记录时间", "Pid", "内存使用", "内存使用率", "连接数", "线程数"]) tomcat_variable_data = (db.query_all(variable_sql, (port, ))) for index, item in enumerate(tomcat_variable_data): if index % tomcat_granularity_level == 0 or index == 0: mem_used = format_size(item[2]) mem_used_percent = f"{item[3]:.2f}%" variable_table.add_row( (item[0], item[1], mem_used, mem_used_percent, item[4], item[5])) tomcat_jvm_data = (db.query_all(jvm_sql, (port, ))) for index, item in enumerate(tomcat_jvm_data): if index % tomcat_granularity_level == 0 or index == 0: jvm_table.add_row(item) printf(f"Tomcat({port})统计信息:") printf("启动信息:") printf(constant_table) printf("运行信息:") printf(variable_table) printf("Jvm内存信息:") printf(jvm_table) printf("*" * 100) # Redis if check_dict["redis_check"][0] == "1": logger.logger.info("统计Redis记录信息...") printf("Redis统计:") redis_granularity_level = int(60 / int(check_dict['redis_check'][1]) * granularity_level) redis_granularity_level = redis_granularity_level if redis_granularity_level != 0 else 1 printf("*" * 100) constant_sql=f"select record_time, pid, port, boot_time from redis_constant "\ f"where '{now_time}' >= record_time "\ f"order by record_time desc" variable_sql=f"select record_time, pid, mem_used, mem_used_percent, connections, threads_num from redis_variable "\ f"where record_time > datetime('{now_time}', '{modifier}') "\ f"order by record_time" # 启动信息 constant_table = pt.PrettyTable(["记录时间", "Pid", "端口", "启动时间"]) constant_data = (db.query_one(constant_sql)) constant_table.add_row(constant_data) # 运行信息 variable_table = pt.PrettyTable( ["记录时间", "Pid", "内存使用", "内存使用率", "连接数", "线程数"]) variable_data = (db.query_all(variable_sql)) for index, item in enumerate(variable_data): if index % tomcat_granularity_level == 0 or index == 0: mem_used = format_size(item[2]) mem_used_percent = f"{item[3]:.2f}%" variable_table.add_row((item[0], item[1], mem_used, mem_used_percent, item[4], item[5])) # master_slave信息 role = db.query_one("select role from redis_role")[0] if role == "master": master_slave_sql = "select a.record_time, connected_slave, slave_ip, slave_port, slave_state from redis_master a ,redis_slaves_info b on a.record_time=b.record_time where a.record_time=(select max(record_time) from redis_master)" master_slave_table = pt.PrettyTable( ["记录时间", "Slave数量", "Slave IP", "Slave端口", "Slave状态"]) master_slave_data = (db.query_all(master_slave_sql)) for i in master_slave_data: master_slave_table.add_row(i) elif role == "slave": master_slave_sql = "select record_time, pid, master_host, master_port, master_link_status from redis_slave order by record_time desc" master_slave_table = pt.PrettyTable( ["记录时间", "Pid", "master主机", "master端口", "与master连接状态"]) master_slave_data = (db.query_one(master_slave_sql)) master_slave_table.add_row(master_slave_data) # sentinel监控信息 sentinel_sql = "select a.record_time, role, host, a.port from redis_sentinel a, redis_constant b on a.record_time=b.record_time where b.record_time=(select max(record_time) from redis_constant)" sentinel_table = pt.PrettyTable(["记录时间", "角色", "IP", "端口"]) sentinel_data = (db.query_all(sentinel_sql)) for i in sentinel_data: sentinel_table.add_row(i) printf("启动信息:") printf(constant_table) printf("运行信息:") printf(variable_table) printf("集群信息:") printf(f"当前角色: {role}") printf(master_slave_table) printf("Sentinel监控信息:") printf(sentinel_table) printf("*" * 100) # backup if check_dict["backup_check"] == "1": logger.logger.info("统计备份记录信息...") printf("备份统计:") backup_dirs = conf.get("backup", "dir")[0].split(",") for i in backup_dirs: directory = i.strip() table = pt.PrettyTable(["记录时间", "备份文件", "大小", "创建时间"]) sql=f"select record_time, filename, size, ctime from backup "\ f"where directory=?"\ f"order by ctime" backup_data = db.query_all(sql, (directory, )) for j in backup_data: if j[2] is not None: size = format_size(j[2]) table.add_row((j[0], j[1], size, j[3])) printf(f"备份({directory})统计信息:") printf(table) printf("*" * 100) # MySQL if check_dict["mysql_check"][0] == "1": logger.logger.info("统计MySQL记录信息...") printf("MySQL统计:") mysql_granularity_level = int(60 / int(check_dict['mysql_check'][1]) * granularity_level) mysql_granularity_level = mysql_granularity_level if mysql_granularity_level != 0 else 1 printf("*" * 100) constant_sql=f"select record_time, pid, port, boot_time from mysql_constant "\ f"where '{now_time}' >= record_time "\ f"order by record_time desc" variable_sql=f"select record_time, pid, mem_used, mem_used_percent, connections, threads_num from mysql_variable "\ f"where record_time > datetime('{now_time}', '{modifier}') "\ f"order by record_time" # 启动信息 constant_table = pt.PrettyTable(["记录时间", "Pid", "端口", "启动时间"]) constant_data = (db.query_one(constant_sql)) constant_table.add_row(constant_data) # 运行信息 variable_table = pt.PrettyTable( ["记录时间", "Pid", "内存使用", "内存使用率", "连接数", "线程数"]) variable_data = (db.query_all(variable_sql)) for index, item in enumerate(variable_data): if index % mysql_granularity_level == 0 or index == 0: mem_used = format_size(item[2]) mem_used_percent = f"{item[3]:.2f}%" variable_table.add_row((item[0], item[1], mem_used, mem_used_percent, item[4], item[5])) # master_slave信息 role = db.query_one("select role from mysql_role")[0] if role == "master": master_slave_sql = "select record_time, pid, slave_num, binlog_do_db, binlog_ignore_db from mysql_master order by record_time desc" master_slave_table = pt.PrettyTable( ["记录时间", "Pid", "Slave数量", "Binlog_do_db", "Binlog_ignore_db"]) elif role == "slave": master_slave_sql="select record_time, pid, master_host, master_port, replicate_do_db, replicate_ignore_db, "\ "slave_io_thread, slave_io_state, slave_sql_thread, slave_sql_state, "\ "master_uuid, retrieved_gtid_set, executed_gtid_set, seconds_behind_master "\ "from mysql_slave order by record_time desc" master_slave_table = pt.PrettyTable([ "记录时间", "Pid", "Master主机", "Master端口", "同步数据库", "非同步数据库", "Slave_IO线程", "Slave_IO状态", "Slave_SQL线程", "Slave_SQL状态", "Master_UUID", "已接收的GTID集合", "已执行的GTID集合", "Slave落后Master的秒数" ]) master_slave_data = (db.query_one(master_slave_sql)) if master_slave_data is not None: master_slave_table.add_row(master_slave_data) printf("启动信息:") printf(constant_table) printf("运行信息:") printf(variable_table) printf("集群信息:") printf(f"当前角色: {role}") printf(master_slave_table) printf("*" * 100) # 慢日志 printf("慢日志信息:") mysql_user, mysql_ip, mysql_port, mysql_password = conf.get( "mysql", "mysql_user", "mysql_ip", "mysql_port", "mysql_password") mysql_flag, msg = mysql.export_slow_log( logger, mysql_user, mysql_ip, mysql_password, mysql_port, f"{report_dir}/slow_analysis.log", f"{report_dir}/slow.log") if mysql_flag == 1: message = f"该附件存在MySQL慢日志" printf(msg) printf("*" * 100) # Oracle表空间 if check_dict["oracle_check"][0] == "1": logger.logger.info("统计Oracle表空间记录信息...") printf("Oracle表空间统计:") oracle_granularity_level = int( 60 / int(check_dict['oracle_check'][1]) * granularity_level) oracle_granularity_level = oracle_granularity_level if oracle_granularity_level != 0 else 1 sql = "select distinct tablespace_name from oracle" tablespace_names = db.query_all(sql) for i in tablespace_names: i = i[0] table = pt.PrettyTable( ["记录时间", "表空间名称", "表空间大小", "已使用", "已使用百分比", "可用"]) sql=f"select record_time, size, used, used_percent, free from oracle "\ f"where tablespace_name=? "\ f"and record_time > datetime('{now_time}', '{modifier}') "\ f"order by record_time" tablespace_data = db.query_all(sql, (i, )) for index, item in enumerate(tablespace_data): if index % oracle_granularity_level == 0 or index == 0: total = format_size(item[1]) used = format_size(item[2]) used_percent = f"{item[3]}%" free = format_size(item[4]) table.add_row( (item[0], i, total, used, used_percent, free)) printf(f"{i}表空间统计:") printf(table) printf("*" * 100) # war logger.logger.info("生成awr报告...") printf("awr报告信息:") awr_hours = conf.get("oracle", "awr_hours")[0] if oracle.generate_awr(int(awr_hours), report_dir) == 0: printf("请在附件中查看awr.html文件") else: printf("生成awr报告失败, 请自行手动生成") logger.logger.info("统计资源结束...") printf("-" * 100) end_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") printf(f"统计结束时间: {end_time}") tar_file = tar_report(logger, report_dir) sender_alias, receive, subject = conf.get("mail", "sender", "receive", "subject") warning_msg = f"\n请查看统计报告.\n\n{message}" mail.send(logger, warning_msg, sender_alias, receive, subject, msg="report", attachment_file=tar_file)
def analysis(): log_file, log_level=log.get_log_args() logger=log.Logger(log_file, log_level) logger.logger.info("开始分析资源信息...") sender_alias, receive, subject=conf.get("mail", "sender", "receive", "subject" ) warning_percent, warning_interval, analysis_interval=conf.get("autocheck", "warning_percent", "warning_interval", "analysis_interval" ) disk_interval, cpu_interval, memory_interval=conf.get("host", "disk_interval", "cpu_interval", "memory_interval" ) min_value=5 warning_percent=float(warning_percent) warning_interval=int(warning_interval) analysis_interval=int(analysis_interval) disk_interval=int(disk_interval)+analysis_interval cpu_interval=int(cpu_interval)+analysis_interval memory_interval=int(memory_interval)+analysis_interval max_threads=20 executors = { "default": ThreadPoolExecutor(max_threads) } job_defaults = { "coalesce": True, "max_instances": 1, "misfire_grace_time": 3, } scheduler=BlockingScheduler(job_defaults=job_defaults, executors=executors) # host资源记录 logger.logger.info("开始分析主机资源信息...") scheduler.add_job(host.disk_analysis, 'interval', args=[log_file, log_level, warning_percent, warning_interval, sender_alias, receive, subject], seconds=disk_interval, id='disk_ana') scheduler.add_job(host.cpu_analysis, 'interval', args=[log_file, log_level, warning_percent, warning_interval, sender_alias, receive, subject], seconds=cpu_interval, id='cpu_ana') scheduler.add_job(host.memory_analysis, 'interval', args=[log_file, log_level, warning_percent, warning_interval, sender_alias, receive, subject], seconds=memory_interval, id='mem_ana') # users_limit logger.logger.info("开始分析用户资源信息...") scheduler.add_job(user_resource.analysis, 'interval', args=[log_file, log_level, 0, sender_alias, receive, subject], next_run_time=datetime.datetime.now()+datetime.timedelta(seconds=15), minutes=65, id=f'user_limit_ana') # tomcat资源 tomcat_check=conf.get("tomcat", "check")[0] if tomcat_check=='1': tomcat_interval=conf.get("tomcat", "tomcat_interval")[0] tomcat_interval=int(tomcat_interval)+analysis_interval logger.logger.info("开始分析Tomcat资源信息...") scheduler.add_job(tomcat.running_analysis, 'interval', args=[log_file, log_level, warning_interval, sender_alias, receive, subject], seconds=tomcat_interval, id='tomcat_run_ana') scheduler.add_job(tomcat.jvm_analysis, 'interval', args=[log_file, log_level, warning_interval, sender_alias, receive, subject], seconds=tomcat_interval, id='tomcat_jvm_ana') # redis资源 redis_check=conf.get("redis", "check")[0] if redis_check=="1": redis_interval=conf.get("redis", "redis_interval")[0] redis_interval=int(redis_interval)+analysis_interval logger.logger.info("开始分析Redis资源信息...") scheduler.add_job(redis.running_analysis, 'interval', args=[log_file, log_level, warning_interval, sender_alias, receive, subject], seconds=redis_interval, id='redis_run_ana') scheduler.add_job(redis.master_slave_analysis, 'interval', args=[log_file, log_level, warning_interval, sender_alias, receive, subject], seconds=redis_interval, id='redis_slave_ana') # 记录mysql mysql_check=conf.get("mysql", "check")[0] if mysql_check=="1": mysql_interval, seconds_behind_master=conf.get("mysql", "mysql_interval", "seconds_behind_master") mysql_interval=int(mysql_interval)+analysis_interval logger.logger.info("开始分析MySQL资源信息...") scheduler.add_job(mysql.running_analysis, 'interval', args=[log_file, log_level, warning_interval, sender_alias, receive, subject], seconds=mysql_interval, id='mysql_run_ana') scheduler.add_job(mysql.master_slave_analysis, 'interval', args=[log_file, log_level, int(seconds_behind_master), warning_interval, sender_alias, receive, subject], seconds=mysql_interval, id='mysql_slave_ana') # 记录Oracle oracle_check=conf.get("oracle", "check")[0] if oracle_check=="1": oracle_interval=conf.get("oracle", "oracle_interval")[0] oracle_interval=int(oracle_interval)+analysis_interval logger.logger.info("开始分析Oracle信息...") scheduler.add_job(oracle.tablespace_analysis, 'interval', args=[log_file, log_level, warning_percent, warning_interval, sender_alias, receive, subject], seconds=oracle_interval, id='oracle_tablespace_ana') # backup backup_check, backup_dir, backup_cron_time=conf.get("backup", "check", "dir", "cron_time" ) if backup_check=="1": dir_list=[] for i in backup_dir.split(","): dir_list.append(i.strip()) cron_time_list=[] for i in backup_cron_time.split(","): cron_time_list.append(i.strip()) for i in range(len(dir_list)): directory=dir_list[i] cron_time=cron_time_list[i].split(":") hour=cron_time[0].strip() minute=cron_time[1].strip() scheduler.add_job(backup.analysis, 'cron', args=[log_file, log_level, directory, 0, sender_alias, receive, subject], day_of_week='0-6', hour=int(hour), minute=int(minute)+1, id=f'backup{i}_ana') scheduler.start()
def record(): log_file, log_level = log.get_log_args() logger = log.Logger(log_file, log_level) logger.logger.info("开始采集资源信息...") max_threads = 50 executors = {"default": ThreadPoolExecutor(max_threads)} job_defaults = { "coalesce": True, "max_instances": 1, "misfire_grace_time": 3, } scheduler = BlockingScheduler(job_defaults=job_defaults, executors=executors) min_value = 10 # host资源记录 logger.logger.info("开始采集主机资源信息...") disk_interval, cpu_interval, memory_interval, swap_interval, users_limit = conf.get( "host", "disk_interval", "cpu_interval", "memory_interval", "swap_interval", "users_limit") if int(disk_interval) < min_value: disk_interval = min_value if int(cpu_interval) < min_value: cpu_interval = min_value if int(memory_interval) < min_value: memory_interval = min_value if int(swap_interval) < min_value: swap_interval = min_value logger.logger.info("开始采集磁盘资源信息...") scheduler.add_job(host.disk_record, 'interval', args=[log_file, log_level], seconds=int(disk_interval), id='disk_record') logger.logger.info("开始采集CPU资源信息...") scheduler.add_job(host.cpu_record, 'interval', args=[log_file, log_level], seconds=int(cpu_interval), id='cpu_record') logger.logger.info("开始采集内存资源信息...") scheduler.add_job(host.memory_record, 'interval', args=[log_file, log_level], seconds=int(memory_interval), id='memory_record') logger.logger.info("开始采集Swap资源信息...") scheduler.add_job(host.swap_record, 'interval', args=[log_file, log_level], seconds=int(swap_interval), id='swap_record') logger.logger.info("开始采集启动时间资源信息...") #scheduler.add_job(host.boot_time_record, 'interval', args=[log_file, log_level], seconds=int(boot_time_interval), id='boot_time_record') host.boot_time_record(log_file, log_level) # 用户资源限制 logger.logger.info("开始记录用户限制信息...") if users_limit is not None: users_limit_list = [] for i in users_limit.split(","): users_limit_list.append(i.strip()) for user in users_limit_list: scheduler.add_job(user_resource.record, 'interval', args=[log_file, log_level, user], next_run_time=datetime.datetime.now() + datetime.timedelta(seconds=5), minutes=60, id=f'{user}_limit') # tomcat资源 tomcat_check, tomcat_interval, tomcat_port = conf.get( "tomcat", "check", "tomcat_interval", "tomcat_port", ) if tomcat_check == '1': logger.logger.info("开始采集Tomcat资源信息...") tomcat_port_list = [] # 将tomcat_port参数改为列表 for i in tomcat_port.split(","): tomcat_port_list.append(i.strip()) if int(tomcat_interval) < min_value: tomcat_interval = min_value scheduler.add_job(tomcat.record, 'interval', args=[log_file, log_level, tomcat_port_list], seconds=int(tomcat_interval), id='tomcat_record') # redis资源 redis_check, redis_interval, redis_password, redis_port, sentinel_port, sentinel_name, commands = conf.get( "redis", "check", "redis_interval", "password", "redis_port", "sentinel_port", "sentinel_name", "commands") if redis_check == "1": if int(redis_interval) < min_value: redis_interval = min_value logger.logger.info("开始采集Redis资源信息...") scheduler.add_job(redis.record, 'interval', args=[log_file, log_level, redis_password, redis_port, sentinel_port, sentinel_name, commands], \ seconds=int(redis_interval), id='redis_record') # backup backup_check, backup_dir, backup_regular, backup_cron_time = conf.get( "backup", "check", "dir", "regular", "cron_time") if backup_check == "1": logger.logger.info("开始记录备份信息...") dir_list = [] for i in backup_dir.split(","): dir_list.append(i.strip()) regular_list = [] for i in backup_regular.split(","): regular_list.append(i.strip()) cron_time_list = [] for i in backup_cron_time.split(","): cron_time_list.append(i.strip()) for i in range(len(dir_list)): directory = dir_list[i] regular = regular_list[i] cron_time = cron_time_list[i].split(":") hour = cron_time[0].strip() minute = cron_time[1].strip() scheduler.add_job(backup.record, 'cron', args=[log_file, log_level, directory, regular], next_run_time=datetime.datetime.now(), day_of_week='0-6', hour=int(hour), minute=int(minute), id=f'backup{i}') # 记录mysql mysql_check, mysql_interval, mysql_user, mysql_ip, mysql_port, mysql_password = conf.get( "mysql", "check", "mysql_interval", "mysql_user", "mysql_ip", "mysql_port", "mysql_password") if mysql_check == "1": if int(mysql_interval) < min_value: mysql_interval = min_value logger.logger.info("开始采集MySQL资源信息...") scheduler.add_job(mysql.record, 'interval', args=[ log_file, log_level, mysql_user, mysql_ip, mysql_password, mysql_port ], seconds=int(mysql_interval), id='mysql_record') # 记录Oracle oracle_check, oracle_interval = conf.get("oracle", "check", "oracle_interval") if oracle_check == "1": if int(oracle_interval) < min_value: oracle_interval = min_value logger.logger.info("开始记录Oracle信息...") scheduler.add_job(oracle.record, 'interval', args=[log_file, log_level], seconds=int(oracle_interval), id='oracle_record') # 记录并分析匹配 matching_check, matching_files, matching_keys, matching_interal = conf.get( "matching", "check", "matching_files", "matching_keys", "matching_interval") if matching_check == "1": matching_min_value = 1 if int(matching_interal) < matching_min_value: matching_check = matching_min_value logger.logger.info("开始采集匹配信息...") matching_dict = dict( zip([x.strip() for x in matching_files.split(",")], [x.strip() for x in matching_keys.split(",")])) record_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") db = database.db() for matching_file in matching_dict: if os.path.exists(matching_file): sql = "insert into matching values(?, ?, ?, ?, ?)" filesize = os.stat(matching_file)[6] db.update_one(sql, (record_time, matching_file, matching_dict[matching_file], "all", filesize)) else: logger.logger.error( f"Error: [matching]配置中文件{matching_file}不存在") matching_dict.pop(matching_file) scheduler.add_job(matching.matching_records, 'interval', args=[log_file, log_level, matching_dict], seconds=int(matching_interal), id=f'matching') scheduler.start()