| """Preservation judges what an untouched alert does, not how it is written (grader/replay.py, xgrade._preservation). |
| |
| Regression: on afx-e3-s08 a pilot run solved every requirement and added `service: prior-auth-svc` to |
| `PriorAuthSvcDown`, whose expression already yields that label on both branches (README: `service` from the |
| expression or set statically). The Down alert is also the source of the OPS ticket's inhibition (R06). The edit |
| cost the preservation item and the outcome (reward 0.399). |
| """ |
|
|
| import os |
|
|
| import pytest |
|
|
| from conftest import HAVE_TOOLS |
|
|
| MASTER = 20260930 |
|
|
|
|
| def test_an_alert_is_replayed_as_a_whole(): |
| """Both sides must have the same set of (for, keep_firing_for, expression signature): an identical copy may be |
| added, a threshold may not change.""" |
| from alertforge.grader.replay import candidates |
| if not HAVE_TOOLS: |
| pytest.skip("promtool not available") |
| warn = {"expr": 'max by (service) (x{service="a"}) > 0.8', "for": 300.0, "kff": None, "labels": {"severity": "warning"}} |
| crit = {**warn, "expr": 'max by (service) (x{service="a"}) > 0.95', "labels": {"severity": "critical"}} |
| assert candidates([("k", [warn, crit], [crit, warn, dict(warn)])]) |
| assert candidates([("k", [warn], [{**warn, "labels": {"severity": "warning", "service": "a"}}])]) |
| assert not candidates([("k", [warn, crit], [warn, {**crit, "expr": crit["expr"].replace("0.95", "0.9")}])]) |
| assert not candidates([("k", [warn, crit], [warn])]) |
| assert not candidates([("k", [warn], [{**warn, "for": 600.0}])]) |
|
|
|
|
| @pytest.fixture(scope="module") |
| def e3s08(tmp_path_factory): |
| if not HAVE_TOOLS: |
| pytest.skip("promtool/amtool not available") |
| from alertforge.expert import build |
| return build.build_task("E3", 8, str(tmp_path_factory.mktemp("e3s08")), "afx-e3-s08", MASTER) |
|
|
|
|
| def _labelled(m, name, value, label="service", only_first=False, expr=None): |
| from alertforge.expert import solutions |
| from alertforge.expert.model import rules_named |
| files, am, _ = solutions.oracle(m) |
| for k, (_, _, r) in enumerate(rules_named(files, name)): |
| if only_first and k: |
| continue |
| r["labels"][label] = value |
| if expr is not None and k == 0: |
| r["expr"] = expr(r["expr"]) |
| return files, am |
|
|
|
|
| def _grade(m, files, am): |
| """(keys, {item: ok}, {item: replayed}); an alert with two definitions has two items of the same name: ok when |
| both are, replayed when either is.""" |
| from alertforge.expert.build import grade_map, state_map |
| keys, det = grade_map(m["spec"], os.path.dirname(m["hidden_dir"]), {**m["static"], **state_map(files, am)}) |
| ok, rep = {}, {} |
| for x in det["preservation_items"]: |
| ok[x["item"]] = ok.get(x["item"], True) and x["ok"] |
| rep[x["item"]] = rep.get(x["item"], False) or bool(x.get("replayed")) |
| return keys, ok, rep |
|
|
|
|
| @pytest.mark.slow |
| def test_static_own_service_on_an_untouched_alert_keeps_the_task_solved(e3s08): |
| """The pilot's edit, everything else the oracle: reward 1.0. Its alert is R06's source (the inhibition reads |
| `service` on both sides); the same edit on an alert no item is about passes by the replay.""" |
| m = e3s08 |
| r06 = next(i for i in m["items"] if i.code == "R06") |
| src = r06.p["source"] |
| keys, ok, _ = _grade(m, *_labelled(m, src, r06.p["svc"])) |
| assert keys["reward"] == 1.0, {k: v for k, v in ok.items() if not v} |
| pres = {e["name"]: e for e in m["spec"]["preserve"]["rules"]} |
| other = next(n for n, e in pres.items() if n.endswith("Down") and not e.get("svc") and e.get("n", 1) == 1) |
| svc = next(s.name for s in m["world"].services if other == f"{s.camel}Down") |
| keys, ok, rep = _grade(m, *_labelled(m, other, svc)) |
| assert keys["reward"] == 1.0 and rep[f"rule:{other}"], (ok[f"rule:{other}"], rep[f"rule:{other}"]) |
| |
| |
| from alertforge.expert import solutions |
| from alertforge.expert.model import RuleFileSpec, rules_named |
| burn = next(n for n, e in pres.items() if n.endswith("ErrorBudgetBurnSlow") and e.get("n", 1) == 1) |
| for bump, want in ((False, 1.0), (True, 0.0)): |
| files, am, _ = solutions.oracle(m) |
| copy = dict(next(r for _, _, r in rules_named(files, burn))) |
| if bump: |
| copy["expr"] = copy["expr"].replace("> (", "> 2 * (") |
| files["zz-copy"] = RuleFileSpec("zz-copy", 2, [{"name": "copy", "rules": [copy]}]) |
| keys, ok, _ = _grade(m, files, am) |
| assert keys["outcome"] == want, (bump, ok[f"rule:{burn}"]) |
|
|
|
|
| @pytest.mark.slow |
| def test_a_static_label_that_changes_what_fires_still_costs_preservation(e3s08): |
| m = e3s08 |
| r06 = next(i for i in m["items"] if i.code == "R06") |
| wrong = next(s.name for s in m["world"].services if s.name != r06.p["svc"]) |
| pres = {e["name"]: e for e in m["spec"]["preserve"]["rules"]} |
| other = next(n for n, e in pres.items() if n.endswith("Down") and not e.get("svc") and e.get("n", 1) == 1) |
| for name, value, label in ((r06.p["source"], wrong, "service"), (other, r06.p["svc"], "service"), |
| (other, "prod", "env")): |
| keys, ok, _ = _grade(m, *_labelled(m, name, value, label)) |
| assert keys["outcome"] == 0.0 and not ok[f"rule:{name}"], (name, label, value) |
|
|
|
|
| @pytest.mark.slow |
| def test_replay_pairs_the_definitions_of_a_two_copy_alert(e3s08): |
| """A warning and a critical copy under one name: each pristine copy the fast path misses is paired with a |
| current one and replayed (the saturated exercise scenarios make them fire). A changed threshold or a wrong |
| service on a copy still fails.""" |
| m = e3s08 |
| pres = {e["name"]: e for e in m["spec"]["preserve"]["rules"]} |
| two = next(n for n, e in pres.items() if e.get("n", 1) == 2 and e["kind"] == "alert" and not e.get("svc")) |
| svc = next(s.name for s in m["world"].services if two.startswith(s.camel)) |
| for only_first in (False, True): |
| keys, ok, rep = _grade(m, *_labelled(m, two, svc, only_first=only_first)) |
| assert keys["reward"] == 1.0 and ok[f"rule:{two}"] and rep[f"rule:{two}"], only_first |
| wrong = next(s.name for s in m["world"].services if s.name != svc) |
| keys, _, _ = _grade(m, *_labelled(m, two, wrong)) |
| assert keys["outcome"] == 0.0 |
| bump = _labelled(m, two, svc, expr=lambda e: e.replace("> 0.5", "> 0.6").replace("> 0.8", "> 0.85")) |
| keys, _, _ = _grade(m, *bump) |
| assert keys["outcome"] == 0.0 |
|
|
|
|
| |
|
|
| def test_labels_cover_the_required_ones_and_extras_route_alike(): |
| from alertforge.grader.xscore import _routes_alike, labels_cover |
| req = {"severity": "page", "team": "a"} |
| assert labels_cover({"severity": "page", "team": "a", "slo": "x-availability"}, req) |
| assert not labels_cover({"severity": "page"}, req) and not labels_cover({"severity": "critical", "team": "a"}, req) |
|
|
| class Ctx: |
| am = {"route": {}} |
|
|
| @staticmethod |
| def receivers(lab): |
| return ["pagerduty-a"] + (["pagerduty-b"] if lab.get("env") == "prod" else []) |
| assert _routes_alike(Ctx, "XDown", "x", {**req, "slo": "x-availability"}, req) |
| assert not _routes_alike(Ctx, "XDown", "x", {**req, "env": "prod"}, req) |
|
|
|
|
| @pytest.fixture(scope="module") |
| def e4s02(tmp_path_factory): |
| if not HAVE_TOOLS: |
| pytest.skip("promtool/amtool not available") |
| from alertforge.expert import build |
| return build.build_task("E4", 2, str(tmp_path_factory.mktemp("e4s02")), "afx-e4-s02", MASTER) |
|
|
|
|
| @pytest.mark.slow |
| def test_an_extra_label_on_the_floor_alert_keeps_the_task_solved(e4s02): |
| """A pilot run's floor alert carried `slo: member-api-availability` next to the required labels: the README |
| names the labels an alert carries and never says "only these" (T2 lost L, s 0.85). A wrong team still costs L.""" |
| from alertforge.expert import solutions |
| from alertforge.expert.build import grade_map, state_map |
| from alertforge.expert.model import rules_named |
| m = e4s02 |
| it = next(i for i in m["items"] if i.code == "H04") |
| s = m["world"].svc(it.p["svc"]) |
| for value, label, want in ((f"{s.name}-availability", "slo", 1.0), ("someone-else", "team", None)): |
| files, am, _ = solutions.oracle(m) |
| for _, _, r in rules_named(files, it.p["alert"]): |
| r["labels"][label] = value |
| keys, det = grade_map(m["spec"], os.path.dirname(m["hidden_dir"]), {**m["static"], **state_map(files, am)}) |
| r = det["requirements"][it.rid] |
| if want is not None: |
| assert keys["reward"] == want and r["s"] == 1.0, r |
| else: |
| assert r["s"] < 1 and r["families"]["L"] < 1, r |
|
|
|
|
| def test_label_moves_allow_extra_labels_but_not_another_service(): |
| """Migration (R03) and relabel (R10/R11) items: the wanted labels with their values, other labels allowed; a |
| static `service` must still be the alert's own (another value makes it a different service's alert), and an |
| old-team value still fails.""" |
| from alertforge.grader.loader import RuleRef |
| from alertforge.grader.xgrade import ExpertGrader |
|
|
| class C: |
| def __init__(self, labels): |
| self.alerts = {"XDown": [RuleRef("rules/x.yml", {"name": "x"}, |
| {"alert": "XDown", "expr": 'sum by (service) (up{service="x"}) == 0', |
| "labels": labels})]} |
| want = {"severity": "page", "team": "new"} |
| move = {"alert": "XDown", "labels": want, "svcs": ["x"], "n": 1, "allowed": [want]} |
| relabel = {"alert": "XDown", "labels": want, "svc": "x", "n": 1} |
| for lab, q in (({**want}, 1.0), ({**want, "slo": "x-availability"}, 1.0), ({**want, "service": "x"}, 1.0), |
| ({**want, "service": "y"}, 0.0), ({"severity": "page", "team": "old"}, 0.0), |
| ({"severity": "warning", "team": "new"}, 0.0)): |
| assert ExpertGrader._labels_match(C(lab), move) == q, lab |
| assert ExpertGrader._relabel_ok(C(lab), relabel) == q, lab |
|
|
