diff --git a/.gitignore b/.gitignore index 313b001..0f54d87 100644 --- a/.gitignore +++ b/.gitignore @@ -18,3 +18,6 @@ Thumbs.db desktop.ini .DS_Store ~$* + +# 测试生成的临时数据库与数据 +tests/_work/ diff --git a/README.md b/README.md index aef5078..6b4ceab 100644 --- a/README.md +++ b/README.md @@ -25,10 +25,11 @@ Python + Flask + SQLite 后端,React 19 + [Liquid Glass UI](https://tsdsj.gith ``` Local-sever/ ├── app.py Flask 路由:认证与权限、增删改查、导入、统计、导出、日志、用户;托管前端页面 -├── core.py 核心算法:建库入库、两级根因关联、时长与考核指标 +├── core.py 核心算法:建库入库、时间窗标定、三级根因关联、告警关联量化、时长与考核指标 ├── importer.py 数据导入:读取 Excel/CSV、自动识别文件类型、逐行校验(见下方“支持导入的文件”) ├── data_gen.py 第 18 题数据生成器(Data-Generated-Core-Py/data.py 的改进版,字段口径一致) -├── publish_online.py 同步到 ../Online-sever(1Panel 线上版) +├── bench.py 性能与时长准确率测试(对应开题报告预期目标) +├── tests/ 根因准确率扰动测试、考核指标口径测试(见下方“测试”) ├── data/ sites.csv / data_outage.csv / data_alarm.csv 种子数据,outage.db 自动生成 ├── static/ 前端(全部可直接阅读和修改) │ ├── index.html 页面入口,importmap 把 'vendor' / 'echarts' 指向 vendor/ 下的文件 @@ -42,8 +43,6 @@ Local-sever/ │ │ ├── components/ ui(卡片/指标/标签/下拉)、DataTable(表格+分页)、FormDialog、EChart、icons │ │ └── pages/ index.js 页面注册表 + 10 个业务页面,一页一个文件 │ └── vendor/ 第三方库(React、液态玻璃组件库、htm、ECharts),压缩文件,不要手改 -├── tools/vendor-build/ 只在升级第三方库时使用,见下文 -└── _legacy_frontend/ 最早的原生 JS 前端,仅供对照,可删除 ``` ## 修改前端 @@ -68,7 +67,7 @@ html`<${Section} title="标题" span=${6}><${EChart} option=${opt}/>${Section} ### 升级第三方库(很少需要) -`static/vendor/` 由 `tools/vendor-build/` 一次性生成。只有升级 React、组件库或 ECharts,或需要新的 React API / 新的图表类型时才需要 Node.js 20.19+: +`static/vendor/` 由 `tools/vendor-build/`(不在本仓库中)一次性生成。只有升级 React、组件库或 ECharts,或需要新的 React API / 新的图表类型时才需要 Node.js 20.19+: ```bash cd tools/vendor-build @@ -112,12 +111,29 @@ npm run build # 重新生成 ../../static/vendor/ ## 核心算法(core.py) - **退服时长**:一律按“恢复时间 − 开始时间”重算;上报时长保存为 `reported_min`,两者相差超过 1 分钟即标记为“时长差错”。 -- **退服率** = 总退服时长 ÷(站点数 × 统计时长);**网络可用率** = 1 − 退服率。 -- **超长退服站点**:月均超长退服 ≥ 1 次(单次时长 ≥ 场景阈值)。**高频重复站点**:月均退服次数 ≥ 场景次数阈值。两个阈值都可在页面上配置。 -- **根因判定分两级**: - 1. 衍生关系:“小区退服”告警带有 `parent_alarm_id` 时,直接取父告警的类别。 - 2. 时间窗:回溯退服前未清除的同站告警,按优先级判定:割接施工(30 分钟)→ 电源故障(300 分钟)→ 机房环境(180 分钟)→ 传输中断(15 分钟)→ 天馈故障(30 分钟)→ 设备硬件(15 分钟)。 +- **统计周期**:顶栏筛选了月份 / 日期范围时取筛选范围(同时有则取交集),否则取全部流水首日 0 点到末日 24 点。 +- **退服率** = 总退服时长 ÷(站点数 × 统计周期);**网络可用率** = 1 − 退服率。站点数按场景、片区、站型、厂家、站名关键字筛选。看板、对标与导出用同一口径。 +- **超长退服站点**:月均超长退服 ≥ 1 次(单次时长 ≥ 场景阈值)。**高频重复站点**:月均退服次数 ≥ 场景次数阈值。“月均”按统计周期的自然月数计算。**重复退服率** = 高频重复站点数 ÷ 站点数。 +- **根因判定分三级**(每条结果带置信度 高 / 中 / 低): + 0. 衍生告警归并:带 `parent_alarm_id` 的告警按父告警类别计(停电引起的传输告警归为电源故障)。 + 1. 衍生关系(高):与退服开始相差 ≤ 2 分钟的“小区退服”告警带父告警时,取父告警类别。 + 2. 时间窗(中):同站在退服时仍未清除、提前量在该类时间窗内的告警。 + 3. 疑似(低):时间窗放宽到 3 倍才命中,提示人工复核。 - 准确率按“上报原因大类 × 判定根因”交叉矩阵计算,样例数据约 98%。 + 多条命中时依次比较:级别 → 是否随业务恢复清除(±15 分钟)→ 规则优先级(割接施工 → 电源故障 → 机房环境 → 传输中断 → 天馈故障 → 设备硬件)→ 时间早;都没有命中判为“其他”。 +- **时间窗标定**:每次全量分析前,用已闭环流水中同站同类告警的提前量 95% 分位数标定各类时间窗(不小于默认值 30/300/180/15/30/15 分钟,不大于 720 分钟;样本少于 30 条时沿用默认值)。 +- **告警—退服关联量化**:对每类告警计算支持度(退服前 W 分钟内有该类告警的退服占比)、置信度(该类告警其后 W 分钟内发生退服的比例)、提升度(置信度 ÷ 随机窗口遇到退服的概率)。 - **断站分级**:重要 / 主要 / 次要,对应不同的处置响应时限。 -- **影响评估**:受影响用户 = 小区数 × 单小区在线用户 × 忙闲时系数;业务损失 = 小区话务 × 退服时长。 +- **影响评估**:受影响用户 = 小区数 × 单小区在线用户 × 忙闲时系数 × 覆盖补偿系数;受影响用户·小时 = 受影响用户 × 退服时长;业务损失 = 小区话务 × 忙闲时系数 × 覆盖补偿系数 × 退服时长。覆盖补偿:500 米内每有一个邻站下降 10%(室分 5%),最低 40%。 + +## 测试 + +测试都在 `tests/_work/` 下建临时数据库,不影响 `data/outage.db`。 + +```bash +python tests/test_rootcause.py # 根因判定准确率:基线 + 6 组扰动数据(去父告警、时钟偏移、告警缺失、干扰告警、提前量变宽、综合) +python tests/test_kpi.py # 统计周期、稀疏筛选、月均口径、看板与导出一致、影响评估、关联量化 +python bench.py # 单批 1 万条导入耗时、全量分析耗时、时长计算准确率 +``` + +根因测试的时间窗只用 1~6 月流水标定,在 7~9 月流水上计分(留出检验)。数据为合成数据,准确率反映的是算法在设定扰动下的表现,论文中应同时说明扰动设置。 diff --git a/app.py b/app.py index 66f786b..d056f84 100644 --- a/app.py +++ b/app.py @@ -5,7 +5,7 @@ 接口分组(与下方代码顺序一致): 页面与认证 / /login /logout /healthz - 看板与统计 /api/meta /api/dashboard /api/stats /api/confusion /api/sites/rank + 看板与统计 /api/meta /api/dashboard /api/stats /api/confusion /api/association /api/sites/rank 退服流水 /api/outages(查询、新增、修改、删除、批量) /api/analyze 数据导入 /api/import/preview /api/import/confirm /api/template 站点与场景 /api/sites /api/scenes @@ -154,7 +154,8 @@ def dashboard(): started = time.time() filters = current_filters() df = core.frame(filters) - stats = core.site_stats(df) + minutes, months = core.period(filters) + stats = core.site_stats(df, months) # 月度趋势:次数与时长(小时) trend = df.groupby('month').agg(n=('id', 'size'), h=('duration_min', 'sum')).reset_index() @@ -175,11 +176,12 @@ def dashboard(): scene_sites = core.site_count({**filters, 'scene': scene}) if scene_sites == 0: continue - scene_kpi = core.kpis(df[df['scene'] == scene], scene_sites) + scene_kpi = core.kpis(df[df['scene'] == scene], scene_sites, minutes, months) bench.append(dict(scene=scene, **scene_kpi)) return jsonify( - kpi=core.kpis(df, core.site_count(filters)), + kpi=core.kpis(df, core.site_count(filters), minutes, months), + period=dict(days=round(minutes / 1440, 1), months=months), elapsed=round(time.time() - started, 3), rank=to_records(stats.head(15), ['site_name', 'scene', 'total_min', 'count']), trend=trend.to_dict('records'), @@ -209,10 +211,10 @@ def stats(): grouped = df.groupby(dimension).agg( count=('id', 'size'), total_min=('duration_min', 'sum'), avg_min=('duration_min', 'mean'), max_min=('duration_min', 'max'), long_count=('is_long', 'sum'), users=('affected_users', 'sum'), - loss_gb=('loss_gb', 'sum'), sites=('site_name', 'nunique'), + user_h=('user_hours', 'sum'), loss_gb=('loss_gb', 'sum'), sites=('site_name', 'nunique'), ).reset_index() grouped['long_ratio'] = (grouped['long_count'] / grouped['count'] * 100).round(2) - grouped = grouped.round({'total_min': 1, 'avg_min': 1, 'loss_gb': 1}) + grouped = grouped.round({'total_min': 1, 'avg_min': 1, 'loss_gb': 1, 'user_h': 1}) sort = request.args.get('sort', 'total_min') if sort not in grouped.columns: @@ -231,14 +233,29 @@ def confusion(): df = df[df['cause_category'].isin(core.CAUSES)] matrix = pd.crosstab(df['cause_category'], df['root_cause']) matrix = matrix.reindex(index=core.CAUSES, columns=core.CAUSES, fill_value=0) - return jsonify(causes=core.CAUSES, matrix=matrix.values.tolist()) + # 按置信度分组的准确率:用来说明“高 / 中 / 低”置信度标签是否可信 + by_confidence = [] + for level in ['高', '中', '低']: + part = df[df['confidence'] == level] + if len(part): + by_confidence.append(dict(level=level, n=len(part), + acc=round((part['cause_category'] == part['root_cause']).mean() * 100, 2))) + return jsonify(causes=core.CAUSES, matrix=matrix.values.tolist(), by_confidence=by_confidence) + + +@app.route('/api/association') +@login_required +def association(): + """告警类别 → 退服 的关联强度(支持度、置信度、提升度)与当前使用的时间窗。""" + return jsonify(rows=core.association(current_filters()), windows=core.window_table()) @app.route('/api/sites/rank') @login_required def site_rank(): """超长退服站点(kind=long)/ 高频重复站点(kind=repeat)清单,附处置建议。""" - stats = core.site_stats(core.frame(current_filters())) + filters = current_filters() + stats = core.site_stats(core.frame(filters), core.period(filters)[1]) kind = request.args.get('kind', 'long') if kind == 'long': stats = stats[stats['long']] @@ -254,8 +271,8 @@ def site_rank(): # ================================================================ 退服流水管理 OUTAGE_LIST_COLUMNS = ['id', 'record_id', 'ne_id', 'cell_id', 'site_name', 'scene', 'site_type', 'region', 'vendor', 'start_time', 'end_time', 'duration_min', 'reported_min', 'dur_diff', 'cause_category', - 'cause_detail', 'cause_code', 'ticket_id', 'root_cause', 'evidence', 'level', 'status', - 'handler', 'remark', 'affected_users', 'loss_gb', 'advice'] + 'cause_detail', 'cause_code', 'ticket_id', 'root_cause', 'evidence', 'confidence', 'level', + 'status', 'handler', 'remark', 'affected_users', 'user_hours', 'loss_gb', 'advice'] # 新增 / 管理员修改时写入的字段,顺序与 outage_values() 返回值一致 OUTAGE_EDIT_FIELDS = ['record_id', 'ne_id', 'cell_id', 'start_time', 'end_time', 'duration_min', 'cause_category', @@ -380,12 +397,12 @@ def outage_batch(): @app.route('/api/analyze', methods=['POST']) @admin_required def reanalyze(): - """对全部退服流水重新做根因分析(修改阈值或导入告警后使用)。""" + """先按历史流水重新标定时间窗,再对全部退服流水重新做根因分析(导入告警或流水后使用)。""" started = time.time() count = core.analyze_all() accuracy = core.kpis(core.frame())['acc'] log(session['user'], '全量根因分析', f'{count} 条') - return jsonify(n=count, elapsed=round(time.time() - started, 3), acc=accuracy) + return jsonify(n=count, elapsed=round(time.time() - started, 3), acc=accuracy, windows=core.window_table()) # ================================================================ 数据导入 @@ -523,6 +540,7 @@ EXPORT_COLUMN_NAMES = { 'duration_min': '系统计算时长(分)', 'reported_min': '上报时长(分)', 'cause_category': '上报原因大类', 'cause_detail': '原因细项', 'cause_code': '原因码', 'ticket_id': '工单号', 'root_cause': '系统判定根因', 'evidence': '关联告警', 'level': '断站分级', 'status': '闭环状态', 'advice': '处置建议', 'record_id': '流水号', + 'confidence': '判定置信度', 'user_h': '受影响用户·小时', 'user_hours': '受影响用户·小时', } @@ -546,20 +564,23 @@ def excel_response(sheets, filename): @login_required def export(kind): """三类报表:stats 退服统计表、long 超长退服站点清单、advice 根因处置建议清单。""" - df = core.frame(current_filters()) - stats = core.site_stats(df) + filters = current_filters() + df = core.frame(filters) + minutes, months = core.period(filters) + stats = core.site_stats(df, months) stamp = datetime.now().strftime('%Y%m%d%H%M') if kind == 'stats': - k = core.kpis(df) + k = core.kpis(df, core.site_count(filters), minutes, months) # 与看板同一口径 kpi_rows = [ ['退服次数', k['count']], ['累计退服时长(小时)', k['total_h']], ['平均退服时长(分钟)', k['avg_min']], ['退服率(%)', k['outage_rate']], ['网络可用率(%)', k['availability']], ['超长退服占比(%)', k['long_ratio']], - ['重复退服率(%)', k['repeat_rate']], ['受影响用户数', k['users']], ['业务损失(GB)', k['loss_gb']], + ['重复退服率(%)', k['repeat_rate']], ['受影响用户数', k['users']], ['受影响用户·小时', k['user_h']], + ['业务损失(GB)', k['loss_gb']], ['统计站点数', k['sites']], ['统计周期(天)', round(minutes / 1440, 1)], ['根因判定准确率(%)', k['acc']], ['闭环率(%)', k['closed']], ['上报时长差错(条)', k['dur_fix']], ] site_columns = ['ne_id', 'site_name', 'region', 'scene', 'site_type', 'count', 'total_min', 'avg_min', - 'max_min', 'long_count', 'users', 'top_cause'] + 'max_min', 'long_count', 'users', 'user_h', 'top_cause'] sheets = { '考核指标': pd.DataFrame(kpi_rows, columns=['指标', '数值']), '站点退服统计': stats[site_columns].rename(columns=EXPORT_COLUMN_NAMES), @@ -589,7 +610,8 @@ def export(kind): for cause, level in zip(long_outages['root_cause'], long_outages['level'])] long_outages = long_outages.sort_values('duration_min', ascending=False) columns = ['record_id', 'ne_id', 'site_name', 'scene', 'start_time', 'end_time', 'duration_min', - 'cause_category', 'cause_code', 'root_cause', 'evidence', 'level', 'status', 'ticket_id', 'advice'] + 'cause_category', 'cause_code', 'root_cause', 'evidence', 'confidence', 'level', 'status', + 'ticket_id', 'advice'] sheets = {'根因处置建议': long_outages[columns].rename(columns=EXPORT_COLUMN_NAMES)} title = '根因处置建议清单' diff --git a/bench.py b/bench.py new file mode 100644 index 0000000..c93d3ff --- /dev/null +++ b/bench.py @@ -0,0 +1,71 @@ +"""性能与时长计算准确率测试(对应开题报告的预期目标),走 Flask 接口,结果可直接写入论文测试章节。 + + - 单批 10000 条退服流水导入(预览校验 + 确认入库 + 新记录根因分析)≤ 15 秒 + - 单次全量退服时长计算与根因分析 ≤ 8 秒 + - 退服时长计算准确率 ≥ 98%(以生成器真值为准),并核对人工上报时长差错的检出 + +运行:python bench.py 数据库建在 tests/_work 下,不影响 data/outage.db +""" +import io +import os +import sys +import time + +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), 'tests')) +import harness # noqa: E402 设置数据库路径 +from harness import check, core, finish, generate # noqa: E402 + +if os.path.exists(os.environ['OUTAGE_DB']): + os.remove(os.environ['OUTAGE_DB']) +core.DB_PATH = os.environ['OUTAGE_DB'] +started = time.time() +import app as webapp # noqa: E402 导入时 init_db:建库 + 样例数据入库 + 全量分析 +print(f'首次建库、样例入库与全量分析: {time.time() - started:.2f} s') + +client = webapp.app.test_client() +client.post('/login', json={'username': 'admin', 'password': 'admin123'}) + + +def timed(label, request): + begin = time.time() + response = request() + elapsed = time.time() - begin + print(f'{label}: {elapsed:.2f} s(HTTP {response.status_code})') + return response, elapsed + + +# 10000 条新流水:同一站点库,取生成序列第 6001~16000 条,避免与样例数据重复 +_, alarms_big, outages_big = generate('bench', rows=16000) +batch = outages_big.iloc[6000:16000] +upload = io.BytesIO(batch.to_csv(index=False).encode('utf-8-sig')) +response, t_preview = timed('导入预览 10000 条', lambda: client.post( + '/api/import/preview', data={'file': (upload, 'batch.csv')}, content_type='multipart/form-data')) +preview = response.get_json() +print(f' 合格 {preview["ok"]},问题 {preview["bad"]},上报时长差错 {preview["diff"]}') +response, t_confirm = timed('导入确认(入库 + 新记录根因分析)', lambda: client.post( + '/api/import/confirm', json={'token': preview['token']})) +check('单批 10000 条导入 ≤ 15 s', t_preview + t_confirm <= 15, f'({t_preview + t_confirm:.2f} s)') + +upload = io.BytesIO(alarms_big.to_csv(index=False).encode('utf-8-sig')) +response, _ = timed(f'告警预览 {len(alarms_big)} 条', lambda: client.post( + '/api/import/preview', data={'file': (upload, 'alarm.csv')}, content_type='multipart/form-data')) +timed('告警确认(入库 + 全量重新标定与关联)', lambda: client.post( + '/api/import/confirm', json={'token': response.get_json()['token']})) + +total = core.query('SELECT COUNT(*) AS n FROM outages')[0]['n'] +response, t_analyze = timed(f'全量根因分析 /api/analyze({total} 条,含时间窗标定)', + lambda: client.post('/api/analyze')) +core.data_changed() +response, t_dashboard = timed('看板首次请求(全量时长与指标重算)', lambda: client.get('/api/dashboard')) +check('全量时长计算与根因分析 ≤ 8 s', t_analyze + t_dashboard <= 8, f'({t_analyze + t_dashboard:.2f} s)') + +df = core.full_frame() +true_minutes = (core.pd.to_datetime(df['end_time']) - df['start']).dt.total_seconds() / 60 +accuracy = ((df['duration_min'] - true_minutes).abs() < 0.05).mean() * 100 +check('退服时长计算准确率 ≥ 98%', accuracy >= 98, f'({accuracy:.2f}%)') +injected = (df['reported_min'] - true_minutes).abs() > 1 +missed = int((injected & ~df['dur_diff']).sum()) +false_alarm = int((~injected & df['dur_diff']).sum()) +check('人工上报时长差错全部检出且无误报', missed == 0 and false_alarm == 0, + f'(注入 {int(injected.sum())} 条,标记 {int(df["dur_diff"].sum())} 条)') +finish() diff --git a/core.py b/core.py index 7bbc5a8..3e6a189 100644 --- a/core.py +++ b/core.py @@ -38,9 +38,10 @@ SCENE_DEFAULT = { '工业园区': (180, 5, 120, 7), } -# 时间窗规则:(告警类别, 判定根因, 告警最多早于退服多少分钟),按优先级从高到低排列。 +# 时间窗规则:(告警类别, 判定根因, 默认时间窗:告警最多早于退服多少分钟),按优先级从高到低排列。 # 割接操作最先排除;停电有蓄电池后备、机房高温有过热保护延时,所以窗口放宽; # 停电往往同时引起传输告警,因为电源优先级更高,这种情况归为电源故障。 +# 实际使用的窗口由 calibrate_windows() 按历史流水标定(只会放宽,不会小于这里的默认值)。 RULES = [ ('割接施工', '割接施工', 30), ('电源故障', '电源故障', 300), @@ -49,6 +50,21 @@ RULES = [ ('天馈故障', '天馈故障', 30), ('设备硬件', '设备硬件', 15), ] +DEFAULT_WINDOW = {category: window for category, _, window in RULES} +PRIORITY = {category: rank for rank, (category, _, _) in enumerate(RULES)} + +MATCH_TOL_MIN = 2 # 第一级:“小区退服”告警与退服开始时间允许相差的分钟数(网管与工单系统时钟不完全同步) +CLEAR_TOL_MIN = 15 # 告警清除与业务恢复相差在此范围内,视为“随业务恢复清除”,作为根因的佐证 +SUSPECT_FACTOR = 3 # 第三级:时间窗放宽到几倍仍命中的,判为“疑似”根因(置信度低) +WINDOW_MAX = 720 # 标定后的时间窗上限(分钟) +CALIB_QUANTILE = 0.95 # 标定取历史提前量的分位数 +CALIB_MIN_SAMPLES = 30 # 某类样本少于此数时不标定,沿用默认窗口 + +# 覆盖补偿:退服站点周边 COVER_RADIUS_M 米内每有一个邻站,受影响用户和话务损失按 COVER_STEP 递减(邻站吸收部分话务), +# 最低保留 COVER_FLOOR。室分站主要覆盖室内,室外邻站补偿有限,递减幅度减半。 +COVER_RADIUS_M = 500 +COVER_STEP = 0.1 +COVER_FLOOR = 0.4 ADVICE = { '电源故障': ['核查市电及开关电源状态,必要时调度油机发电', '检测蓄电池组容量,老化电池纳入更换计划', '评估加装智能电表与远程动环监控'], @@ -123,23 +139,38 @@ CREATE TABLE IF NOT EXISTS sites(ne_id TEXT PRIMARY KEY, site_name TEXT, distric CREATE TABLE IF NOT EXISTS outages(id INTEGER PRIMARY KEY, record_id TEXT, ne_id TEXT, cell_id TEXT, start_time TEXT, end_time TEXT, duration_min REAL, reported_min REAL, cause_category TEXT, cause_detail TEXT, cause_code TEXT, ticket_id TEXT, root_cause TEXT, evidence TEXT, status TEXT DEFAULT '待处理', - handler TEXT, remark TEXT); + handler TEXT, remark TEXT, confidence TEXT); CREATE INDEX IF NOT EXISTS ix_out_ne ON outages(ne_id, start_time); CREATE TABLE IF NOT EXISTS alarms(alarm_id TEXT PRIMARY KEY, ne_id TEXT, alarm_code TEXT, alarm_name TEXT, alarm_level TEXT, category TEXT, start_time TEXT, clear_time TEXT, duration_s INTEGER, cleared TEXT, parent_alarm_id TEXT); CREATE INDEX IF NOT EXISTS ix_alarm_ne ON alarms(ne_id, start_time); CREATE TABLE IF NOT EXISTS logs(id INTEGER PRIMARY KEY, username TEXT, action TEXT, detail TEXT, ts TEXT); +CREATE TABLE IF NOT EXISTS windows(category TEXT PRIMARY KEY, window_min REAL, default_min REAL, samples INTEGER, + source TEXT, updated_at TEXT); """ +def migrate(): + """旧版数据库补字段:outages.confidence(根因判定置信度)。补了字段返回 True,需要重新做一次全量分析。""" + with db() as conn: + columns = {row['name'] for row in conn.execute('PRAGMA table_info(outages)')} + if 'confidence' not in columns: + conn.execute('ALTER TABLE outages ADD COLUMN confidence TEXT') + return True + return False + + def init_db(): """启动时调用:建表;数据库文件是第一次创建时,再写入默认账号、场景阈值,并导入 data/ 下的样例数据。""" is_first_run = not os.path.exists(DB_PATH) os.makedirs(os.path.dirname(DB_PATH), exist_ok=True) with db() as conn: conn.executescript(SCHEMA) + upgraded = migrate() if not is_first_run: + if upgraded: + analyze_all() # 旧库升级:按新算法重新标定时间窗并补上置信度 return now = datetime.now().strftime(TIME_FMT) @@ -218,88 +249,279 @@ def save_sites(df): # ================================================================ 5. 根因关联分析 -def analyze(outages): +def read_alarms(ne_ids=None, categories=None): + """读取告警(可按基站、类别过滤),时间列解析为 datetime,开始时间列改名为 alarm_time。""" + conditions = [] + args = [] + if ne_ids is not None: + ne_ids = list(ne_ids) + if not ne_ids: + return pd.DataFrame(columns=['alarm_id', 'ne_id', 'alarm_name', 'category', 'alarm_time', 'clear_time', + 'parent_alarm_id']) + # 基站很多时(导入全网工参后)不用 IN (?, ?, ...),避免超过 SQLite 的参数个数上限 + conditions.append('ne_id IN (SELECT value FROM json_each(?))') + args.append(pd.Series(ne_ids).to_json(orient='values', force_ascii=False)) + if categories is not None: + conditions.append('category IN (SELECT value FROM json_each(?))') + args.append(pd.Series(list(categories)).to_json(orient='values', force_ascii=False)) + sql = 'SELECT alarm_id, ne_id, alarm_name, category, start_time, clear_time, parent_alarm_id FROM alarms' + if conditions: + sql += ' WHERE ' + ' AND '.join(conditions) + with db() as conn: + alarms = pd.read_sql(sql, conn, params=args) + alarms['start_time'] = pd.to_datetime(alarms['start_time'], errors='coerce', format='mixed') + alarms['clear_time'] = pd.to_datetime(alarms['clear_time'], errors='coerce', format='mixed') + alarms = alarms.dropna(subset=['start_time']) + return alarms.rename(columns={'start_time': 'alarm_time'}) + + +def still_active(alarm_clear, outage_start): + """告警在退服开始时仍未清除(允许 1 分钟误差)才可能是退服的原因。""" + return alarm_clear.isna() | (alarm_clear >= outage_start - pd.Timedelta(minutes=1)) + + +def calibrate_windows(until=None): """ - 两级根因判定。outages 需含 id, ne_id, start_time 三列,返回 [(根因, 证据, id), ...]。 - 第一级 衍生关系:同站、同一时刻的“小区退服”告警如果带 parent_alarm_id,直接取父告警的类别 - (网管已经给出因果链,最可靠); - 第二级 时间窗: 否则回溯同站在退服前仍未清除的告警,按 RULES 的优先级取第一个命中的类别; - 都没有命中判为“其他”。 + 用历史流水标定各类根因告警的时间窗(告警最多早于退服多少分钟),结果写入 windows 表并返回 {类别: 分钟}。 + 样本:已闭环、上报原因属于规则类别的退服(until 指定时只用该日期之前的,便于留出检验); + 在同站、同类别、退服时仍未清除、提前量不超过 WINDOW_MAX 的告警中,取离退服最近的一条,记其提前量; + 窗口:提前量的 95% 分位数,不小于默认窗口、不大于 WINDOW_MAX;样本少于 30 条时沿用默认窗口。 + 这样时间窗随本地网络的实际情况(蓄电池后备时长、动环告警延时等)自动调整,而不是写死在代码里。 + """ + categories = list(DEFAULT_WINDOW) + sql = ("SELECT id, ne_id, start_time, cause_category FROM outages WHERE status = '已闭环' " + "AND cause_category IN (SELECT value FROM json_each(?))") + args = [pd.Series(categories).to_json(orient='values', force_ascii=False)] + if until: + sql += ' AND start_time < ?' + args.append(until) + with db() as conn: + outages = pd.read_sql(sql, conn, params=args) + outages['start_time'] = pd.to_datetime(outages['start_time']) + + alarms = read_alarms(outages['ne_id'].unique(), categories) + pairs = outages.merge(alarms, left_on=['ne_id', 'cause_category'], right_on=['ne_id', 'category']) + lead = (pairs['start_time'] - pairs['alarm_time']).dt.total_seconds() / 60 + usable = still_active(pairs['clear_time'], pairs['start_time']) & (lead >= -5) & (lead <= WINDOW_MAX) + pairs = pairs[usable].assign(lead=lead[usable].clip(lower=0)) + nearest = pairs.sort_values('lead').drop_duplicates('id') + + now = datetime.now().strftime(TIME_FMT) + result = {} + rows = [] + for category in categories: + leads = nearest.loc[nearest['cause_category'] == category, 'lead'] + default = DEFAULT_WINDOW[category] + if len(leads) >= CALIB_MIN_SAMPLES: + window = float(min(max(leads.quantile(CALIB_QUANTILE), default), WINDOW_MAX)) + source = '历史标定' + else: + window = float(default) + source = '默认(样本不足)' + result[category] = round(window, 1) + rows.append((category, round(window, 1), default, int(len(leads)), source, now)) + with db() as conn: + conn.execute('DELETE FROM windows') + conn.executemany('INSERT INTO windows VALUES(?,?,?,?,?,?)', rows) + return result + + +def load_windows(): + """当前使用的时间窗 {类别: 分钟};未标定的类别用默认窗口。""" + windows = dict(DEFAULT_WINDOW) + for row in query('SELECT category, window_min FROM windows'): + if row['category'] in windows and row['window_min']: + windows[row['category']] = row['window_min'] + return windows + + +def window_table(): + """时间窗明细(页面展示用)。""" + saved = {row['category']: row for row in query('SELECT * FROM windows')} + rows = [] + for category, _, default in RULES: + row = saved.get(category) or {'window_min': default, 'samples': 0, 'source': '默认', 'updated_at': ''} + rows.append(dict(category=category, priority=PRIORITY[category] + 1, default_min=default, + window_min=row['window_min'], samples=row['samples'], source=row['source'], + updated_at=row['updated_at'])) + return rows + + +def analyze(outages, windows=None): + """ + 三级根因判定。outages 需含 id, ne_id, start_time, end_time 四列,返回 [(根因, 证据, 置信度, id), ...]。 + 预处理 衍生告警归并:告警带 parent_alarm_id 且父告警属于根因类别时,按父告警的类别和名称计 + (如停电引起的传输告警归为电源故障); + 第一级 衍生关系(置信度高):同站“小区退服”告警与退服开始相差不超过 MATCH_TOL_MIN 分钟、且带父告警, + 直接取父告警类别; + 第二级 时间窗(置信度中):同站在退服时仍未清除、提前量在该类时间窗内的告警; + 第三级 疑似(置信度低):时间窗放宽到 SUSPECT_FACTOR 倍才命中的告警,提示人工复核; + 多条命中时依次比较:级别 → 是否随业务恢复清除(清除与恢复相差 ≤ CLEAR_TOL_MIN 分钟)→ 规则优先级 → 时间早; + 都没有命中判为“其他”。 """ if outages.empty: return [] + windows = windows or load_windows() - # 只取涉及到的基站的告警,避免全表读取 - ne_ids = tuple(outages['ne_id'].dropna().unique()) - placeholders = ','.join('?' * len(ne_ids)) - with db() as conn: - alarms = pd.read_sql(f'SELECT alarm_id, ne_id, alarm_name, category, start_time, clear_time, parent_alarm_id ' - f'FROM alarms WHERE ne_id IN ({placeholders})', conn, params=ne_ids, - parse_dates=['start_time', 'clear_time']) - alarms = alarms.rename(columns={'start_time': 'alarm_time'}) - - outages = outages[['id', 'ne_id', 'start_time']].copy() + outages = outages[['id', 'ne_id', 'start_time', 'end_time']].copy() outages['start_time'] = pd.to_datetime(outages['start_time']) + outages['end_time'] = pd.to_datetime(outages['end_time']) + alarms = read_alarms(outages['ne_id'].dropna().unique()) - results = {} # 退服 id -> (根因, 证据) + # ---- 预处理:衍生告警按父告警计 + alarms['root_cat'] = alarms['category'] + alarms['root_name'] = alarms['alarm_name'] + parents = alarms.drop_duplicates('alarm_id').set_index('alarm_id') + parent_id = alarms['parent_alarm_id'].fillna('') + parent_cat = parent_id.map(parents['category']) + linked = parent_cat.isin(DEFAULT_WINDOW) + alarms.loc[linked, 'root_cat'] = parent_cat[linked] + alarms.loc[linked, 'root_name'] = parent_id[linked].map(parents['alarm_name']) + # 证据里显示的告警名:衍生告警写成“传输告警(衍生自 市电停电)” + alarms['show_name'] = alarms['alarm_name'] + alarms.loc[linked, 'show_name'] = alarms.loc[linked, 'alarm_name'] + '(衍生自 ' + alarms.loc[linked, 'root_name'] + ')' - # ---- 第一级:衍生关系。找到带父告警的“小区退服”告警,再查出父告警的类别 - child_alarms = alarms[(alarms['category'] == '小区退服') & alarms['parent_alarm_id'].fillna('').ne('')] - child_alarms = child_alarms[['ne_id', 'alarm_time', 'parent_alarm_id']].rename(columns={'alarm_time': 'start_time'}) - parent_alarms = alarms.drop(columns=['ne_id', 'parent_alarm_id']) - child_with_parent = child_alarms.merge(parent_alarms, left_on='parent_alarm_id', right_on='alarm_id') - matched = outages.merge(child_with_parent, on=['ne_id', 'start_time']).drop_duplicates('id') + results = {} # 退服 id -> (根因, 证据, 置信度) + + # ---- 第一级:衍生关系 + child = alarms[(alarms['category'] == '小区退服') & linked][['ne_id', 'alarm_time', 'root_cat', 'root_name']] + matched = outages.merge(child, on='ne_id') + gap = (matched['alarm_time'] - matched['start_time']).abs() + matched = matched[gap <= pd.Timedelta(minutes=MATCH_TOL_MIN)].assign(gap=gap) + matched = matched.sort_values(['id', 'gap']).drop_duplicates('id') for row in matched.itertuples(): - if row.category in CAUSES: - evidence = f'衍生关系:{row.alarm_name}@{row.alarm_time:%m-%d %H:%M}' - results[row.id] = (row.category, evidence) + results[row.id] = (row.root_cat, f'衍生关系:{row.root_name} → 小区退服@{row.alarm_time:%m-%d %H:%M}', '高') - # ---- 第二级:时间窗。把剩余退服与同站的根因类告警两两配对,逐条规则打标 + # ---- 第二、三级:时间窗与疑似 remaining = outages[~outages['id'].isin(results)] - pairs = remaining.merge(alarms[alarms['category'] != '小区退服'], on='ne_id') - minutes_before = (pairs['start_time'] - pairs['alarm_time']).dt.total_seconds() / 60 - # 告警在退服时仍未清除(允许 1 分钟误差)才可能是原因 - still_active = pairs['clear_time'].isna() | (pairs['clear_time'] >= pairs['start_time'] - pd.Timedelta(minutes=1)) + candidates = alarms[(alarms['category'] != '小区退服') & alarms['root_cat'].isin(DEFAULT_WINDOW)] + pairs = remaining.merge(candidates, on='ne_id') + lead = (pairs['start_time'] - pairs['alarm_time']).dt.total_seconds() / 60 + window = pairs['root_cat'].map(windows).astype(float) + active = still_active(pairs['clear_time'], pairs['start_time']) & (lead >= -5) + pairs['tier'] = np.select([active & (lead <= window), active & (lead <= window * SUSPECT_FACTOR)], [0, 1], 9) + clear_gap = (pairs['clear_time'] - pairs['end_time']).abs() + pairs['sync'] = clear_gap <= pd.Timedelta(minutes=CLEAR_TOL_MIN) + pairs['unsync'] = ~pairs['sync'] + pairs['prio'] = pairs['root_cat'].map(PRIORITY) - pairs['rank'] = 99 # 命中规则的序号,越小优先级越高;99 表示没有命中 - for rank, (category, _, window) in enumerate(RULES): - hit = ((pairs['category'] == category) & (minutes_before <= window) & (minutes_before >= -5) - & still_active & (pairs['rank'] > rank)) - pairs.loc[hit, 'rank'] = rank - - # 每条退服取优先级最高、时间最早的一条告警作为根因 - best = pairs[pairs['rank'] < 99].sort_values(['id', 'rank', 'alarm_time']).drop_duplicates('id') + best = pairs[pairs['tier'] < 9].sort_values(['id', 'tier', 'unsync', 'prio', 'alarm_time']).drop_duplicates('id') for row in best.itertuples(): - evidence = f'时间窗:{row.alarm_name}@{row.alarm_time:%m-%d %H:%M}' - results[row.id] = (RULES[row.rank][1], evidence) + sync_note = ',随业务恢复清除' if row.sync else '' + if row.tier == 0: + results[row.id] = (row.root_cat, f'时间窗:{row.show_name}@{row.alarm_time:%m-%d %H:%M}{sync_note}', '中') + else: + results[row.id] = (row.root_cat, f'疑似(超出时间窗):{row.show_name}@{row.alarm_time:%m-%d %H:%M}' + f'{sync_note},建议人工复核', '低') output = [] for outage_id in outages['id']: - cause, evidence = results.get(outage_id, ('其他', '时间窗内无关联告警')) - output.append((cause, evidence, int(outage_id))) + cause, evidence, confidence = results.get(outage_id, ('其他', '时间窗内无关联告警', '低')) + output.append((cause, evidence, confidence, int(outage_id))) return output -def analyze_all(ids=None): - """对指定 id(不传则全部)的退服流水重新做根因分析并写回数据库,返回分析条数。""" - sql = 'SELECT id, ne_id, start_time FROM outages' - if ids: - sql += ' WHERE id IN (' + ','.join(str(i) for i in ids) + ')' +def analyze_all(ids=None, recalibrate=True): + """ + 对指定 id 的退服流水(ids=None 表示全部)重新做根因分析并写回数据库,返回分析条数。 + 全量分析前先按历史流水重新标定时间窗(recalibrate=False 时沿用已有窗口)。 + """ + if ids is not None and len(ids) == 0: + return 0 + if ids is None and recalibrate: + calibrate_windows() + + sql = 'SELECT id, ne_id, start_time, end_time FROM outages' + if ids is not None: + sql += ' WHERE id IN (' + ','.join(str(int(i)) for i in ids) + ')' with db() as conn: outages = pd.read_sql(sql, conn) results = analyze(outages) with db() as conn: - conn.executemany('UPDATE outages SET root_cause=?, evidence=? WHERE id=?', results) + conn.executemany('UPDATE outages SET root_cause=?, evidence=?, confidence=? WHERE id=?', results) data_changed() return len(results) +def association(filters=None): + """ + 告警类别与退服的关联强度,规则为“同站出现 X 类告警 → 其后 W 分钟内发生退服”(W 为该类时间窗): + 告警数 n_A、命中数 n_AB(其后 W 分钟内同站发生退服的告警数) + 支持度 support = 开始前 W 分钟内同站有 X 类告警的退服数 ÷ 退服总数,即 P(X 类告警 | 退服) + 置信度 confidence = n_AB ÷ n_A,即 P(退服 | X 类告警) + 提升度 lift = 置信度 ÷ P0,P0 = 退服数 × W ÷(站点数 × 统计时长),即随机一个 W 分钟窗口内遇到退服的概率 + 提升度 > 1 说明该类告警出现后退服概率高于随机水平,数值越大关联越强。 + """ + filters = filters or {} + df = frame(filters) + lo, hi = period_bounds(filters) + minutes = max((hi - lo).total_seconds() / 60, 1440) + n_sites = max(site_count(filters), 1) + windows = load_windows() + + site_where, site_args = site_conditions(filters) + ne_ids = [row['ne_id'] for row in query('SELECT ne_id FROM sites' + site_where, site_args)] + alarms = read_alarms(ne_ids, list(DEFAULT_WINDOW)) + alarms = alarms[(alarms['alarm_time'] >= lo) & (alarms['alarm_time'] < hi)] + outages = df[['id', 'ne_id', 'start']].dropna().sort_values('start') + + rows = [] + for category, _, _ in RULES: + window = windows[category] + tolerance = pd.Timedelta(minutes=window) + cat_alarms = alarms.loc[alarms['category'] == category, ['ne_id', 'alarm_time']].sort_values('alarm_time') + hits = 0 + if len(cat_alarms) and len(outages): + forward = pd.merge_asof(cat_alarms, outages, left_on='alarm_time', right_on='start', by='ne_id', + direction='forward', tolerance=tolerance) + hits = int(forward['start'].notna().sum()) + covered = 0 + if len(cat_alarms) and len(outages): + backward = pd.merge_asof(outages, cat_alarms, left_on='start', right_on='alarm_time', by='ne_id', + direction='backward', tolerance=tolerance) + covered = int(backward['alarm_time'].notna().sum()) + p0 = min(len(outages) * window / (n_sites * minutes), 1) if len(outages) else 0 + confidence = hits / len(cat_alarms) if len(cat_alarms) else 0 + rows.append(dict( + category=category, window_min=window, alarms=len(cat_alarms), hits=hits, + support=round(covered / len(outages) * 100, 2) if len(outages) else 0, + confidence=round(confidence * 100, 2), + lift=round(confidence / p0, 2) if p0 else 0, + )) + return rows + + # ================================================================ 6. 指标核算 +def site_cover(): + """ + 各站覆盖补偿系数 {ne_id: 系数}:COVER_RADIUS_M 米内的邻站数 n,系数 = max(COVER_FLOOR, 1 − COVER_STEP × n), + 室分站递减幅度减半。距离按经纬度近似换算(城市范围内误差可忽略);没有经纬度的站系数为 1。 + """ + sites = pd.DataFrame(query('SELECT ne_id, site_type, lng, lat FROM sites')) + if sites.empty: + return {} + sites = sites.dropna(subset=['lng', 'lat']) + if sites.empty: + return {} + lat0 = np.radians(sites['lat'].astype(float).mean()) + x = sites['lng'].to_numpy(float) * 111320 * np.cos(lat0) + y = sites['lat'].to_numpy(float) * 110540 + neighbors = np.zeros(len(sites), dtype=int) + for begin in range(0, len(sites), 1000): # 分块计算,站点很多时不会一次占用大量内存 + dx = x[begin:begin + 1000, None] - x[None, :] + dy = y[begin:begin + 1000, None] - y[None, :] + neighbors[begin:begin + 1000] = ((dx * dx + dy * dy) <= COVER_RADIUS_M ** 2).sum(axis=1) - 1 + step = np.where(sites['site_type'].eq('室分'), COVER_STEP / 2, COVER_STEP) + factor = np.clip(1 - step * neighbors, COVER_FLOOR, 1) + return dict(zip(sites['ne_id'], factor.round(3))) + + def full_frame(): """ 全部退服流水 + 站点信息 + 场景阈值,并计算派生字段: - is_long 是否超长、dur_diff 上报时长差错、affected_users 受影响用户、loss_gb 业务损失、level 断站分级。 + is_long 是否超长、dur_diff 上报时长差错、cover_factor 覆盖补偿系数、affected_users 受影响用户、 + user_hours 受影响用户·小时、loss_gb 业务损失、level 断站分级。 结果缓存到数据变化为止(见 data_changed)。 """ global _frame_cache @@ -319,11 +541,18 @@ def full_frame(): df['is_long'] = df['duration_min'] >= long_min df['dur_diff'] = (df['reported_min'] - df['duration_min']).abs() > 1 # 人工上报时长与系统计算相差超过 1 分钟 - # 影响评估:受影响用户 = 小区数 × 单小区在线用户 × 忙闲时系数;业务损失 = 小区数 × 单小区话务 × 系数 × 时长 + # 影响评估: + # 受影响用户 = 小区数 × 单小区在线用户 × 忙闲时系数 × 覆盖补偿系数(同一时刻掉线的用户数) + # 受影响用户·小时 = 受影响用户 × 退服时长(小时),反映影响的持续程度 + # 业务损失 = 小区数 × 单小区每小时话务 × 忙闲时系数 × 覆盖补偿系数 × 退服时长(小时) busy_factor = np.where(df['start'].dt.hour.between(9, 22), 1.0, 0.35) # 9-22 点为忙时 cells = df['cells'].fillna(3).astype(float) - df['affected_users'] = (cells * df['users_per_cell'].fillna(200) * busy_factor).round().astype(int) - df['loss_gb'] = (cells * df['gb_per_cell_h'].fillna(10) * busy_factor * df['duration_min'] / 60).round(2) + df['cover_factor'] = df['ne_id'].map(site_cover()).fillna(1.0).astype(float) + hours = df['duration_min'] / 60 + users = cells * df['users_per_cell'].fillna(200) * busy_factor * df['cover_factor'] + df['affected_users'] = users.round().astype(int) + df['user_hours'] = (users * hours).round(1) + df['loss_gb'] = (cells * df['gb_per_cell_h'].fillna(10) * busy_factor * df['cover_factor'] * hours).round(2) # 断站分级(按整列一次计算,比逐行判断快几十倍): # 重要:超长,且是关键场景或时长超过阈值 2 倍 @@ -362,8 +591,49 @@ def frame(filters=None): return df.copy() -def site_count(filters=None): - """满足站点类筛选条件(场景、片区、站型、厂家)的站点数,用作退服率的分母。""" +def period_bounds(filters=None): + """ + 统计周期 [起, 止)。有月份 / 日期范围筛选时取筛选范围(同时有则取交集), + 否则取全部退服流水首日 0 点到末日 24 点。 + """ + filters = filters or {} + df = full_frame() + if df.empty: + today = pd.Timestamp.now().normalize() + lo, hi = today, today + pd.Timedelta(days=1) + else: + lo = df['start'].min().normalize() + hi = df['start'].max().normalize() + pd.Timedelta(days=1) + + lowers = [] + uppers = [] + if filters.get('month'): + month_start = pd.Timestamp(filters['month'] + '-01') + lowers.append(month_start) + uppers.append(month_start + pd.offsets.MonthBegin(1)) + if filters.get('date_from'): + lowers.append(pd.Timestamp(filters['date_from'])) + if filters.get('date_to'): + uppers.append(pd.Timestamp(filters['date_to']) + pd.Timedelta(days=1)) + if lowers: + lo = max(lowers) + if uppers: + hi = min(uppers) + if hi <= lo: + hi = lo + pd.Timedelta(days=1) + return lo, hi + + +def period(filters=None): + """统计周期的 (分钟数, 自然月数):分钟数是退服率的时间分母,月数是“月均”的分母。""" + lo, hi = period_bounds(filters) + minutes = (hi - lo).total_seconds() / 60 + months = len(pd.period_range(lo, hi - pd.Timedelta(seconds=1), freq='M')) + return minutes, max(months, 1) + + +def site_conditions(filters=None): + """站点类筛选(场景、片区、站型、厂家、站名/站号关键字)对应的 WHERE 子句与参数。""" filters = filters or {} column_of = {'scene': 'scene', 'region': 'district', 'site_type': 'site_type', 'vendor': 'vendor'} conditions = [] @@ -372,30 +642,42 @@ def site_count(filters=None): if filters.get(key): conditions.append(f'{column} = ?') args.append(filters[key]) - - sql = 'SELECT COUNT(*) AS n FROM sites' - if conditions: - sql += ' WHERE ' + ' AND '.join(conditions) - return query(sql, args)[0]['n'] + if filters.get('site'): + conditions.append('(instr(site_name, ?) > 0 OR instr(ne_id, ?) > 0)') # 与 frame() 一样区分大小写 + args += [filters['site'], filters['site']] + if not conditions: + return '', [] + return ' WHERE ' + ' AND '.join(conditions), args -def kpis(df, n_sites=None): +def site_count(filters=None): + """满足站点类筛选条件的站点数,用作退服率、重复退服率的分母。""" + where, args = site_conditions(filters) + return query('SELECT COUNT(*) AS n FROM sites' + where, args)[0]['n'] + + +def kpis(df, n_sites=None, minutes=None, months=None): """ - 运维考核指标。 + 运维考核指标。n_sites / minutes / months 为站点数、统计时长(分钟)、统计月数,不传时按全量计算。 退服率 = 总退服时长 ÷(站点数 × 统计时长);网络可用率 = 1 − 退服率 + 重复退服率 = 高频重复站点数 ÷ 站点数 根因判定准确率 = 上报原因与系统判定一致的比例(只统计上报原因已填写的记录) """ - if not n_sites: + if n_sites is None: n_sites = site_count() + if minutes is None or months is None: + default_minutes, default_months = period() + minutes = minutes or default_minutes + months = months or default_months if df.empty: return dict(count=0, total_h=0, avg_min=0, outage_rate=0, availability=100, long_ratio=0, repeat_rate=0, - users=0, loss_gb=0, sites=n_sites, acc=0, dur_fix=0, closed=0) + users=0, user_h=0, loss_gb=0, sites=n_sites, acc=0, dur_fix=0, closed=0) total_minutes = df['duration_min'].sum() - period_minutes = max((df['start'].max() - df['start'].min()).total_seconds() / 60, 1) - outage_rate = total_minutes / (n_sites * period_minutes) * 100 + denominator = max(n_sites, 1) * max(minutes, 1) + outage_rate = total_minutes / denominator * 100 - stats = site_stats(df) + stats = site_stats(df, months) known = df[df['cause_category'].isin(CAUSES) & df['root_cause'].notna()] if len(known): @@ -410,8 +692,9 @@ def kpis(df, n_sites=None): outage_rate=round(outage_rate, 4), availability=round(100 - outage_rate, 4), long_ratio=round(df['is_long'].mean() * 100, 2), - repeat_rate=round(stats['repeat'].mean() * 100, 2), + repeat_rate=round(stats['repeat'].sum() / max(n_sites, 1) * 100, 2), users=int(df['affected_users'].sum()), + user_h=int(round(float(df['user_hours'].sum()))), loss_gb=round(df['loss_gb'].sum(), 1), sites=n_sites, acc=accuracy, @@ -420,19 +703,23 @@ def kpis(df, n_sites=None): ) -def site_stats(df): +def site_stats(df, months=None): """ - 站点维度统计,按累计退服时长从大到小排序。 + 站点维度统计,按累计退服时长从大到小排序。months 为统计周期的自然月数,不传时按全量周期。 超长退服站点 long:月均超长退服 ≥ 1 次 高频重复站点 repeat:月均退服次数 ≥ 场景次数阈值 """ if df.empty: - return pd.DataFrame(columns=['site_name', 'count', 'total_min', 'long', 'repeat']) + return pd.DataFrame(columns=['ne_id', 'site_name', 'region', 'scene', 'site_type', 'count', 'total_min', + 'avg_min', 'max_min', 'long_count', 'users', 'user_h', 'long_min', 'freq_count', + 'top_cause', 'long', 'repeat']) + if months is None: + months = period()[1] stats = df.groupby(['ne_id', 'site_name', 'region', 'scene', 'site_type'], dropna=False).agg( count=('id', 'size'), total_min=('duration_min', 'sum'), avg_min=('duration_min', 'mean'), max_min=('duration_min', 'max'), long_count=('is_long', 'sum'), users=('affected_users', 'sum'), - long_min=('long_min', 'first'), freq_count=('freq_count', 'first'), + user_h=('user_hours', 'sum'), long_min=('long_min', 'first'), freq_count=('freq_count', 'first'), ).reset_index() # 主要根因:每站出现次数最多的根因;次数相同时取名称排序靠前的(与 pandas 的 mode 结果一致) @@ -441,11 +728,12 @@ def site_stats(df): top_cause = cause_counts.drop_duplicates('ne_id').set_index('ne_id')['root_cause'] stats['top_cause'] = stats['ne_id'].map(top_cause).fillna('') - months = max(df['month'].nunique(), 1) + months = max(months, 1) stats['long'] = stats['long_count'] / months >= 1 stats['repeat'] = stats['count'] / months >= stats['freq_count'].fillna(4) stats['total_min'] = stats['total_min'].round(1) stats['avg_min'] = stats['avg_min'].round(1) + stats['user_h'] = stats['user_h'].round(1) return stats.sort_values('total_min', ascending=False) diff --git a/static/js/pages/Impact.js b/static/js/pages/Impact.js index 4f8a5b3..c063575 100644 --- a/static/js/pages/Impact.js +++ b/static/js/pages/Impact.js @@ -9,7 +9,8 @@ const BENCH_COLUMNS = [ {key: 'scene', title: '场景'}, {key: 'sites', title: '站点数'}, {key: 'count', title: '退服次数'}, {key: 'total_h', title: '累计时长(h)'}, {key: 'avg_min', title: '平均时长(min)'}, {key: 'outage_rate', title: '退服率(%)'}, {key: 'availability', title: '可用率(%)'}, {key: 'long_ratio', title: '超长占比(%)'}, {key: 'repeat_rate', title: '重复退服率(%)'}, - {key: 'users', title: '受影响用户', render: num}, {key: 'loss_gb', title: '业务损失(GB)', render: num}, + {key: 'users', title: '受影响用户', render: num}, {key: 'user_h', title: '用户·小时', render: num}, + {key: 'loss_gb', title: '业务损失(GB)', render: num}, ]; /** 场景柱状图配置:最大的场景用强调色标出 */ @@ -24,14 +25,15 @@ export default function Impact() { const {filters} = useApp(); const {data} = useFetch('/api/dashboard', filters); if (!data) return html`<${Loading}/>`; - const {kpi: k, bench} = data; + const {kpi: k, bench, period} = data; return html`