| """Delivered notifications for the expert tier: inhibition, route walk with group_by, notification sets. |
| |
| - `inhibited(am, alerts)`: Alertmanager 0.28 inhibition over the alerts firing together. A target matching |
| a rule's target side is muted by a firing source that matches the source side and agrees on `equal`, |
| except that when the target also matches the source side, sources that match the target side are skipped |
| (Alertmanager's two-sided exclusion: two alerts that match both sides never mute each other). Inhibited |
| alerts still act as sources. |
| - `walk(am, labels)`: the matching leaf routes (first match wins unless `continue`), with the effective |
| receiver and group_by. A child's unset or empty `group_by` inherits the parent's; `'...'` groups on every |
| label. |
| - `notifications(am, path, text, snapshots)`: distinct (receiver, route, group key) over snapshot times, |
| after inhibition. Receivers come from amtool; a route walk that disagrees with amtool fails closed. |
| |
| Timers (group_wait, group_interval, repeat_interval) are out of scope: a notification is a group that has |
| at least one delivered alert at some snapshot. |
| """ |
|
|
| from __future__ import annotations |
|
|
| from .amcheck import Unsupported, resolve |
| from .matchers import compile_list, compile_value |
|
|
| ALL = "..." |
|
|
|
|
| def _parse(ms, legacy: dict | None, legacy_re: dict | None) -> list: |
| """`matchers` strings (Alertmanager's own grammar, see matchers.py) plus the legacy `match`/`match_re`.""" |
| out = compile_list(ms) |
| for d, op in ((legacy, "="), (legacy_re, "=~")): |
| if d is None: |
| continue |
| if not isinstance(d, dict): |
| raise Unsupported("match must be a mapping") |
| for k, v in d.items(): |
| out.append((str(k), compile_value(op, str(v)))) |
| return out |
|
|
|
|
| def _ok(ms: list, labels: dict) -> bool: |
| return all(fn(labels.get(n, "")) for n, fn in ms) |
|
|
|
|
| |
|
|
| def _rules(am: dict) -> list: |
| out = [] |
| for r in am.get("inhibit_rules") or []: |
| if not isinstance(r, dict): |
| raise Unsupported("inhibit rule is not a mapping") |
| src = _parse(r.get("source_matchers"), r.get("source_match"), r.get("source_match_re")) |
| tgt = _parse(r.get("target_matchers"), r.get("target_match"), r.get("target_match_re")) |
| eq = r.get("equal") or [] |
| if not isinstance(eq, list): |
| raise Unsupported("equal must be a list") |
| out.append((src, tgt, [str(e) for e in eq])) |
| return out |
|
|
|
|
| def inhibited(am: dict, alerts: list[dict]) -> list[bool] | None: |
| """For each alert (label dict), whether the others firing with it mute it. None if unsupported.""" |
| try: |
| rules = _rules(am) |
| except (Unsupported, AttributeError): |
| return None |
| out = [] |
| for t in alerts: |
| muted = False |
| for src, tgt, eq in rules: |
| if not _ok(tgt, t): |
| continue |
| two_sided = _ok(src, t) |
| for s in alerts: |
| if s is t or not _ok(src, s): |
| continue |
| if any(s.get(e, "") != t.get(e, "") for e in eq): |
| continue |
| if two_sided and _ok(tgt, s): |
| continue |
| muted = True |
| break |
| if muted: |
| break |
| out.append(muted) |
| return out |
|
|
|
|
| def delivered(am: dict, alerts: list[dict]) -> list[dict] | None: |
| mask = inhibited(am, alerts) |
| if mask is None: |
| return None |
| return [a for a, m in zip(alerts, mask) if not m] |
|
|
|
|
| |
|
|
| def walk(am: dict, labels: dict) -> list[tuple[str, object, str]] | None: |
| """[(receiver, group_by list or ALL, route path)] for the matching leaves; None if unsupported.""" |
| root = am.get("route") |
| if not isinstance(root, dict): |
| return None |
| try: |
| return _walk(root, labels, root.get("receiver"), root.get("group_by") or [], "0", True) |
| except (Unsupported, AttributeError, TypeError): |
| return None |
|
|
|
|
| def _walk(node: dict, labels: dict, recv, gb, path: str, is_root: bool) -> list | None: |
| if not is_root: |
| ms = _parse(node.get("matchers"), node.get("match"), node.get("match_re")) |
| if not _ok(ms, labels): |
| return None |
| recv = node.get("receiver") or recv |
| if node.get("group_by"): |
| gb = node["group_by"] |
| gb = ALL if ALL in (gb if isinstance(gb, list) else [gb]) else list(gb) |
| found: list = [] |
| for i, child in enumerate(node.get("routes") or []): |
| if not isinstance(child, dict): |
| raise Unsupported("route is not a mapping") |
| got = _walk(child, labels, recv, gb, f"{path}.{i}", False) |
| if got is not None: |
| found += got |
| if not child.get("continue"): |
| break |
| if not found: |
| found = [(str(recv), gb, path)] |
| return found |
|
|
|
|
| def group_key(gb, labels: dict) -> tuple: |
| if gb == ALL: |
| return tuple(sorted(labels.items())) |
| return tuple((k, labels.get(k, "")) for k in sorted(gb)) |
|
|
|
|
| def notifications(am: dict, am_path: str, am_text: str, snapshots: list[list[dict]]) -> set | None: |
| """Distinct (receiver, route path, group key, frozenset(services)) over snapshots; None if unsupported.""" |
| groups: dict[tuple, set] = {} |
| for alerts in snapshots: |
| live = delivered(am, alerts) |
| if live is None: |
| return None |
| for a in live: |
| leaves = walk(am, a) |
| want = resolve(am_path, am_text, a) |
| if leaves is None or want is None or sorted({r for r, _, _ in leaves}) != sorted(set(want)): |
| return None |
| for recv, gb, path in leaves: |
| key = (recv, path, group_key(gb, a)) |
| groups.setdefault(key, set()).add(a.get("service", "")) |
| return {(r, p, k, frozenset(s)) for (r, p, k), s in groups.items()} |
|
|
