"""What Prometheus scrapes in every hidden scenario: the background world under each card's own series. A scenario group used to hold `up` for every service and, beyond that, only the series its card needed, so a service whose pods were up and serving had no request counters at all. A floor rule written to survive missing series (`... or sum(up) * 0`, `absent(...)`, `unless`) read that as zero traffic and paged in every scenario where the pods were up (afx-e1-s03, T1). No Prometheus shows pods that are up without their series, so the scenarios are completed instead of the rules being bent. For every service with an `up` target in a group: - app series per target: request counters for the kinds that serve requests (`http_requests_total` by code and method, `grpc_server_handled_total` by code and method) and every other per-pod family the repo's rules read about the service (request-duration histograms, DB pool gauges, queue depth, ...). Traffic flows while a target is up; a target that goes down or leaves discovery gets stale markers on the same scrape (as Prometheus writes them), and the service's traffic moves to the targets still serving; - per-pod cAdvisor series (memory, CPU throttling) where the rules read them, for as long as the pod exists; - the exporter series a card adds to the world (`Item.exporters`: a replica's lag, a consumer group, a volume) and the per-target gauges in `w.notes["background_series"]`; - the ingress controller's request counters (`nginx_ingress_controller_requests`) for every HTTP service: the README says this Prometheus scrapes the apps and the ingress, so an error ratio read at the load balancer sees what the app's own counters saw (status = code, minute by minute), and while no target of the service is up, the 502s (targets down) or 503s (no targets left) the controller answers to the requests clients keep sending. A family the group already has for a service is left alone: the card's own series and their traffic win. Where a card's pods carry one family, the missing ones go on the same pods and agree with it (a request counter adds up to the histogram's count). Values are healthy (no rule in the repo fires on them) and come from their own random stream (task seed, resample, group name), so the scenario stream, the workspace and every series a card draws stay as they were. A group can declare a service it leaves without app series on purpose (`G.bare`); `lint` checks the rest. """ from __future__ import annotations import json import os import random import re from contextlib import contextmanager from ..promsim import STALE from . import xscen from .vocab import public_zone from .xscen import HIST_LES, Raw, dec, pod_name, rs_hash SERVES = {"api": "http", "worker": "http", "latency": "http", "grpc": "grpc"} # kinds that serve requests FAMILY = {"http_requests_total": "http", "grpc_server_handled_total": "grpc", "http_request_duration_seconds_bucket": "hist", "http_request_duration_seconds_count": "hist", "http_request_duration_seconds_sum": "hist", "db_pool_connections_active": "dbpool", "db_pool_connections_max": "dbpool", "db_client_connection_errors_total": "dbclient", "work_queue_depth": "queue", "export_last_success_timestamp_seconds": "export", "container_memory_working_set_bytes": "mem", "container_spec_memory_limit_bytes": "mem", "container_cpu_cfs_periods_total": "cpu", "container_cpu_cfs_throttled_periods_total": "cpu"} CADVISOR = {"mem", "cpu"} PER_SERIES = {"le", "code", "method", "handler", "grpc_code", "grpc_method", "grpc_service", "grpc_type", "container"} E_SHARE = 0.0002 # 5xx (or gRPC Unavailable) share of background traffic, far under every burn threshold NOT_FOUND = 0.03 # 4xx share, as the cards' own request counters carry # healthy request durations (cumulative share per house bucket): p99 about 0.2s, nothing near a latency objective LATENCY = {"0.05": 0.40, "0.1": 0.96, "0.25": 0.999, "0.5": 0.9999, "1.0": 1.0, "2.5": 1.0, "+Inf": 1.0} # a saturated service (exercise scenarios only): 40% of requests past the top finite bucket LATENCY_HOT = {"0.05": 0.05, "0.1": 0.10, "0.25": 0.20, "0.5": 0.30, "1.0": 0.40, "2.5": 0.60, "+Inf": 1.0} CPU_PERIODS = 600 # CFS periods per minute (100ms period), ~2% of them throttled SCRAPE_SEED = 0x5C2A INGRESS = "nginx_ingress_controller_requests" def _num(v) -> bool: return v is not None and v != STALE and not isinstance(v, bool) # ---------------------------------------------------------------------------- what the rules read _STR = re.compile(r'"(?:[^"\\]|\\.)*"') _SEL = re.compile(r"([a-zA-Z_:][a-zA-Z0-9_:]*)\s*\{([^{}]*)\}") _MATCHER = re.compile(r'([a-zA-Z_][a-zA-Z0-9_]*)\s*(=~|!=|!~|=)\s*"((?:[^"\\]|\\.)*)"') _IDENT = re.compile(r"(? list[tuple[str, list[tuple[str, str, str]]]]: """(metric, [(label, op, value)]) for every vector selector of a generated rule expression.""" out = [(m.group(1), _MATCHER.findall(m.group(2))) for m in _SEL.finditer(expr)] rest = _STR.sub(" ", _SEL.sub(" ", expr)) rest = _CLAUSE.sub(" ", re.sub(r"\[[^\]]*\]", " ", rest)) for m in _IDENT.finditer(rest): if m.group(0) not in _WORDS and not rest[m.end():].lstrip().startswith("("): out.append((m.group(0), [])) return out def _services(matchers, names) -> list[str] | None: hit = None for lab, op, val in matchers: if lab != "service" or op not in ("=", "=~"): continue ok = [n for n in names if (n == val if op == "=" else re.fullmatch(val, n))] hit = ok if hit is None else [n for n in hit if n in ok] return hit def reads(states, names: list[str]) -> dict[str, set[str]]: """service -> every metric a rule reads about it, in any of the given repo states (records followed: a burn alert on `slo:sli_error:ratio_rate1h{service="x"}` reads x's request counters).""" out: dict[str, set[str]] = {n: set() for n in names} for files in states: rules = [r for f in files.values() for g in f.groups for r in g["rules"]] rec: dict[str, list[str]] = {} for r in rules: if "record" in r: rec.setdefault(r["record"], []).append(str(r.get("expr", ""))) def walk(expr, outer, depth=0): for metric, ms in selectors(expr): svcs = _services(ms, names) svcs = outer if svcs is None else svcs if metric in rec and depth < 6: for e in rec[metric]: walk(e, svcs, depth + 1) else: for s in svcs: out[s].add(metric) for r in rules: lab = r.get("labels") if isinstance(r.get("labels"), dict) else {} walk(str(r.get("expr", "")), [lab["service"]] if lab.get("service") in out else []) return out # ---------------------------------------------------------------------------- the plan of a task's world class Plan: """Which series every service of a world exports, and the filler that puts them into a scenario group.""" def __init__(self, w, items, states, seed: str): self.w, self.seed = w, seed self.svcs = {s.name: s for s in w.services} rd = reads(states, list(self.svcs)) # the request family comes from the kind (one SLI record name is defined once per family, so the rules # alone would hand every service both); the other families from what the rules read about the service self.need = {n: ({SERVES[s.kind]} if s.kind in SERVES else set()) | {FAMILY[m] for m in rd[n] if FAMILY.get(m) not in (None, "http", "grpc")} for n, s in self.svcs.items()} self.templates = [dict(t) for it in items for t in it.exporters(w)] for e in w.notes.get("background_series", []): if e.get("service") in self.svcs: # a per-target gauge (H10): scraped while its service's targets are self.templates.append({"service": e["service"], "metric": e["metric"], "labels": dict(e["labels"]), "key": ("service",), "values": ("const", e["value"]), "follow": True}) covered = {t["metric"] for t in self.templates} | set(FAMILY) | {"up", INGRESS} self.uncovered = {n: sorted(m for m in rd[n] if m not in covered and not m.startswith("ALERTS")) for n in self.svcs} # the ingress controller in front of the HTTP services: its own random stream, drawn once per task crng = random.Random(f"{w.tseed}|ingress-nginx") self.ingress = {"job": "ingress-nginx", "controller_class": "k8s.io/ingress-nginx", "controller_namespace": "ingress-nginx", "controller_pod": pod_name(crng, "ingress-nginx-controller", rs_hash(crng)), "instance": f"10.{crng.randint(16, 31)}.0.{crng.randint(2, 99)}:10254"} self.zone = public_zone(w.domain) def rate(self, s) -> float: """Requests per second: the service's own, at least five times a catalog floor.""" return max(float(s.rps), 5 * float(s.floor)) if s.floor else float(s.rps) def saturate(self, svc, targets, n, rng) -> list[Raw]: """The service's own per-pod families past every threshold its rules hold (slow requests, a full pool, memory at the limit, a backlog, a late export, throttling): exercise scenarios only, so that an untouched alert on them fires somewhere and a rewrite of it can be replayed. Its request counters stay healthy.""" fams = sorted(self.need[svc] - {"http", "grpc"}) if not fams: return [] lanes = _lanes_from_targets(self.w, svc, targets, n, rng) _traffic(lanes, self.rate(self.svcs[svc]), n, rng) lim, pool = rng.choice([2, 4, 6]) * 1024 ** 3, rng.choice([20, 30, 50]) return [r for lane in lanes for fam in fams for r in GEN[fam](lane, n, rng, svc=svc, ns=self.w.namespace, limit=lim, pool=pool, hot=True)] # ------------------------------------------------------------------ filler def complete(self, g) -> None: n, bare = g.minutes, g.extra.get("bare", {}) ups: dict[str, list[Raw]] = {} for r in g.series: svc = r.labels.get("service") if r.metric == "up" and svc in self.svcs and r.labels.get("job") == svc: ups.setdefault(svc, []).append(r) add: list[Raw] = [] for svc in [s for s in self.svcs if s in ups]: rng = random.Random(f"{self.seed}|{g.name}|{svc}") have = {FAMILY[r.metric] for r in g.series if r.labels.get("service") == svc and r.metric in FAMILY} missing = sorted(self.need[svc] - have - set(bare.get(svc, []))) if missing: add += self._app(svc, ups[svc], g.series, missing, n, rng) add += self._exporters(svc, ups[svc], g.series, n, rng) g.series += add g.series += self._ingress(g.name, ups, g.series, n) def _app(self, svc, targets, series, fams, n, rng) -> list[Raw]: s = self.svcs[svc] pods: dict[str, list[Raw]] = {} for r in series: lab = r.labels if (lab.get("service") == svc and "pod" in lab and "instance" in lab and r.metric != "up" and not r.metric.startswith("container_") and lab.get("job", svc) == svc): pods.setdefault(lab["pod"], []).append(r) lanes = _lanes_from_pods(pods, n, rng) if pods else _lanes_from_targets(self.w, svc, targets, n, rng) _traffic(lanes, self.rate(s), n, rng) lim = rng.choice([2, 4, 6]) * 1024 ** 3 pool = rng.choice([20, 30, 50]) out: list[Raw] = [] for lane in lanes: for fam in fams: out += GEN[fam](lane, n, rng, svc=svc, ns=self.w.namespace, limit=lim, pool=pool) return out def _exporters(self, svc, targets, series, n, rng) -> list[Raw]: out = [] alive = [any(t.values[m] == 1 for t in targets) for m in range(n + 1)] gone = [any(t.values[m] in (0, STALE) for t in targets) for m in range(n + 1)] for t in self.templates: if t["service"] != svc: continue key = {k: t["labels"][k] for k in t["key"]} if any(r.metric == t["metric"] and all(r.labels.get(k) == v for k, v in key.items()) for r in series): continue vals = _values(t["values"], n, rng) if t.get("follow"): vals = _shape(vals, alive, gone) out.append(Raw(t["metric"], dict(t["labels"]), vals)) return out def _ingress(self, gname, ups, series, n) -> list[Raw]: """nginx_ingress_controller_requests for every HTTP service with targets in the group. While a target serves, the controller counts what the app's own counters count (status = code, method = method); in a minute with no app sample and no target up, clients still call and the controller answers them itself: 502 while targets exist but are down, 503 once none is left, at the rate the service had before.""" out: list[Raw] = [] for svc in [s for s in self.svcs if s in ups and SERVES.get(self.svcs[s].kind) == "http"]: app = [r for r in series if r.metric == "http_requests_total" and r.labels.get("service") == svc and r.labels.get("job", svc) == svc] if not app: continue rng = random.Random(f"{self.seed}|{gname}|{svc}|ingress") inc: dict[tuple[str, str], list[float]] = {} served = [False] * (n + 1) for r in app: acc = inc.setdefault((str(r.labels.get("code", "")), str(r.labels.get("method", "GET"))), [0] * (n + 1)) for m in range(n + 1): served[m] = served[m] or _num(r.values[m]) if m and _num(r.values[m - 1]) and _num(r.values[m]): a, b = r.values[m - 1], r.values[m] acc[m] += b - a if b >= a else b total = [sum(v[m] for v in inc.values()) for m in range(n + 1)] before, nominal = [], self.rate(self.svcs[svc]) * 60 for m in range(1, n + 1): if served[m] or any(t.values[m] == 1 for t in ups[svc]): if served[m] and served[m - 1]: before = (before + [total[m]])[-5:] continue status = "502" if any(t.values[m] == 0 for t in ups[svc]) else "503" want = (sum(before) / len(before) if before else nominal) * rng.uniform(0.95, 1.05) inc.setdefault((status, "GET"), [0] * (n + 1))[m] += want base = {**self.ingress, "ingress": svc, "namespace": self.w.namespace, "service": svc, "host": f"{svc}.{self.zone}", "path": "/"} for (code, method), xs in sorted(inc.items()): vals, v, carry, seen = [], None, 0.0, code in ("200", "404", "500") for m, x in enumerate(xs): k = int(x + carry) carry = x + carry - k if v is None and (seen or k): v = (rng.randint(10 ** 5, 10 ** 6) if code == "200" else rng.randint(200, 4000) if seen else 0) if v is not None: v += k if m else 0 vals.append(v) out.append(Raw(INGRESS, {**base, "method": method, "status": code}, vals)) return out # ---------------------------------------------------------------------------- lanes: one pod each def _lanes_from_targets(w, svc, targets, n, rng) -> list[dict]: """One pod per `up` target, in target order (unify_targets pairs the k-th pod with the k-th target). A target serves while it is up; a gap in discovery inside its life (an SD flap) does not stop the pod from serving.""" rs = rs_hash(rng) lanes = [] for t in targets: up = t.values scraped = [up[m] == 1 for m in range(n + 1)] on = [m for m in range(n + 1) if scraped[m]] lo, hi = (on[0], on[-1]) if on else (n + 1, -1) serving = [scraped[m] or (lo <= m <= hi and up[m] != 0) for m in range(n + 1)] exists = [up[m] in (0, 1) or (lo <= m <= hi) for m in range(n + 1)] lanes.append({"labels": {"service": svc, "namespace": w.namespace, "pod": pod_name(rng, svc, rs), "instance": t.labels.get("instance", ""), "job": svc}, "scraped": scraped, "stale": [up[m] in (0, STALE) for m in range(n + 1)], "serving": serving, "exists": exists, "fresh": lo > 0, "inc": None}) return lanes def _lanes_from_pods(pods: dict, n, rng) -> list[dict]: """The card's own pods: same labels, sampled when the card's series are, traffic read off their counters.""" lanes = [] for pod, rs in pods.items(): common = dict(rs[0].labels) for r in rs[1:]: common = {k: v for k, v in common.items() if r.labels.get(k) == v} base = {k: v for k, v in common.items() if k not in PER_SERIES} scraped = [any(_num(r.values[m]) for r in rs) for m in range(n + 1)] stale = [not scraped[m] and any(r.values[m] == STALE for r in rs) for m in range(n + 1)] src = ([r for r in rs if r.metric in ("http_requests_total", "grpc_server_handled_total")] or [r for r in rs if r.metric == "http_request_duration_seconds_count"]) inc = None if src: inc = [0] * (n + 1) for r in src: for m in range(1, n + 1): a, b = r.values[m - 1], r.values[m] if _num(a) and _num(b): inc[m] += b - a if b >= a else b on = [m for m in range(n + 1) if scraped[m]] lanes.append({"labels": base, "scraped": scraped, "stale": stale, "serving": scraped, "exists": scraped, "fresh": bool(on) and on[0] > 0, "inc": inc}) return lanes def _traffic(lanes, rps, n, rng) -> None: """Integer requests per minute per lane: the service's rate split over the lanes serving that minute (lanes whose counters the card drew keep their own counts).""" wts = [rng.uniform(0.8, 1.2) for _ in lanes] tot = [rps * 60 * rng.uniform(0.95, 1.05) for _ in range(n + 1)] carry = [0.0] * len(lanes) for k, lane in enumerate(lanes): if lane["inc"] is None: lane["inc"] = [0] * (n + 1) lane["own"] = False else: lane["own"] = True for m in range(1, n + 1): live = [k for k, lane in enumerate(lanes) if not lane["own"] and lane["serving"][m]] ws = sum(wts[k] for k in live) for k in live: x = tot[m] * wts[k] / ws + carry[k] lanes[k]["inc"][m] = int(x) carry[k] = x - int(x) def _shape(vals: list, scraped: list, stale: list) -> list: """A lane's values where it was scraped, a stale marker on the scrape its target went away, nothing else.""" out, prev = [], False for m, v in enumerate(vals): if scraped[m]: out.append(v) elif prev and stale[m]: out.append(STALE) else: out.append(None) prev = scraped[m] return out def _counter(start: int, incs: list[int]) -> list[int]: out, v = [], start for m, x in enumerate(incs): v += x if m else 0 out.append(v) return out def _split(incs: list[int], shares: list[float]) -> list[list[int]]: """Each minute's count split exactly: every code but the first takes its share with a carry (never negative, so every code's counter only grows), the first code takes the rest.""" parts = [[0] * len(incs) for _ in shares] carry = [0.0] * len(shares) for m, t in enumerate(incs): left = t for j in range(1, len(shares)): x = t * shares[j] + carry[j] got = min(int(x), left) carry[j] = x - got parts[j][m] = got left -= got parts[0][m] = left return parts def _counters(lane, metric, codes: list[tuple[dict, float, tuple[int, int]]], rng) -> list[Raw]: parts = _split(lane["inc"], [sh for _, sh, _ in codes]) out = [] for (lab, _, (lo, hi)), incs in zip(codes, parts): start = 0 if lane["fresh"] else rng.randint(lo, hi) out.append(Raw(metric, {**lane["labels"], **lab}, _shape(_counter(start, incs), lane["scraped"], lane["stale"]))) return out # ---------------------------------------------------------------------------- generators per family def _http(lane, n, rng, **_): ok = (1 - E_SHARE) * (1 - NOT_FOUND) return _counters(lane, "http_requests_total", [({"code": "200", "method": "GET"}, ok, (10 ** 4, 10 ** 6)), ({"code": "404", "method": "GET"}, (1 - E_SHARE) * NOT_FOUND, (200, 900)), ({"code": "500", "method": "GET"}, E_SHARE, (50, 900))], rng) def _grpc(lane, n, rng, **_): ok = (1 - E_SHARE) * (1 - NOT_FOUND) return _counters(lane, "grpc_server_handled_total", [({"grpc_code": "OK", "grpc_method": "Get"}, ok, (10 ** 4, 10 ** 6)), ({"grpc_code": "NotFound", "grpc_method": "Get"}, (1 - E_SHARE) * NOT_FOUND, (200, 900)), ({"grpc_code": "Unavailable", "grpc_method": "Get"}, E_SHARE, (50, 900))], rng) def _hist(lane, n, rng, hot=False, **_): """Buckets as floor(requests so far x cumulative share): every bucket only grows, never holds more than the next one up, and `+Inf` (and `_count`) is exactly the requests the lane's counters saw.""" shares = LATENCY_HOT if hot else LATENCY total, acc = [], 0 for m, x in enumerate(lane["inc"]): acc += x if m else 0 total.append(acc) off = 0 if lane["fresh"] else rng.randint(10 ** 4, 10 ** 5) out = [] for le in HIST_LES: vals = [off + (t if le == "+Inf" else int(t * shares[le])) for t in total] out.append(Raw("http_request_duration_seconds_bucket", {**lane["labels"], "le": le}, _shape(vals, lane["scraped"], lane["stale"]))) off += 0 if lane["fresh"] else rng.randint(0, 40) out.append(Raw("http_request_duration_seconds_count", dict(lane["labels"]), list(out[-1].values))) return out def _gauge(lane, metric, vals): return Raw(metric, dict(lane["labels"]), _shape(vals, lane["scraped"], lane["stale"])) def _dbpool(lane, n, rng, pool=30, hot=False, **_): act = [pool if hot else rng.randint(2, max(3, pool // 4)) for _ in range(n + 1)] return [_gauge(lane, "db_pool_connections_active", act), _gauge(lane, "db_pool_connections_max", [pool] * (n + 1))] def _dbclient(lane, n, rng, hot=False, **_): start = rng.randint(0, 40) return [_gauge(lane, "db_client_connection_errors_total", [start + (120 * m if hot else 0) for m in range(n + 1)])] def _queue(lane, n, rng, hot=False, **_): return [_gauge(lane, "work_queue_depth", [rng.randint(20, 400) + (9000 if hot else 0) for _ in range(n + 1)])] def _export(lane, n, rng, hot=False, **_): every = rng.choice([15, 20, 30]) # the last export finished on the job's schedule (four hours ago when hot) vals = [-4 * 3600] * (n + 1) if hot else [60 * (m - m % every) for m in range(n + 1)] return [_gauge(lane, "export_last_success_timestamp_seconds", vals)] def _cadvisor(lane, svc, ns): pod = lane["labels"].get("pod") or f"{svc}-0" return {"service": svc, "container": svc, "namespace": ns, "pod": pod} def _mem(lane, n, rng, svc="", ns="", limit=2 * 1024 ** 3, hot=False, **_): lab, base = _cadvisor(lane, svc, ns), rng.uniform(0.45, 0.65) base = 0.97 if hot else base ws = [int(limit * base * (1 + rng.uniform(-0.002, 0.002))) for _ in range(n + 1)] ex = lane["exists"] gone = [not ex[m] for m in range(n + 1)] return [Raw("container_memory_working_set_bytes", lab, _shape(ws, ex, gone)), Raw("container_spec_memory_limit_bytes", dict(lab), _shape([limit] * (n + 1), ex, gone))] def _cpu(lane, n, rng, svc="", ns="", hot=False, **_): lab = _cadvisor(lane, svc, ns) per = [0] + [CPU_PERIODS + rng.randint(-5, 5) for _ in range(n)] thr = [0] + [rng.randint(5, 18) + (360 if hot else 0) for _ in range(n)] ex = lane["exists"] gone = [not ex[m] for m in range(n + 1)] start = rng.randint(10 ** 5, 10 ** 6) return [Raw("container_cpu_cfs_periods_total", lab, _shape(_counter(start, per), ex, gone)), Raw("container_cpu_cfs_throttled_periods_total", dict(lab), _shape(_counter(start // 50, thr), ex, gone))] GEN = {"http": _http, "grpc": _grpc, "hist": _hist, "dbpool": _dbpool, "dbclient": _dbclient, "queue": _queue, "export": _export, "mem": _mem, "cpu": _cpu} def _values(spec, n, rng) -> list: kind = spec[0] if kind == "const": return [spec[1]] * (n + 1) if kind == "ints": return [rng.randint(spec[1], spec[2]) for _ in range(n + 1)] if kind == "counter": # (counter, low, high): per-second rate drawn once, a minute's increase around it r = rng.uniform(spec[1], spec[2]) return _counter(rng.randint(10 ** 6, 10 ** 7), [0] + [int(r * 60 * rng.uniform(0.9, 1.1)) for _ in range(n)]) raise ValueError(spec) @contextmanager def active(plan: Plan): """Complete every scenario group drawn inside the block (xscen.G.done calls the plan).""" prev = xscen.SCRAPE xscen.SCRAPE = plan.complete try: yield plan finally: xscen.SCRAPE = prev