File size: 4,344 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 | """Preservation fast path for the expert tier: a rule's effective, normalised form.
The effective rule is the rule merged with its group: rule labels over group labels (the rule wins), plus the
group's interval, query_offset and limit. The expression is compared after collapsing whitespace; when that
differs, both sides go through `promtool --experimental promql format` (which canonicalises spacing, quoting,
durations and matcher order) with the label lists of by/without/on/ignoring/group_* sorted afterwards,
because the formatter keeps their order.
"""
from __future__ import annotations
import hashlib
import json
import re
import subprocess
from .loader import collapse, dur_s
from .promrun import tool
_FMT_CACHE: dict[str, str | None] = {}
_LIST = re.compile(r"\b(by|without|on|ignoring|group_left|group_right)\s*\(([^()]*)\)")
def _sort_lists(expr: str) -> str:
def fix(m):
items = [x.strip() for x in m.group(2).split(",") if x.strip()]
return f"{m.group(1)} ({', '.join(sorted(items))})"
return _LIST.sub(fix, expr)
def fmt_expr(expr: str) -> str | None:
key = collapse(expr)
if key not in _FMT_CACHE:
try:
r = subprocess.run([tool("promtool"), "--experimental", "promql", "format", key],
capture_output=True, text=True, timeout=20)
_FMT_CACHE[key] = _sort_lists(collapse(r.stdout)) if r.returncode == 0 else None
except (subprocess.TimeoutExpired, OSError):
_FMT_CACHE[key] = None
return _FMT_CACHE[key]
def effective(rule: dict, group: dict) -> dict:
kind = "alert" if "alert" in rule else "record"
glabels = group.get("labels") if isinstance(group.get("labels"), dict) else {}
rlabels = rule.get("labels") if isinstance(rule.get("labels"), dict) else {}
labels = {str(k): str(v) for k, v in {**glabels, **rlabels}.items()}
ann = rule.get("annotations") if isinstance(rule.get("annotations"), dict) else {}
return {"k": kind, "n": str(rule.get(kind)), "expr": collapse(rule.get("expr", "")),
"for": dur_s(rule.get("for")), "kff": dur_s(rule.get("keep_firing_for")), "labels": labels,
"ann": {str(k): str(v) for k, v in ann.items()},
"g": [dur_s(group.get("interval")) or 60, dur_s(group.get("query_offset")), group.get("limit") or 0]}
def digest(eff: dict, expr_form: str | None = None) -> str:
d = dict(eff)
d["expr"] = expr_form if expr_form is not None else eff["expr"]
return hashlib.sha256(json.dumps(d, sort_keys=True).encode()).hexdigest()
def same_rule(eff: dict, want: dict) -> bool:
"""want: {"raw": digest over the collapsed text, "fmt": digest over the formatted text}."""
if digest(eff) == want["raw"]:
return True
f = fmt_expr(eff["expr"])
return f is not None and digest(eff, f) == want.get("fmt")
def preserved(rule: dict, group: dict) -> dict:
"""The effective rule as preservation compares it. An alert's annotations are left out: they change what
the notification says, not when it fires or where it goes (a description added to an untouched alert
is not a regression)."""
eff = effective(rule, group)
if eff["k"] == "alert":
eff["ann"] = {}
return eff
def pristine_entry(rule: dict, group: dict) -> dict:
eff = preserved(rule, group)
f = fmt_expr(eff["expr"])
out = {"kind": eff["k"], "name": eff["n"], "raw": digest(eff), "fmt": digest(eff, f) if f else None}
if eff["k"] == "alert": # the pristine form, replayed when the text changed (replay.py)
out["form"] = {"expr": eff["expr"], "for": eff["for"], "kff": eff["kff"], "labels": eff["labels"]}
return out
def core_eff(rule: dict, group: dict, keep_labels: tuple = ()) -> dict:
"""The effective rule reduced to its behaviour: expression, `for`, `keep_firing_for`, group fields and
only the named labels (annotations and other labels may change without changing what it does)."""
eff = effective(rule, group)
eff["labels"] = {k: v for k, v in eff["labels"].items() if k in keep_labels}
eff["ann"] = {}
return eff
def core_entry(rule: dict, group: dict, keep_labels: tuple = ()) -> dict:
eff = core_eff(rule, group, keep_labels)
f = fmt_expr(eff["expr"])
return {"raw": digest(eff), "fmt": digest(eff, f) if f else None}
|