File size: 8,022 Bytes
f3b0a91 | 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 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 | """Alertmanager world: routing policy, oracle config, R01-R06 defects, route and inhibit cases.
Expected receiver sets come from `policy()` (the written team convention), not from the oracle YAML;
the gate proves that the oracle config resolves to the policy with the real amtool.
"""
from __future__ import annotations
import copy
import random
CATCHALL = "slack-sre-catchall"
JIRA = "jira-sre"
def policy(team: str, severity: str) -> list[str]:
"""Routing convention (README): page → PagerDuty + Slack; warning → Slack; ticket → Jira + Slack."""
return sorted({"page": [f"pagerduty-{team}", f"slack-{team}"], "warning": [f"slack-{team}"],
"ticket": [JIRA, f"slack-{team}"]}[severity])
def team_route(team: str) -> dict:
return {"matchers": [f'team="{team}"'], "receiver": f"slack-{team}",
"routes": [{"matchers": ['severity="page"'], "receiver": f"pagerduty-{team}", "continue": True},
{"matchers": ['severity=~"page|warning"'], "receiver": f"slack-{team}"}]}
def receivers(teams: list[str], domain: str) -> list[dict]:
out = [{"name": CATCHALL, "slack_configs": [{"channel": "#sre-alerts", "send_resolved": True}]},
{"name": JIRA, "webhook_configs": [{"url": f"http://jira-bridge.{domain}:9095/alerts/SRE"}]},
{"name": "null-sink"}]
for t in teams:
out.append({"name": f"pagerduty-{t}", "pagerduty_configs": [{"routing_key": f"PD_{t.upper().replace('-', '_')}_KEY"}]})
out.append({"name": f"slack-{t}", "slack_configs": [{"channel": f"#{t}-alerts", "send_resolved": True}]})
return out
def base_config(teams_routed: list[str], all_teams: list[str], domain: str) -> dict:
return {
"global": {"resolve_timeout": "5m", "slack_api_url": "https://hooks.slack.invalid/services/T000/B000/XXXX"},
"route": {"receiver": CATCHALL, "group_by": ["alertname", "service"], "group_wait": "30s",
"group_interval": "5m", "repeat_interval": "4h",
"routes": [{"matchers": ['severity="ticket"'], "receiver": JIRA, "continue": True}]
+ [team_route(t) for t in teams_routed]},
"receivers": receivers(all_teams, domain),
"inhibit_rules": [{"source_matchers": ['severity="page"'], "target_matchers": ['severity="warning"'],
"equal": ["alertname", "service"]}],
}
def inhibit_rule(source: str, targets: list[str]) -> dict:
return {"source_matchers": [f'alertname="{source}"'],
"target_matchers": [f'alertname=~"{"|".join(sorted(targets))}"'], "equal": ["service"]}
def _team_idx(cfg: dict, team: str) -> int:
return next(i for i, r in enumerate(cfg["route"]["routes"]) if r.get("matchers") == [f'team="{team}"'])
def apply_route_defect(cfg: dict, defect: str, team: str, service: str, rng: random.Random) -> dict:
"""Pristine config for a Route requirement: 'add' removes the team subtree; R01-R04 break it."""
c = copy.deepcopy(cfg)
routes = c["route"]["routes"]
i = _team_idx(c, team)
if defect == "add":
routes.pop(i)
elif defect == "R01":
j = rng.randrange(1, len(team) - 1)
typo = team[:j] + team[j + 1:]
routes[i]["matchers"] = [f'team="{typo}"']
elif defect == "R02":
routes.insert(i, {"matchers": [f'service="{service}"'], "receiver": f"slack-{team}"})
elif defect == "R03":
routes[i]["routes"][0].pop("continue")
elif defect == "R04":
routes[i]["routes"][0]["matchers"] = ['severity=~"page|ticket"']
else:
raise ValueError(defect)
return c
def apply_inhibit_defect(cfg: dict, defect: str, rule: dict) -> dict:
c = copy.deepcopy(cfg)
idx = c["inhibit_rules"].index(rule)
if defect == "add":
c["inhibit_rules"].pop(idx)
elif defect == "R05":
c["inhibit_rules"][idx] = {k: v for k, v in rule.items() if k != "equal"}
elif defect == "R06":
c["inhibit_rules"][idx] = {"source_matchers": rule["target_matchers"],
"target_matchers": rule["source_matchers"], "equal": rule["equal"]}
else:
raise ValueError(defect)
return c
def route_cases(team: str, service: str, other_team: str, alert_names: dict[str, str]) -> dict:
"""Positive cases (Jaccard) and negative cases (forbidden receivers) for one team's routing."""
pos, neg = [], []
for sev in ("page", "ticket", "warning"):
lab = {"alertname": alert_names.get(sev, f"Synthetic{sev.title()}Alert"), "severity": sev,
"team": team, "service": service}
pos.append({"labels": lab, "expect": policy(team, sev)})
own = {f"pagerduty-{team}", f"slack-{team}"}
neg.append({"labels": {"alertname": "SyntheticTicketAlert", "severity": "ticket", "team": team,
"service": service}, "forbid": [f"pagerduty-{team}"]})
neg.append({"labels": {"alertname": "SyntheticPageAlert", "severity": "page", "team": other_team,
"service": service}, "forbid": sorted(own)})
neg.append({"labels": {"alertname": "SyntheticWarningAlert", "severity": "warning", "team": team,
"service": service}, "forbid": [f"pagerduty-{team}"]})
return {"pos": pos, "neg": neg}
def preserved_route_cases(teams: list[str], services: dict[str, str]) -> list[dict]:
"""Label sets for untouched teams whose receivers must not change."""
out = []
for t in teams:
svc = services.get(t, f"{t}-svc")
for sev in ("page", "ticket", "warning"):
out.append({"labels": {"alertname": f"Preserved{sev.title()}", "severity": sev, "team": t,
"service": svc}, "expect": policy(t, sev)})
return out
def inhibit_cases(source: str, targets: list[str], service: str, other_service: str, team: str,
bystander: str) -> list[dict]:
"""Suppressed and not-suppressed cases for 'while <source> fires, suppress <targets> for the same service'."""
src = {"alertname": source, "service": service, "severity": "page", "team": team}
out = []
for t in targets:
tgt = {"alertname": t, "service": service, "severity": "page", "team": team}
out.append({"source": src, "target": tgt, "expect": True})
t0 = targets[0]
out += [
{"source": src, "target": {"alertname": t0, "service": other_service, "severity": "page", "team": team},
"expect": False},
{"source": {"alertname": t0, "service": service, "severity": "page", "team": team},
"target": {"alertname": source, "service": service, "severity": "page", "team": team}, "expect": False},
{"source": src, "target": {"alertname": bystander, "service": service, "severity": "warning", "team": team},
"expect": False},
]
return out
def preserved_inhibit_cases(pairs: list[tuple[str, str, str]], req_sources: dict[str, tuple[str, str]]) -> list[dict]:
"""The pristine 'page suppresses warning of the same alert+service' rule, plus H3 bystander cases.
pairs: (alertname, service, team) of untouched alerts. req_sources: req id -> (source alert, service).
"""
out = []
for name, svc, team in pairs:
base = {"alertname": name, "service": svc, "team": team}
out.append({"source": {**base, "severity": "page"}, "target": {**base, "severity": "warning"}, "expect": True})
out.append({"source": {**base, "severity": "page"}, "target": {**base, "service": svc + "-canary",
"severity": "warning"}, "expect": False})
for rid, (src, svc) in sorted(req_sources.items()):
for name, _, team in pairs[:2]:
out.append({"req": rid, "source": {"alertname": src, "service": svc, "severity": "page", "team": team},
"target": {"alertname": name, "service": svc, "severity": "warning", "team": team},
"expect": False})
return out
|