File size: 8,919 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 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 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 | """Gate lints that read a built task the way a careful on-call engineer would and fail on contradictions between
its packets, its text and the repo it ships (R4, R6, FA-4, BM-6, S7). Text only, no promtool.
- paged team: a page in a PagerDuty export or Slack channel names the team its alert carries in the starting repo
- alert exists: every alert a packet shows paging exists in the starting repo (or is the cluster-level alert)
- anachronism: a packet dated before the split never says the new team was (or wasn't) paged
- rule dumps: a rule-manager log or rules API paste shows the starting repo's labels for that rule
- deploy tags: a release tag is never dated after its deploy
- deploy hours: rollouts start in office hours on working days (one evening hotfix per log allowed)
- numbering: INC and PagerDuty numbers grow with time across the task
- recency: "this week" points at packets from this week
"""
from __future__ import annotations
import csv
import datetime as dt
import io
import re
TITLE = re.compile(r"\[(?:FIRING:\d+|RESOLVED)\] ([A-Z][A-Za-z0-9]+)(?: ([a-z][\w.-]*))?(?: \(([^)]*)\))?")
TAG = re.compile(r"^(\d{4}-\d\d-\d\d)T(\d\d):(\d\d):\d\d[+-]\d\d:\d\d rollouts \S+ v(\d{4})\.(\d\d)\.(\d\d)-\d+ (.*)$")
def _pristine_labels(m: dict) -> dict[str, list[dict]]:
from .then import state
files, _ = state(m["world"])
out: dict[str, list[dict]] = {}
for f in files.values():
for g in f.groups:
for r in g["rules"]:
if "alert" in r:
out.setdefault(r["alert"], []).append({**(g.get("labels") or {}), **(r.get("labels") or {})})
return out
def _titles(path: str, text: str):
"""(title, pagerduty service or None, created_on or None) from an export or a channel dump."""
if path.endswith(".csv") and text.startswith("incident_number"):
for row in csv.DictReader(io.StringIO(text)):
yield row["title"], row["service_name"].split(" ")[0], row["created_on"]
elif path.endswith(".txt"):
for line in text.splitlines():
yield line, None, None
def paged_team_lint(m: dict) -> list[str]:
w, ws = m["world"], m["static"]
labels = _pristine_labels(m)
cluster = set(w.cluster_level)
out = []
for path, text in ws.items():
if not path.startswith("incidents/"):
continue
for title, _pd, _ in _titles(path, text):
mm = TITLE.search(title)
if not mm:
continue
alert, _svc, rest = mm.groups()
if alert not in labels:
if alert not in cluster:
out.append(f"{path}: {alert} pages in the packet but the starting repo has no such alert")
continue
teams = {str(lab.get("team")) for lab in labels[alert] if lab.get("team")}
vals = (rest or "").split()
if teams and vals and vals[-1] not in teams:
out.append(f"{path}: {alert} shown with team {vals[-1]!r}, the starting repo labels it {sorted(teams)}")
return out
def rule_dump_lint(m: dict) -> list[str]:
labels = _pristine_labels(m)
out = []
for path, text in m["static"].items():
if path.endswith("prometheus.log"):
for mm in re.finditer(r"name=(\w+) index=\d+ rule=\"(.*?)\" err=", text):
team = re.search(r"\\n team: ([\w-]+)", mm.group(2))
want = {str(x.get("team")) for x in labels.get(mm.group(1), [])}
if team and want and team.group(1) not in want:
out.append(f"{path}: log shows team {team.group(1)} on {mm.group(1)}, the repo has {sorted(want)}")
elif path.endswith("rules-api.json"):
import json
for g in json.loads(text)["data"]["groups"]:
for r in g["rules"]:
want = {str(x.get("team")) for x in labels.get(r["name"], [])}
if want and r["labels"].get("team") not in want:
out.append(f"{path}: rules API shows team {r['labels'].get('team')} on {r['name']}")
return out
EVENT_FILES = ("timeline.md", "postmortem.md", "prometheus.log", "rules-api.json", "alerts-explore.csv", "deploys.log",
"slack-alerts.txt", "app.log")
def _packet_days(ws: dict, inc: str) -> list[dt.date]:
"""The days an incident happened on: what its own event files say (a PagerDuty export also has the pages of the
days around it, and an E3 channel export two weeks of history, so those only count when nothing else does)."""
own, rest = set(), set()
for path, text in ws.items():
if path.startswith(f"incidents/{inc}/"):
days = {dt.date.fromisoformat(d) for d in re.findall(r"(20\d\d-\d\d-\d\d)", text[:40000])}
(own if path.rsplit("/", 1)[-1] in EVENT_FILES else rest).update(days)
return sorted(own) if own else sorted(rest)[-1:]
def anachronism_lint(m: dict) -> list[str]:
w, ws = m["world"], m["static"]
tr = w.trigger or {}
if not tr.get("moved"):
return []
new, day = tr["new"], tr.get("day")
out = []
pat = re.compile(rf"\b{re.escape(new)}( rota)? (were|wasn't|was|weren't|never|on-call)\b|paged {re.escape(new)}\b"
rf"|\(page {re.escape(new)}\)|page {re.escape(new)}\)")
for inc in sorted({p.split("/")[1] for p in ws if p.startswith("incidents/")}):
days = _packet_days(ws, inc)
if not days or day is None or min(days) >= day:
continue
for path, text in ws.items():
if path.startswith(f"incidents/{inc}/") and (path.endswith(".md") or path.endswith(".txt") or path.endswith(".csv")):
hit = pat.search(text)
if hit:
out.append(f"{path}: dated {min(days)} (before the split on {day}) but says {hit.group(0)!r}")
return out
def deploy_lint(m: dict) -> list[str]:
out = []
for path, text in m["static"].items():
if not path.endswith("deploys.log"):
continue
evening = 0
for line in text.splitlines():
mm = TAG.match(line)
if not mm:
continue
day = dt.date.fromisoformat(mm.group(1))
tag = dt.date(int(mm.group(4)), int(mm.group(5)), int(mm.group(6)))
if tag > day:
out.append(f"{path}: release {tag} rolled out on {day}")
if "started" in mm.group(7):
h = int(mm.group(2))
if day.weekday() >= 5 or h < 8:
out.append(f"{path}: rollout started {day:%a} {mm.group(2)}:{mm.group(3)}")
elif h >= 19:
evening += 1
if evening > 1:
out.append(f"{path}: {evening} rollouts started in the evening")
return out
def numbering_lint(m: dict) -> list[str]:
ws = m["static"]
out = []
incs = []
for inc in sorted({p.split("/")[1] for p in ws if p.startswith("incidents/INC-")}):
days = _packet_days(ws, inc)
if days: # an INC is opened once the thing is noticed: the last day of a packet that spans several
incs.append((int(inc[4:]), days[-1], inc))
incs.sort()
for (a, da, ia), (b, db, ib) in zip(incs, incs[1:]):
if db < da - dt.timedelta(days=1):
out.append(f"{ib} ({db}) is numbered after {ia} ({da})")
firsts = []
for path, text in ws.items():
if path.endswith(".csv") and text.startswith("incident_number"):
rows = list(csv.DictReader(io.StringIO(text)))
nums = [int(r["incident_number"]) for r in rows]
if nums != sorted(nums) or len(set(nums)) != len(nums):
out.append(f"{path}: incident numbers not increasing")
if rows:
firsts.append((int(rows[0]["incident_number"]), rows[0]["created_on"], path))
firsts.sort()
for (a, ca, pa), (b, cb, pb) in zip(firsts, firsts[1:]):
if cb < ca and dt.datetime.fromisoformat(ca[:-1]) - dt.datetime.fromisoformat(cb[:-1]) > dt.timedelta(days=1):
out.append(f"{pb}: #{b} created {cb} but numbered above #{a} ({ca}, {pa})")
return out
def recency_lint(m: dict) -> list[str]:
w = m["world"]
today = w.cal.today
monday = today - dt.timedelta(days=today.weekday())
out = []
for t in m["tickets"].values():
if "this week" not in t.body:
continue
for inc in set(re.findall(r"incidents/([\w-]+)/", t.body)):
days = _packet_days(m["static"], inc)
if days and min(days) < monday - dt.timedelta(days=1):
out.append(f"{t.key} says 'this week' about {inc}, dated {min(days)} (week starts {monday})")
return out
def lint(m: dict) -> list[str]:
return (paged_team_lint(m) + rule_dump_lint(m) + anachronism_lint(m) + deploy_lint(m) + numbering_lint(m)
+ recency_lint(m))
|