File size: 6,667 Bytes
44084af | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 | """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 # BM-4: diagnosis (the symptom tickets) is at least this share of a task's weight
TICKET_WEIGHT = 6
ROUTE_TICKET_WEIGHT = 4 # E3's tickets are routing/inhibition kinds, graded by cheaper case matrices
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)
# a group without a result is a promtool failure (timeout, no junit, a temp dir it can't write), not "nothing
# fired": calibrating on it would silently drop exemptions and storm sets, so the build stops here
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
|