| """Behavioural preservation, second step (G8): an untouched alert whose text changed is replayed. |
| |
| The fast path (norm.py) proves identity up to promtool formatting. When it fails for an untouched alert, the |
| pristine form and the current form run side by side over every hidden scenario and the task's exercise scenarios |
| (each service down, gone, erroring, saturated), in one extra promtool call. The alert is compared as a whole: |
| every pristine definition (a warning and a critical copy are two) against every current one. It passes when: |
| - both sides have the same set of `for`, `keep_firing_for` and expression signature: the expressions keep the |
| pristine's strings, numbers, durations and functions (operands may be reordered, a comparison flipped, a `by` |
| list written as `without`, an identical copy added); a changed threshold, window, aggregation or debounce is |
| never replayed into a pass; |
| - the two forms produce the same firing `ALERTS` series, labels included, at every minute of every scenario, and |
| the pristine form fires somewhere (a replay where nothing fires proves nothing). Labels are compared on what |
| fires: a static label equal to what the expression already yields on every series it returns (`service` on a |
| `sum by (service)` alert) changes nothing; one that changes or adds a value does. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import re |
|
|
| from .loader import RuleFile |
| from .norm import fmt_expr |
|
|
| _STR = re.compile(r'"(?:[^"\\]|\\.)*"|\'(?:[^\'\\]|\\.)*\'') |
| _NUM = re.compile(r"(?<![\w.])(?:\d+(?:\.\d+)?(?:[eE][+-]?\d+)?(?:ms|[smhdwy])?|\.\d+)(?![\w.])") |
| _LISTS = re.compile(r"\b(by|without|on|ignoring|group_left|group_right)\s*\([^()]*\)") |
| _IDENT = re.compile(r"[A-Za-z_:][\w:]*") |
| _FREE = {"by", "without", "on", "ignoring", "group_left", "group_right", "bool", "and", "or", "unless"} |
|
|
|
|
| def signature(expr: str) -> tuple | None: |
| """What an equivalent rewrite keeps: string literals, numbers and durations, metric and function names. |
| Label lists of by/without/on/ignoring and the set operators are left out (their rewrites are replayed).""" |
| f = fmt_expr(expr) |
| if f is None: |
| return None |
| strings = sorted(_STR.findall(f)) |
| rest = _LISTS.sub(" ", _STR.sub(" ", f)) |
| rest = re.sub(r"\{[^{}]*\}", " ", rest) |
| nums = sorted(_NUM.findall(rest)) |
| idents = sorted(x for x in _IDENT.findall(_NUM.sub(" ", rest)) if x not in _FREE) |
| return strings, nums, idents |
|
|
|
|
| def _dur(sec) -> str | None: |
| return f"{int(sec)}s" if isinstance(sec, (int, float)) and sec else (str(sec) if sec else None) |
|
|
|
|
| def _rule(name: str, form: dict) -> dict: |
| r = {"alert": name, "expr": form["expr"]} |
| if _dur(form.get("for")): |
| r["for"] = _dur(form["for"]) |
| if _dur(form.get("kff")): |
| r["keep_firing_for"] = _dur(form["kff"]) |
| if form.get("labels"): |
| r["labels"] = dict(form["labels"]) |
| return r |
|
|
|
|
| def _sig(form: dict): |
| sig = signature(form["expr"]) |
| return form.get("for"), form.get("kff"), None if sig is None else tuple(tuple(x) for x in sig) |
|
|
|
|
| def candidates(pairs: list[tuple[object, list, list]]) -> list[tuple[object, list, list]]: |
| """(item, pristine forms, current forms) worth replaying: an alert as a whole, every definition of it on each |
| side. The two sides have the same set of (`for`, `keep_firing_for`, expression signature): a copy may be added |
| (two identical definitions fire as one alert), dropped or rewritten, but no threshold, window, function or |
| debounce may change. The labels are compared by the replay, on the series that fire.""" |
| out = [] |
| for item, ps, cs in pairs: |
| sp, sc = {_sig(p) for p in ps}, {_sig(c) for c in cs} |
| if not ps or not cs or any(x[2] is None for x in sp | sc) or sp != sc: |
| continue |
| out.append((item, ps, cs)) |
| return out |
|
|
|
|
| def _end(g: dict) -> int: |
| return int(g.get("minutes") or max([p["t"] for p in g.get("probes", [])] or [60])) |
|
|
|
|
| def equivalent(pairs: list[tuple[object, list, list]], groups: list[dict], files: list[RuleFile], workdir: str, |
| masks: dict[str, list[str]]) -> set: |
| """Items whose pristine and current definitions behave the same on every scenario (see the module doc).""" |
| from . import snap |
| pairs = candidates(pairs) |
| if not pairs or not groups: |
| return set() |
| rules = [] |
| for i, (_, ps, cs) in enumerate(pairs): |
| rules += [_rule(f"AfReplayP{i}", p) for p in ps] + [_rule(f"AfReplayC{i}", c) for c in cs] |
| extra = RuleFile("rules/zz-af-replay.yml", [{"name": "af-replay", "rules": rules}]) |
| run, pre = [], {} |
| for k, g in enumerate(groups): |
| t = _end(g) |
| probes = [] |
| for i in range(len(pairs)): |
| pa = f'ALERTS{{alertname="AfReplayP{i}",alertstate="firing"}}' |
| ca = f'ALERTS{{alertname="AfReplayC{i}",alertstate="firing"}}' |
| diff = f"(count(({pa} unless ignoring (alertname) {ca}) or ({ca} unless ignoring (alertname) {pa})) or vector(0))" |
| fired = f"(count({pa}) or vector(0))" |
| probes += [{"type": "count", "id": f"rp{k}.d{i}", "expr": f"max_over_time({diff}[{t + 1}m:1m])", "t": t, "expect": 0}, |
| {"type": "count", "id": f"rp{k}.f{i}", "expr": f"max_over_time({fired}[{t + 1}m:1m])", "t": t, "expect": 0}] |
| name = f"rp{k}|{g['name']}" |
| run.append({"name": name, "input_series": g["input_series"], "probes": probes}) |
| if masks.get(g["name"]): |
| pre[name] = masks[g["name"]] |
| res, got_masks = snap.run_groups(run, list(files) + [extra], workdir, "rp", masks=pre) |
| ok = set() |
| for i, (item, _, _) in enumerate(pairs): |
| same, fired = True, False |
| for k, g in enumerate(run): |
| r = res.get(g["name"]) |
| if r is None or {f"AfReplayP{i}", f"AfReplayC{i}"} & set(got_masks.get(g["name"], [])): |
| same = False |
| break |
| same = same and r.get(f"rp{k}.d{i}") is True |
| fired = fired or r.get(f"rp{k}.f{i}") is False |
| if same and fired: |
| ok.add(item) |
| return ok |
|
|
