File size: 7,120 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 163 164 165 166 167 168 169 170 171 172 173 | """Static checks: tamper rules, label/annotation checks (S1), preservation hashes (H2, H6)."""
from __future__ import annotations
import hashlib
import json
import re
from .loader import RuleRef, canon, dur_s
FORBIDDEN_LABELS = {"alertname", "alertstate", "__name__"}
_LABEL_FN = re.compile(r"label_(?:replace|join)\s*\((.*)", re.S)
_TEMPLATE_LABEL = re.compile(
r"\$labels\.([A-Za-z_][A-Za-z0-9_]*)|\.Labels\.([A-Za-z_][A-Za-z0-9_]*)"
r"|index\s+\$labels\s+\"([A-Za-z_][A-Za-z0-9_]*)\"")
def _label_fn_targets(expr: str) -> set[str]:
"""Destination labels of every label_replace/label_join call (second argument)."""
out = set()
text = expr
while True:
m = _LABEL_FN.search(text)
if not m:
return out
rest = m.group(1)
depth, i = 0, 0
while i < len(rest): # skip the first argument (balanced parentheses)
c = rest[i]
if c in "([{":
depth += 1
elif c in ")]}":
depth -= 1
elif c == "," and depth == 0:
break
i += 1
q = re.match(r'\s*,\s*"([^"]*)"', rest[i:])
if q:
out.add(q.group(1))
text = rest
def rule_tamper(every: list[RuleRef], input_metrics: set[str]) -> list[str]:
"""Series-injection and evaluation-knob tamper (H6, H7). Stray files are NOT tamper (S5)."""
reasons = []
seen_groups = set()
for ref in every:
g, r = ref.group, ref.rule
gid = (ref.file, str(g.get("name")))
if gid not in seen_groups:
seen_groups.add(gid)
if g.get("interval") not in (None, "") and dur_s(g.get("interval")) != 60:
reasons.append(f"group interval changed: {gid}")
if g.get("query_offset") not in (None, "", 0, "0s"):
reasons.append(f"group query_offset set: {gid}")
if g.get("limit") not in (None, 0):
reasons.append(f"group limit set: {gid}")
labels = r.get("labels") or {}
if not isinstance(labels, dict):
continue
expr = str(r.get("expr", ""))
if _label_fn_targets(expr) & FORBIDDEN_LABELS:
reasons.append(f"label_replace/label_join onto a reserved label in {ref.file}")
if "record" in r:
name = str(r["record"])
if name.startswith(("ALERTS", "__")) or name in input_metrics:
reasons.append(f"record shadows a reserved or input series: {name}")
if set(map(str, labels)) & FORBIDDEN_LABELS:
reasons.append(f"record {name} sets a reserved label")
elif set(map(str, labels)) & {"alertstate", "__name__", "alertname"}:
reasons.append(f"alert {r.get('alert')} sets a reserved label")
return reasons
def am_tamper(am: dict) -> list[str]:
"""Mute/active time intervals were never in pristine; using them silences pages (H2)."""
reasons = []
if am.get("time_intervals") or am.get("mute_time_intervals"):
reasons.append("alertmanager time_intervals added")
def walk(node, depth=0):
if not isinstance(node, dict) or depth > 50:
return
if node.get("mute_time_intervals") or node.get("active_time_intervals"):
reasons.append("route uses mute/active time intervals")
for child in node.get("routes") or []:
walk(child, depth + 1)
walk(am.get("route") or {})
return reasons
# ---------------------------------------------------------------------------- label / annotations
def template_labels(rule: dict) -> set[str]:
out = set()
for v in list((rule.get("annotations") or {}).values()) + list((rule.get("labels") or {}).values()):
for m in _TEMPLATE_LABEL.finditer(str(v)):
out.add(next(x for x in m.groups() if x))
return out
def summary_ok(rule: dict) -> bool:
ann = rule.get("annotations") or {}
s = ann.get("summary") if isinstance(ann, dict) else None
return isinstance(s, str) and s.strip() != "" and "service" in template_labels({"annotations": {"s": s}})
def runbook_ok(rule: dict, expected: str) -> bool:
ann = rule.get("annotations") or {}
return isinstance(ann, dict) and str(ann.get("runbook_url", "")).strip() == expected
def labels_ok(rule: dict, required: dict) -> bool:
"""Exact label block: every required label with its value, and no extra keys (H12)."""
labels = rule.get("labels") or {}
if not isinstance(labels, dict):
return False
return {str(k): str(v) for k, v in labels.items()} == {str(k): str(v) for k, v in required.items()}
def best_definition(defs: list[RuleRef], required: dict, runbook: str) -> tuple[RuleRef | None, dict]:
"""Pick the definition with the best static score (S4 "score the best definition")."""
best, best_res = None, {"labels": False, "summary": False, "runbook": False}
for d in defs:
res = {"labels": labels_ok(d.rule, required), "summary": summary_ok(d.rule),
"runbook": runbook_ok(d.rule, runbook)}
if best is None or sum(res.values()) > sum(best_res.values()):
best, best_res = d, res
return best, best_res
# ---------------------------------------------------------------------------- preservation
def _h(obj) -> str:
return hashlib.sha256(json.dumps(obj, sort_keys=True, default=str).encode()).hexdigest()
def am_hashes(am: dict) -> dict:
receivers = {}
for r in am.get("receivers") or []:
if isinstance(r, dict) and "name" in r:
receivers[str(r["name"])] = _h(r)
return {"global": _h(am.get("global") or {}), "receivers": receivers}
def preservation(every: list[RuleRef], alerts: dict, preserve: dict, am: dict | None,
route_results: list[bool], inhibit_results: list[bool]) -> tuple[float, list[dict]]:
"""Fraction of preserved items intact: untouched rules, AM global/receivers, route and inhibit cases."""
have: dict[str, int] = {}
for ref in every:
h = canon(ref.rule, ref.group)
have[h] = have.get(h, 0) + 1
items = []
for item in preserve.get("rules", []):
ok = have.get(item["hash"], 0) >= 1
if ok and item["kind"] == "alert":
ok = len(alerts.get(item["name"], [])) == 1 # duplicated untouched name → not preserved (H12)
items.append({"item": f"rule:{item['name']}", "ok": ok})
cur = am_hashes(am) if isinstance(am, dict) else {"global": None, "receivers": {}}
want = preserve.get("am", {})
if want:
items.append({"item": "am:global", "ok": cur["global"] == want.get("global")})
for name, h in sorted(want.get("receivers", {}).items()):
items.append({"item": f"am:receiver:{name}", "ok": cur["receivers"].get(name) == h})
for i, ok in enumerate(route_results):
items.append({"item": f"route_case:{i}", "ok": ok})
for i, ok in enumerate(inhibit_results):
items.append({"item": f"inhibit_case:{i}", "ok": ok})
if not items:
return 1.0, items
return sum(1 for x in items if x["ok"]) / len(items), items
|