| """The repo README (house rules), in the words of whoever wrote it at each company (R2, editorial pass E8). |
| |
| Every paragraph has three wordings and every wording states the same rules: the severity table, the alert |
| classes, Down semantics, SLO names, the routing table, the inhibition rules, the `runbook_url` pattern, the group |
| and `ALERTS` rules. Each wording is used by a third of the tasks of a build (`variety.house`), the section order |
| and headings vary, and every README ends with what this particular repo does differently. |
| """ |
|
|
| from __future__ import annotations |
|
|
| from . import knobs, variety |
|
|
|
|
| def _pick(w, key: str, opts: list[str]) -> str: |
| return variety.house(w, f"readme:{key}", opts) |
|
|
|
|
| def intro(w, f) -> str: |
| c = w.company |
| return _pick(w, "intro", [ |
| f"Prometheus rules and the shared Alertmanager config for {c.name}. The observability team owns this repo. " |
| f"Service teams file `{c.key}-` tickets against it and review changes to their own rules. Alertmanager is " |
| f"shared with the platform and data Prometheus servers, so most team subtrees route alerts that don't come " |
| f"from here.", |
| f"This is where {c.name}'s alerting lives: the rules our Prometheus evaluates and the Alertmanager config every " |
| f"Prometheus in the company sends to. Observability owns it; teams ask for changes with `{c.key}-` tickets and " |
| f"review whatever touches their own rules. The platform and data Prometheus servers use the same " |
| f"Alertmanager, which is why many team subtrees route alerts this repo never fires.", |
| f"Alerting rules and routing for {c.name}, maintained by observability. If you own a service, open a " |
| f"`{c.key}-` ticket for changes and expect to review the ones to your rules. One Alertmanager serves this " |
| f"Prometheus as well as the platform and data ones, so plenty of the routing below is for alerts defined " |
| f"elsewhere."]) |
|
|
|
|
| def layout(w, f) -> str: |
| ops = _pick(w, "layout-ops", [ |
| "PagerDuty exports and postmortems are the authoritative times; Slack threads are local time and can be a minute off.", |
| "times: PagerDuty and postmortems win; Slack is local time and sometimes a minute out", |
| "PagerDuty and postmortem times are the ones to trust; Slack exports are in local time, give or take a minute"]) |
| rows = _pick(w, "layout-rows", [ |
| f"""| what | where | authoritative for | |
| |---|---|---| |
| | alerting and recording rules | `rules/` | | |
| | routing, receivers, inhibition | `alertmanager/alertmanager.yml` | | |
| | SLO catalog | `slo/services.yaml` | targets, SLO windows, SLI families, traffic floors | |
| | who owns what | `teams/ownership.yaml` | team of every service (wins over anything a runbook says) | |
| | policies | `docs/adr/` | burn-rate policy, scrape intervals, disk alerts | |
| | runbooks | `runbooks/*.md` | what an alert is for and how fast it has to page | |
| | incident packets | `incidents/` | {ops} | |
| | smoke tests | `tests/visible/` | just the smoke suite, not a spec |""", |
| f"""| path | contents | source of truth for | |
| |---|---|---| |
| | `rules/` | every alerting and recording rule | | |
| | `alertmanager/alertmanager.yml` | routes, receivers, inhibitions | | |
| | `slo/services.yaml` | the SLO catalog | SLO targets and windows, SLI family per service, traffic floors | |
| | `teams/ownership.yaml` | owners | which team owns each service; beats any runbook | |
| | `docs/adr/` | decisions | burn-rate policy, scrape intervals, disk alerts | |
| | `runbooks/*.md` | one page per alert or service | what the alert means, how quickly it must page | |
| | `incidents/` | packets from past incidents | {ops} | |
| | `tests/visible/` | the smoke suite | nothing; it is not a spec |""", |
| f"""- `rules/`: alerting and recording rules. |
| - `alertmanager/alertmanager.yml`: routing tree, receivers, inhibition rules. |
| - `slo/services.yaml`: the SLO catalog, the one place for targets, SLO windows, SLI families and traffic floors. |
| - `teams/ownership.yaml`: the team that owns each service. If a runbook disagrees, this file is right. |
| - `docs/adr/`: decisions (burn-rate policy, scrape intervals, disk alerts). |
| - `runbooks/*.md`: what each alert is for and how fast it has to page. |
| - `incidents/`: packets from past incidents ({ops}). |
| - `tests/visible/`: a smoke suite. Not a spec."""]) |
| tools = _pick(w, "layout-tools", [ |
| "`bin/af-check` is CI (promtool check, the smoke tests, amtool check-config). `bin/range2test` turns a " |
| "`query_range` pull from an incident packet into a promtool test so you can replay it against a branch.", |
| "CI is `bin/af-check`: promtool check, the smoke tests, amtool check-config. To replay an incident against a " |
| "branch, feed one of the packet's `query_range` pulls to `bin/range2test` and run the promtool test it writes.", |
| "Two scripts: `bin/af-check` (what CI runs: promtool check, smoke tests, amtool check-config) and " |
| "`bin/range2test`, which makes a promtool test out of a `query_range` pull from `incidents/`, for replaying an " |
| "incident against your change."]) |
| return f"{rows}\n\n{tools}" |
|
|
|
|
| def house(w, f) -> str: |
| return _pick(w, "house", [ |
| "Older files predate the conventions below; don't reformat them in passing. All groups run at the global " |
| "evaluation interval (1m); we don't use `interval:`, `query_offset:` or `limit:` on groups. Rules don't read " |
| "`ALERTS` or `ALERTS_FOR_STATE` (an alert keeping its own firing series up is the one exception we allow): when " |
| "one alert should hold another back, that's an inhibition rule in Alertmanager, where on-call can see it.\n" |
| "The deploy job refuses a repo with symlinks in it, anywhere, so there are none: copy a file instead of " |
| "linking it.", |
| "Some files are older than the conventions here. Leave their formatting alone unless you are changing them " |
| "for a reason. Every group runs at the global evaluation interval of 1m: no `interval:`, `query_offset:` or " |
| "`limit:` on a group. No rule reads `ALERTS` or `ALERTS_FOR_STATE`, except an alert that keeps its own firing " |
| "series up. If one alert should silence another, write an inhibition rule in Alertmanager so on-call can see " |
| "it.\nNo symlinks anywhere in the repo: the deploy job rejects them. Copy the file instead.", |
| "A word on old files: they predate the rules below, and we don't reformat them in drive-by changes. Groups " |
| "all evaluate at the global interval (1m); `interval:`, `query_offset:` and `limit:` aren't used on groups " |
| "here. Reading `ALERTS` or `ALERTS_FOR_STATE` from a rule is off limits; the only allowed case is an alert " |
| "holding up its own firing series. Holding one alert back while another fires is Alertmanager's job " |
| "(inhibition), visible to on-call.\nThe deploy job fails on any symlink in the repo, so copy files rather " |
| "than linking them."]) |
|
|
|
|
| def sees(w, f) -> str: |
| adr = f["scrape"] |
| return _pick(w, "sees", [ |
| "This Prometheus scrapes our apps and the ingress. Every app target gets a `service` label from its Kubernetes " |
| "Service name and a `pod` label at relabel time, so `up{service=\"…\"}` is how you find a service's targets. " |
| "kube-state-metrics and the kubelet live in the platform team's Prometheus, which we don't alert from. Platform " |
| "federates a short allowlist of cAdvisor container series into ours (`container_memory_*`, `container_spec_*`, " |
| "`container_cpu_*`) and nothing from kube-state-metrics. Synthetic checks run in the vendor's uptime tool, " |
| "which only covers the public homepage. For us, `up` and the services' own request counters are the " |
| "liveness signals.\n" |
| f"Scrape intervals per job are in ADR {adr}. We size rate windows at about four scrape intervals.", |
| "We scrape the app pods and the ingress controller. Relabelling puts the Kubernetes Service name in `service` " |
| "and the pod name in `pod` on every app target, so a service's targets are `up{service=\"…\"}`. The kubelet " |
| "and kube-state-metrics are scraped by platform's Prometheus and we don't alert on them; platform federates an " |
| "allowlist of cAdvisor series to us (`container_memory_*`, `container_spec_*`, `container_cpu_*`), none from " |
| "kube-state-metrics. The uptime vendor's synthetic checks cover the public homepage only. That leaves `up` and " |
| "each service's own request counters as our liveness signals.\n" |
| f"ADR {adr} has the scrape interval of every job. A rate window should cover about four scrape intervals.", |
| "What we can see from here: our apps and the ingress. App targets are relabelled with `service` (the " |
| "Kubernetes Service name) and `pod`; `up{service=\"…\"}` lists a service's targets. Platform runs the " |
| "Prometheus with the kubelet and kube-state-metrics in it, and we don't alert from that one. They federate " |
| "a few cAdvisor container series into ours (`container_memory_*`, `container_spec_*`, `container_cpu_*`), " |
| "and nothing from kube-state-metrics. The vendor's synthetic checks only watch the public homepage, so " |
| "liveness here means `up` and the services' own request counters.\n" |
| f"Per-job scrape intervals: ADR {adr}. Rate windows are sized at roughly four scrape intervals."]) |
|
|
|
|
| |
| |
| SEVERITY_ALIAS = {"critical": "page"} |
|
|
|
|
| def severity(w, f) -> str: |
| return _pick(w, "severity", [ |
| "`page` wakes someone up. `critical` is the older spelling of `page`: it routes and pages the same way, and new " |
| "rules use `page`. `warning` pages nobody. Generation-1 files still have a few two-tier alerts with a `warning` " |
| "and a `critical` copy.\n\n" |
| "We page when users are hurt now, or will be within the hour, and whoever gets paged can act on it. " |
| "Everything else is a ticket (`severity: ticket`), which lands in the owning team's queue.", |
| "Severities: `page` gets someone out of bed; `critical` means the same thing in older rules (same routing, same " |
| "page) and new rules say `page`; `warning` goes to Slack and pages nobody. A few generation-1 alerts come in " |
| "pairs, a `warning` copy and a `critical` copy.\n\n" |
| "A page is for users hurting now or within the hour, and only if the person paged can do something about " |
| "it. Anything else is `severity: ticket` and goes to the owning team's queue.", |
| "- `page`: wakes someone up.\n- `critical`: the old name for `page`. Routed and paged exactly like it; write " |
| "`page` in new rules.\n- `warning`: pages nobody.\n- `ticket`: lands in the owning team's queue.\n\n" |
| "Some generation-1 alerts still exist twice, as a `warning` and a `critical` copy. The rule for paging: " |
| "users are affected now or will be within the hour, and the person who gets paged can act. If not, it's " |
| "a ticket."]) |
|
|
|
|
| def classes(w, f) -> str: |
| disk = f["disk"] |
| text = _pick(w, "classes", [ |
| "- **Service alerts** (`<ServiceCamel>HighErrorRatio`, `<ServiceCamel>Down`, burn alerts) page the owning team.\n" |
| " Service error alerts are per service, never per pod; one page per service per outage. They use a 5m window\n" |
| " and `for: 10m`. Errors are 5xx; 4xx are the caller's problem.\n" |
| "- **Capacity alerts** (`ContainerMemoryNearLimit`, disk) open a ticket for the owning team, except where an ADR\n" |
| f" says a level pages (disk: ADR {disk}). `ContainerMemoryNearLimit` opens a ticket when a container keeps reaching\n" |
| " 90% of its memory limit for 10 minutes. One busy 5-minute stretch isn't that. We want the ticket inside 20\n" |
| " minutes of the first time it reaches 90%, which leaves time before the OOM.\n" |
| "- **Fleet alerts** (node, database, cache, broker exporters) are `infra`'s, `severity: warning`, and page nobody.\n" |
| "- Any other alert keeps the `severity` and `team` it has unless a ticket says otherwise. Ticket alerts carry\n" |
| " `service` like pages do.\n\n" |
| "Every alert has labels `severity` and `team`. Service, capacity and ticket alerts also carry `service` on the\n" |
| "alert (from the expression or as a static label). Annotations: a `summary` that says what is affected, and\n" |
| "`runbook_url`.", |
| "Service alerts are `<ServiceCamel>HighErrorRatio`, `<ServiceCamel>Down` and the burn alerts. They page the team " |
| "that owns the service, and error alerts are per service, not per pod, so an outage is one page per service. " |
| "Window 5m, `for: 10m`. Only 5xx count as errors; a 4xx is the caller's problem.\n\n" |
| "Capacity alerts (`ContainerMemoryNearLimit`, disk) are tickets for the owning team unless an ADR makes a level " |
| f"page (disk: ADR {disk}). `ContainerMemoryNearLimit` is for a container that keeps hitting 90% of its memory " |
| "limit for 10 minutes, not for one busy 5-minute stretch, and the ticket should be open within 20 minutes of " |
| "the first time it hits 90%, well before the OOM.\n\n" |
| "Fleet alerts (node, database, cache and broker exporters) belong to `infra`, are `severity: warning`, and " |
| "page nobody. All other alerts keep their `severity` and `team` unless a ticket asks for a change. Ticket " |
| "alerts carry `service`, same as pages.\n\n" |
| "Labels on every alert: `severity`, `team`. Service, capacity and ticket alerts carry `service` as well, from " |
| "the expression or set statically. Annotations: a `summary` naming what is affected, and a `runbook_url`.", |
| "| class | examples | goes to | rules |\n|---|---|---|---|\n" |
| "| service | `<ServiceCamel>HighErrorRatio`, `<ServiceCamel>Down`, burn alerts | owning team, paged | per " |
| "service and never per pod (one page per service per outage); error alerts on a 5m window with `for: 10m`; " |
| "errors are 5xx (4xx are the caller's problem) |\n" |
| f"| capacity | `ContainerMemoryNearLimit`, disk | owning team, ticket | an ADR can make a level page (disk: ADR {disk}) |\n" |
| "| fleet | node, database, cache, broker exporters | `infra`, `severity: warning` | pages nobody |\n\n" |
| "`ContainerMemoryNearLimit` means a container keeps reaching 90% of its memory limit for 10 minutes; a " |
| "single busy 5-minute stretch doesn't count. The ticket should exist within 20 minutes of the first time the " |
| "container reaches 90%, so there is time before the OOM kill. Alerts outside these classes keep their " |
| "`severity` and `team` unless a ticket changes them, and ticket alerts carry `service` the way pages do.\n\n" |
| "All alerts: labels `severity` and `team`; service, capacity and ticket alerts add `service` (from the " |
| "expression or as a static label); annotations `summary` (what is affected) and `runbook_url`."]) |
| if knobs.on("label-rule"): |
| text += " Other labels are fine as long as they don't change where the alert goes." |
| return text |
|
|
|
|
| def health(w, f) -> str: |
| return _pick(w, "health", [ |
| "Each service has one Down alert, `<ServiceCamel>Down` (`checkout-api` → `CheckoutApiDown`). It pages the owning " |
| "team within 10 minutes of the service losing its last healthy target, including when the targets are gone. A " |
| "restart that drops targets for up to 2 minutes must not page. Labels: `severity: page`, `team`, and `service`.", |
| "One Down alert per service, named `<ServiceCamel>Down` (so `checkout-api` has `CheckoutApiDown`). When a service " |
| "has no healthy target left, and that includes having no targets at all, its owner gets paged within 10 " |
| "minutes. Targets missing for 2 minutes or less (a restart) must not page. It carries `severity: page`, " |
| "`team` and `service`.", |
| "`<ServiceCamel>Down` (for `checkout-api`: `CheckoutApiDown`) is the only Down alert a service has. Lose the last " |
| "healthy target, or lose the targets altogether, and the owning team is paged within 10 minutes; a restart that " |
| "takes targets away for at most 2 minutes doesn't page. Labels `severity: page`, `team`, `service`."]) |
|
|
|
|
| def slos(w, f) -> str: |
| adr = f["slo"] |
| return _pick(w, "slos", [ |
| "SLI records are `slo:sli_error:ratio_rate<window>` for 5m, 30m, 1h and 6h: the bad fraction, `by (service)`, " |
| "covering every service that emits the family's metrics (don't filter them by service). Latency SLIs are per " |
| "service (`slo:sli_latency:ratio_rate<window>`), because the objective is per service. Burn alerts only read the " |
| "SLI records for their own service. Names: `<ServiceCamel>ErrorBudgetBurnFast` (`for: 2m`, `severity: page`) and " |
| "`<ServiceCamel>ErrorBudgetBurnSlow` (`for: 15m`, `severity: ticket`), labels `severity`, `team` and " |
| f"`slo: <service>-availability`. The factors come from ADR {adr} and the window in the catalog.", |
| "Error SLIs are recorded as `slo:sli_error:ratio_rate<window>` (windows 5m, 30m, 1h, 6h): the fraction of bad " |
| "requests `by (service)`, one record per window for every service with the family's metrics. Don't add a " |
| "service filter to them. Latency SLIs are recorded per service as `slo:sli_latency:ratio_rate<window>`, since " |
| "each service has its own objective. A burn alert reads its own service's SLI records and nothing else; it is " |
| "called `<ServiceCamel>ErrorBudgetBurnFast` (`severity: page`, `for: 2m`) or `<ServiceCamel>ErrorBudgetBurnSlow` " |
| "(`severity: ticket`, `for: 15m`) and is labelled `severity`, `team` and `slo: <service>-availability`. Factors: " |
| f"ADR {adr}; window: the catalog.", |
| "- SLI records: `slo:sli_error:ratio_rate<window>`, windows 5m, 30m, 1h and 6h, the bad fraction " |
| "`by (service)` across every service that emits the family's metrics (no per-service filter).\n" |
| "- Latency SLIs: `slo:sli_latency:ratio_rate<window>`, one per service because objectives differ per service.\n" |
| "- Burn alerts read only their own service's SLI records: `<ServiceCamel>ErrorBudgetBurnFast` (`for: 2m`, " |
| "`severity: page`), `<ServiceCamel>ErrorBudgetBurnSlow` (`for: 15m`, `severity: ticket`), labelled `severity`, " |
| "`team`, `slo: <service>-availability`.\n" |
| f"- Burn factors: ADR {adr}. SLO window: `slo/services.yaml`."]) |
|
|
|
|
| TABLES = ["""| severity | receivers | |
| |---|---| |
| | page, critical | `pagerduty-<team>`, `slack-<team>`, and `slack-sre-fyi` | |
| | ticket | `jira-<team>`, `slack-<team>` | |
| | warning | `slack-<team>` |""", """| alert severity | delivered to | |
| |---|---| |
| | `page` or `critical` | `pagerduty-<team>` + `slack-<team>` + `slack-sre-fyi` | |
| | `ticket` | `jira-<team>` + `slack-<team>` | |
| | `warning` | `slack-<team>` only |""", """- `page` and `critical`: `pagerduty-<team>`, `slack-<team>`, `slack-sre-fyi` |
| - `ticket`: `jira-<team>`, `slack-<team>` |
| - `warning`: `slack-<team>`"""] |
|
|
|
|
| def routing(w, f) -> str: |
| table = _pick(w, "routing-table", TABLES) |
| return _pick(w, "routing", [ |
| "The `team` label on the alert is the routing key and has to match `teams/ownership.yaml`. Each team has a " |
| f"subtree matching its `team`:\n\n{table}\n\n" |
| "SRE watches every page in #sre-fyi (`slack-sre-fyi`); nobody is paged from there. The root receiver " |
| "`slack-alerts-default` is the catch-all for alerts with no `team`; nobody is on it. Rule evaluation failures go " |
| "to `slack-prometheus-meta`. The paging unit is the service: one page per service per outage; two services " |
| "failing together are two pages, even for the same team. Don't change receivers you don't own, `global`, or add " |
| "time intervals.", |
| "Alerts are routed on their `team` label, which must be a team in `teams/ownership.yaml`. Every team has its own " |
| f"subtree, matched on `team`, that sends:\n\n{table}\n\n" |
| "`slack-sre-fyi` is #sre-fyi, where SRE sees every page; it pages nobody. Anything without a `team` ends up at the " |
| "root receiver, `slack-alerts-default`, which nobody watches. Failed rule evaluations are routed to " |
| "`slack-prometheus-meta`. We page per service: one page per service per outage, so two services down at once " |
| "means two pages even when they belong to the same team. Leave other teams' receivers, `global` and time " |
| "intervals alone (don't add any).", |
| f"Routing key: the alert's `team` label, matching `teams/ownership.yaml`. One subtree per team:\n\n{table}\n\n" |
| "Notes: #sre-fyi (`slack-sre-fyi`) is how SRE keeps an eye on every page, and nobody is paged from it. The root " |
| "receiver `slack-alerts-default` catches whatever has no `team`; no one reads it. Evaluation failures go to " |
| "`slack-prometheus-meta`. One page per service per outage: two failing services are two pages, also within one " |
| "team. Not yours to change: other teams' receivers, `global`. Don't add time intervals."]) |
|
|
|
|
| def inhibition(w, f) -> str: |
| cluster = "" |
| if w.clusters: |
| cluster = _pick(w, "inhibition-cluster", [ |
| "\nCluster-level alerts carry no `service`; the list is `ClusterUnreachable`. When `ClusterUnreachable` fires " |
| "it pages platform (`pagerduty-platform`) and holds back the service pages in that cluster, `equal: [cluster]`.", |
| "\nThe only cluster-level alert is `ClusterUnreachable`, and it has no `service` label. It pages platform " |
| "(`pagerduty-platform`), and while it fires the service pages in the same cluster are held back " |
| "(`equal: [cluster]`).", |
| "\nCluster level: `ClusterUnreachable` (no `service` label) pages platform through `pagerduty-platform`; " |
| "while it is firing, service pages from that cluster stay held back, `equal: [cluster]`."]) |
| return _pick(w, "inhibition", [ |
| "Between two services' own alerts, `equal: [service]`, so one service's outage never silences another's. A " |
| "critical copy of an alert holds back the warning copy of the same alert for the same service: " |
| "`equal: [alertname, service]`.", |
| "Inhibitions between service alerts use `equal: [service]`: an outage of one service must never mute another " |
| "service's alerts. The critical copy of an alert holds back its warning copy, same alert and same service, " |
| "with `equal: [alertname, service]`.", |
| "- service alerts holding back other service alerts: always `equal: [service]`, so no outage silences another " |
| "service.\n- critical copy over warning copy of the same alert for the same service: `equal: [alertname, service]`."]) + cluster |
|
|
|
|
| def runbooks(w, f) -> str: |
| return _pick(w, "runbooks", [ |
| f"`runbook_url` is `https://runbooks.{w.domain}/alerts/<AlertName>`. The site is built from `runbooks/*.md` in " |
| "this repo, and each page lists the alerts it covers in its front matter.", |
| f"Runbook links point at `https://runbooks.{w.domain}/alerts/<AlertName>`. That site is generated from " |
| "`runbooks/*.md` here; a page's front matter lists the alerts it covers.", |
| f"Use `https://runbooks.{w.domain}/alerts/<AlertName>` as the `runbook_url`. The runbook site is built from " |
| "`runbooks/*.md`, and the front matter of each page says which alerts it covers."]) |
|
|
|
|
| def extras(w, f) -> str: |
| """What this repo does that the rules above don't: one of three kinds of section, each true of this world.""" |
| kind = _pick(w, "extras", ["exceptions", "changelog", "contacts"]) |
| legacy = sorted(x.stem for x in w.files.values() if x.gen == 1 and x.stem.startswith("legacy-")) |
| operator = sorted(x.stem for x in w.files.values() if x.gen == 3) |
| dead = w.notes.get("dead_receiver") |
| if kind == "exceptions": |
| lines = ["## Known exceptions", "", "| where | what | why it's still there |", "|---|---|---|"] |
| if legacy: |
| lines.append(f"| {', '.join(f'`rules/{x}.yml`' for x in legacy)} | inline ratios, two-tier warning/critical " |
| f"copies, quoted durations | generation 1; moved out when someone has a reason to touch them |") |
| if operator: |
| lines.append(f"| {', '.join(f'`rules/{x}.yaml`' for x in operator)} | PrometheusRule manifests | those teams " |
| f"deploy rules with the operator |") |
| lines.append("| fleet files (`node-exporter`, `postgres`, ...) | upstream thresholds | nobody has tuned them |") |
| if dead: |
| lines.append(f"| `{dead}` receiver | routes nothing | kept until its last user is confirmed gone |") |
| return "\n".join(lines) |
| if kind == "changelog": |
| mon = ["2025-11", "2026-02", "2026-05", "2026-08"] |
| return "\n".join(["## Changelog", "", |
| f"- {mon[0]}: burn alerts moved to the SLI records (ADR {f['slo']}).", |
| f"- {mon[1]}: `slack-sre-fyi` added; SRE stopped being paged for every team.", |
| f"- {mon[2]}: disk alerts per ADR {f['disk']}.", |
| f"- {mon[3]}: kafka-exporter scraped every 1m instead of 15s (ADR {f['scrape']})."]) |
| return "\n".join(["## Contacts", "", |
| "- Questions: #obs-help. Office hours Tuesday and Thursday afternoons.", |
| f"- Urgent routing problems out of hours: the SRE rota (`pagerduty-sre`).", |
| "- Reviews: observability for anything under `alertmanager/`; the owning team for its rules."]) |
|
|
|
|
| SECTIONS = [("Where things live", layout), (None, house), ("What this Prometheus sees", sees), |
| ("Severity and paging", severity), ("Alert classes", classes), ("Service health", health), ("SLOs", slos), |
| ("Routing", routing), ("Inhibition", inhibition), ("Runbooks", runbooks)] |
| HEADINGS = {"Where things live": ["Where things live", "Layout", "What's where"], |
| "What this Prometheus sees": ["What this Prometheus sees", "Scrape targets", "What we scrape"], |
| "Severity and paging": ["Severity and paging", "Paging policy", "Severities"], |
| "Alert classes": ["Alert classes", "Kinds of alerts", "Alert classes"], |
| "Service health": ["Service health", "Down alerts", "Service health"], |
| "SLOs": ["SLOs", "SLO alerting", "SLIs and burn alerts"], |
| "Routing": ["Routing", "Who gets what", "Routing"], |
| "Inhibition": ["Inhibition", "Inhibition rules", "Inhibitions"], |
| "Runbooks": ["Runbooks", "Runbook links", "Runbooks"]} |
|
|
|
|
| def readme(w, f: dict) -> str: |
| order = list(SECTIONS) |
| if _pick(w, "order", [0, 1]): |
| i, j = order.index(("Alert classes", classes)), order.index(("Routing", routing)) |
| order[i], order[j] = order[j], order[i] |
| title = _pick(w, "title", ["# monitoring", f"# {w.company.name} monitoring", "# alerting"]) |
| out = [title, "", intro(w, f), ""] |
| for head, fn in order: |
| if head: |
| out += [f"## {_pick(w, 'h:' + head, HEADINGS[head])}", ""] |
| out += [fn(w, f), ""] |
| out += [extras(w, f), ""] |
| return "\n".join(out) |
|
|
