File size: 5,236 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 | """Gate lint for the scraped world of a built task (scraped.py): every hidden group, the preservation replay's
exercise groups included, has to look like something a Prometheus scraped.
1. completeness: a service with an `up` target at 1 has every series family it exports in this world (request
counters for the kinds that serve requests, the per-pod families its rules read, its exporters), unless the
group declares the gap (`bare`);
2. coverage: at every minute one of its targets is up, some request counter of the service has a sample (a card's
own traffic can't stop short of its targets' lifetime);
3. consistency: an app series is only sampled while the target it was scraped from is up (a target that is down or
gone has stale or no series, as Prometheus writes them);
4. reach: no rule in the repo reads a metric about a service that no scenario carries;
5. ingress: the README says this Prometheus scrapes the ingress, so every HTTP service with a target up has the
controller's request counters (`nginx_ingress_controller_requests`).
"""
from __future__ import annotations
import json
import os
import re
from ..promsim import STALE
from .scraped import FAMILY, INGRESS, SERVES
from .xscen import dec
_LAB = re.compile(r'([a-zA-Z_][a-zA-Z0-9_]*)="((?:[^"\\]|\\.)*)"')
MAX_REPORTS = 12
def _parse(g: dict) -> list[tuple[str, dict, list]]:
out = []
for s in g["input_series"]:
name, inner = s["series"].split("{", 1)
out.append((name, dict(_LAB.findall(inner)), dec(s["values"])))
return out
def _num(v) -> bool:
return v is not None and v != STALE
def check_groups(plan, groups: list[dict]) -> list[str]:
bad: list[str] = []
for g in groups:
series = _parse(g)
bare = g.get("bare", {})
ups: dict[str, list[tuple[dict, list]]] = {}
fams: dict[str, set] = {}
for name, lab, vals in series:
svc = lab.get("service")
if name == "up" and svc in plan.svcs and lab.get("job") == svc:
ups.setdefault(svc, []).append((lab, vals))
if svc and name in FAMILY:
fams.setdefault(svc, set()).add(FAMILY[name])
for svc, targets in ups.items():
n = max(len(v) for _, v in targets)
live = [m for m in range(n) if any(m < len(v) and v[m] == 1 for _, v in targets)]
if not live:
continue
skip = set(bare.get(svc, []))
for fam in sorted(plan.need[svc] - fams.get(svc, set()) - skip):
bad.append(f"{g['name']}: {svc} has targets up and no {fam} series")
for t in plan.templates:
if t["service"] == svc and not any(
name == t["metric"] and all(lab.get(k) == t["labels"][k] for k in t["key"])
for name, lab, _ in series):
bad.append(f"{g['name']}: {svc} has targets up and no {t['metric']}")
req = SERVES.get(plan.svcs[svc].kind)
if req and req not in skip:
rs = [v for name, lab, v in series if lab.get("service") == svc and FAMILY.get(name) == req]
gap = next((m for m in live if not any(m < len(v) and _num(v[m]) for v in rs)), None)
if gap is not None:
bad.append(f"{g['name']}: {svc} has a target up at minute {gap} and no request series sample")
if req == "http" and req not in skip and not any(name == INGRESS and lab.get("service") == svc
for name, lab, _ in series):
bad.append(f"{g['name']}: {svc} has targets up and no ingress series")
by_target = {(lab.get("service"), lab.get("instance"), lab.get("pod")): vals
for name, lab, vals in series if name == "up" and lab.get("pod")}
for name, lab, vals in series:
if name == "up" or name.startswith("container_") or not lab.get("pod"):
continue
up = by_target.get((lab.get("service"), lab.get("instance"), lab.get("pod")))
if up is None or lab.get("job", lab.get("service")) != lab.get("service"):
continue
m = next((m for m, v in enumerate(vals) if _num(v) and not (m < len(up) and up[m] == 1)), None)
if m is not None:
bad.append(f"{g['name']}: {name}{{pod={lab['pod']}}} sampled at minute {m} while its target is not up")
return bad
def lint(m: dict) -> list[str]:
"""The checks above on a built task (build_task's result), exercise groups included."""
plan = m.get("scrape")
if plan is None:
return []
groups = list(m["groups"])
ex = os.path.join(m["hidden_dir"], "exercise.json")
if os.path.exists(ex):
with open(ex) as fh:
groups += json.load(fh)
bad = check_groups(plan, groups)
for svc, metrics in sorted(plan.uncovered.items()):
for metric in metrics:
bad.append(f"rules read {metric} about {svc}, which no scenario carries")
if len(bad) > MAX_REPORTS:
bad = bad[:MAX_REPORTS] + [f"... {len(bad) - MAX_REPORTS} more scraped-world findings"]
return [f"scraped world: {b}" for b in bad]
|