| """Calibration of a built expert task against its own pristine and oracle states. |
| |
| derive_storms storm sets read off the pristine snapshots (H20: every service whose page fires in the |
| unreachable cluster has to be held back, not only the ones a packet happens to list) |
| label-less exempts alertnames that fire label-less in the oracle state of a scenario |
| background_alerts untouched alerts of a ticket's service that fire anyway (never the fix, left out of counts) |
| q_pristine per requirement, from one grade of the pristine workspace |
| """ |
|
|
| from __future__ import annotations |
|
|
| import math |
| import shutil |
| import tempfile |
|
|
| from ..grader.loader import parse_rule_file |
|
|
| PAGE_SEV = ("page", "critical") |
| TICKET_SHARE = 0.55 |
| TICKET_WEIGHT = 6 |
| ROUTE_TICKET_WEIGHT = 4 |
|
|
|
|
| def ticket_weights(spec: dict) -> None: |
| """Symptom tickets weigh 6 (E3's route and inhibition tickets 4), then all of them are scaled up together, |
| rounded up, until they hold TICKET_SHARE of the total weight, so that a run doing only the routine work never |
| outranks one that diagnoses the tickets.""" |
| reqs = spec["requirements"] |
| tick = [r for r in reqs if r.get("ticket")] |
| if not tick: |
| return |
| for r in tick: |
| r["weight"] = ROUTE_TICKET_WEIGHT if spec["family"] == "E3" and r["kind"] in ("route", "inhibit") else TICKET_WEIGHT |
| routine = sum(r["weight"] for r in reqs if not r.get("ticket")) |
| tw = sum(r["weight"] for r in tick) |
| need = TICKET_SHARE / (1 - TICKET_SHARE) * routine |
| if tw < need: |
| k = need / tw |
| for r in tick: |
| r["weight"] = math.ceil(r["weight"] * k - 1e-9) |
|
|
|
|
| def _snapshots(groups: list, mapping: dict, tag: str) -> dict: |
| from ..grader import snap |
| files = [parse_rule_file(k, v) for k, v in sorted(mapping.items()) if k.startswith("rules/")] |
| tmp = tempfile.mkdtemp(prefix=f"af-{tag}-") |
| try: |
| res, _ = snap.run_groups(groups, files, tmp, tag) |
| finally: |
| shutil.rmtree(tmp, ignore_errors=True) |
| |
| |
| bad = sorted(g["name"] for g in groups if res.get(g["name"]) is None) |
| if bad: |
| raise RuntimeError(f"calibration ({tag}): promtool returned no result for {len(bad)} group(s) {bad[:3]}; " |
| "check AF_PROMTOOL and that TMPDIR is a writable directory") |
| return res |
|
|
|
|
| def derive_storms(spec: dict, groups: list, pristine_map: dict) -> None: |
| """A storm group with `derive: {cluster, paged}`: `muted` is every service with a page firing in that cluster |
| during the storm window of the pristine state, minus the services that must still page (`paged`, down |
| elsewhere too). The requirement's service table keeps exactly the services the group grades.""" |
| gs = [g for g in groups if (g.get("storm") or {}).get("derive")] |
| if not gs: |
| return |
| res = _snapshots(gs, pristine_map, "storm") |
| graded: dict[str, set] = {} |
| for g in gs: |
| d = g["storm"].pop("derive") |
| fired = set() |
| for p in g["probes"]: |
| if p.get("family") != "storm": |
| continue |
| for a in (res.get(g["name"]) or {}).get(p["id"]) or []: |
| if a.get("cluster") == d["cluster"] and a.get("severity") in PAGE_SEV and a.get("service"): |
| fired.add(a["service"]) |
| keep = sorted(set(d.get("paged", []))) |
| g["storm"]["muted"] = sorted(fired - set(keep)) |
| g["storm"]["failing"] = g["storm"]["muted"] + keep |
| graded.setdefault(g["req"], set()).update(g["storm"]["failing"]) |
| for r in spec["requirements"]: |
| if r["id"] in graded: |
| r["storm"]["services"] = {s: v for s, v in r["storm"]["services"].items() if s in graded[r["id"]]} |
|
|
|
|
| def calibrate(spec, groups, pristine_map, oracle_map, tests_dir) -> None: |
| """Storm sets, label-less exemptions (alertnames that fire label-less in the oracle state of a scenario: a |
| defect that pages label-less in the pristine state must not exempt itself), then q_pristine per requirement.""" |
| from .build import grade_map, write_tests |
| derive_storms(spec, groups, pristine_map) |
| gprobe = [{**g, "probes": [p for p in g["probes"] if p.get("family") == "G"]} for g in groups] |
| gprobe = [g for g in gprobe if g["probes"]] |
| res = _snapshots(gprobe, oracle_map, "cal") |
| exempt: dict[str, set] = {} |
| for g in gprobe: |
| got = (res.get(g["name"]) or {}).get(g["probes"][0]["id"]) or [] |
| exempt.setdefault(g["name"], set()).update(a.get("alertname", "") for a in got) |
| for g in groups: |
| if g["name"] in exempt: |
| g["g_exempt"] = sorted(exempt[g["name"]]) |
| background_alerts(spec, groups, pristine_map, oracle_map) |
| write_tests(tests_dir, spec, groups) |
| keys, det = grade_map(spec, tests_dir, pristine_map) |
| for r in spec["requirements"]: |
| r["q_pristine"] = det["requirements"][r["id"]]["q"] |
|
|
|
|
| def background_alerts(spec, groups, pristine_map, oracle_map) -> None: |
| """Untouched alerts of the ticket's service that fire in a scenario in the pristine or the oracle state |
| (a burn alert on the same outage, say) can never be the fix: they are left out of that group's counts.""" |
| from ..grader.xscore import CLASS_SEV |
| reqs = {r["id"]: r for r in spec["requirements"] if r["kind"] == "outcome"} |
| og = [g for g in groups if g["req"] in reqs] |
| seen: dict[str, set] = {} |
| for mp in (pristine_map, oracle_map): |
| res = _snapshots(og, mp, "bg") |
| for g in og: |
| oc = reqs[g["req"]]["outcome"] |
| for p in g["probes"]: |
| if not str(p.get("family", "")).startswith(("F_", "S_")) or p["type"] == "count": |
| continue |
| cls = p.get("class") or oc["services"][p["svc"]]["class"] |
| for pid in p.get("any_of", [p["id"]]): |
| for a in (res.get(g["name"]) or {}).get(pid) or []: |
| if a.get("service") == p["svc"] and a.get("severity") in CLASS_SEV[cls]: |
| seen.setdefault(g["name"], set()).add(a.get("alertname", "")) |
| for g in og: |
| touch = set(reqs[g["req"]]["outcome"]["touch"]) | {reqs[g["req"]]["outcome"].get("alertname")} |
| ex = sorted(seen.get(g["name"], set()) - touch) |
| if ex: |
| g["o_exempt"] = ex |
|
|
