stackvitals 0.1.0__py3-none-any.whl

stackvitals/core/investment.py

@@ -0,0 +1,187 @@
+"""Where the work goes: each merged pull request sorted into feature, fix, maintenance, security or docs work from the
+repo's own label rules, its Jira or Linear issue's type, common labels, its changelog fragment, its title (a Conventional
+Commit or component prefix, or the leading verb) or the files it touched; the mix per month, with how each was decided.
+People's and agents' work only: update bots are counted apart."""
+import fnmatch
+import re
+from collections import Counter
+from datetime import datetime
+
+from stackvitals.core.actors import kind_of
+from stackvitals.core.config import INVESTMENT as CATEGORIES
+
+OTHER = "other"
+# Common label names (the part after "type:", "kind/" and the like), checked in this order: security work wins.
+LABELS = (("security", ("security", "vulnerability", "cve")),
+          ("fix", ("bug", "fix", "bugfix", "regression", "defect", "hotfix")),
+          ("feature", ("feature", "enhancement", "feat", "new feature", "feature request")),
+          ("docs", ("documentation", "docs", "doc")),
+          ("maintenance", ("chore", "refactor", "refactoring", "dependencies", "deps", "tech debt", "tech-debt", "ci",
+                           "build", "maintenance", "performance", "perf", "cleanup", "test", "tests", "infra")))
+TITLES = {"feat": "feature", "feature": "feature", "fix": "fix", "bugfix": "fix", "hotfix": "fix", "revert": "fix", "bug": "fix",
+          "docs": "docs", "doc": "docs", "documentation": "docs", "security": "security", "sec": "security",
+          "chore": "maintenance", "refactor": "maintenance", "ci": "maintenance", "build": "maintenance", "test": "maintenance",
+          "tests": "maintenance", "testing": "maintenance", "perf": "maintenance", "style": "maintenance", "deps": "maintenance",
+          "mnt": "maintenance", "maint": "maintenance", "bench": "maintenance", "release": "maintenance"}
+CONVENTIONAL = re.compile(r"^\s*([A-Za-z]+)(?:\([^)]*\))?!?:")
+# Changelog fragments (towncrier and the like) name their kind: news/1234.bugfix.rst, changelog/12.feature.md, CHANGES/9.bugfix.
+FRAGMENT = re.compile(r"(?:^|/)(?:news|changes|changelog|changelog\.d|newsfragments)/[^/]+?\.([A-Za-z]+)(?:\.(?:rst|md|txt))?$",
+                      re.I)
+FRAGMENTS = {"security": "security", "bugfix": "fix", "bugfixes": "fix", "bug": "fix", "fix": "fix", "fixed": "fix",
+             "feature": "feature", "features": "feature", "improvement": "feature", "enhancement": "feature", "added": "feature",
+             "removal": "maintenance", "deprecation": "maintenance", "breaking": "maintenance", "misc": "maintenance",
+             "trivial": "maintenance", "vendor": "maintenance", "process": "maintenance", "packaging": "maintenance",
+             "contrib": "maintenance", "internal": "maintenance", "performance": "maintenance", "doc": "docs", "docs": "docs",
+             "documentation": "docs"}
+# A title's leading verb, once backport tags, a component prefix and a scope are set aside ("[3.14] dialects: (llvm) add").
+VERBS = {**dict.fromkeys(("fix", "fixes", "fixed", "fixing", "revert", "resolve", "resolves", "correct", "repair", "prevent",
+                          "avoid", "handle", "restore", "preserve", "don't"), "fix"),
+         **dict.fromkeys(("add", "adds", "added", "adding", "implement", "implements", "introduce", "support", "allow",
+                          "enable", "expose", "new", "create", "provide", "feat", "feature"), "feature"),
+         **dict.fromkeys(("refactor", "remove", "removes", "drop", "clean", "cleanup", "bump", "upgrade", "deprecate",
+                          "simplify", "move", "rename", "replace", "migrate", "speed", "optimize", "optimise", "vendor", "pin",
+                          "unpin", "release", "prepare", "tidy", "reorganize", "restructure", "test", "tests", "skip", "lint",
+                          "use", "rework", "extract", "split", "switch"), "maintenance"),
+         **dict.fromkeys(("document", "documents", "docs", "doc", "typo", "readme", "clarify"), "docs")}
+DOCS = ("docs/*", "doc/*", "*.md", "*.rst", "*.adoc", "mkdocs.yml", "LICENSE*")
+TESTS = ("tests/*", "test/*", "testing/*", "__tests__/*", "*_test.*", "test_*", "*.spec.*", "*.test.*", "conftest.py")
+UPKEEP = (".github/*", "*.lock", "*lock.json", "*lock.yaml", "go.sum", "requirements*.txt", ".pre-commit-config.yaml",
+          "Dockerfile*", ".gitignore", "renovate.json", ".editorconfig")
+ORDER = ("security", "fix", "feature", "maintenance", "docs")  # when a PR carries fragments of several kinds
+RELEASE = re.compile(r"^\s*(?:(?:prepare\s+)?release\b(?!s)|bump\s+version\b|v?\d+\.\d+(?:\.\d+)?\s*$)", re.I)
+TRACKER = {"BUG": "fix", "INCIDENT": "fix", "REQUIREMENT": "feature"}
+MONTHS = 6
+
+
+def _key(label: str) -> str:
+    # "type: bug", "kind/bug", "T-bug", "🐛 bug" all read as "bug".
+    last = re.split(r"[:/]", label.lower())[-1]
+    return re.sub(r"^[^a-z0-9]+", "", last).removeprefix("t-").strip(" -_")
+
+
+def _all(paths: list[str], patterns: tuple) -> bool:
+    return bool(paths) and all(any(fnmatch.fnmatch(p, g) or fnmatch.fnmatch(p.rsplit("/", 1)[-1], g) for g in patterns)
+                               for p in paths)
+
+
+def _verb(title: str) -> str | None:
+    t = re.sub(r"^\s*(\[[^\]]*\]\s*)+", "", title)
+    t = re.sub(r"^\s*[\w./-]+:\s*", "", t)
+    t = re.sub(r"^\(([^)]*)\)\s*", "", t)
+    word = re.match(r"[A-Za-z]+(?:'t)?", t)
+    return word.group(0).lower() if word else None
+
+
+def classify(pr: dict, rules: dict | None = None, tracker_type: str | None = None) -> tuple[str, str]:
+    """(category, how it was decided) for one pull request."""
+    labels = pr.get("lb") or []
+    low = {x.lower(): x for x in labels}
+    for cat in CATEGORIES:
+        for name in (rules or {}).get(cat) or []:
+            if name.lower() in low:
+                return cat, f"label {low[name.lower()]} (this repo's rule)"
+    keys = {_key(x): x for x in labels}
+    if any(k in keys for k in LABELS[0][1]):
+        return "security", f"label {next(keys[k] for k in LABELS[0][1] if k in keys)}"
+    if tracker_type in TRACKER:
+        return TRACKER[tracker_type], f"issue type {tracker_type.lower()}"
+    for cat, names in LABELS[1:]:
+        hit = next((keys[k] for k in names if k in keys), None)
+        if hit:
+            return cat, f"label {hit}"
+    title = pr.get("ti") or ""
+    # A release PR gathers every changelog fragment, so its title decides (pip's "Release 26.2").
+    if RELEASE.match(title):
+        return "maintenance", "title release"
+    found = CONVENTIONAL.match(title)
+    if found and found.group(1).lower() in TITLES:
+        return TITLES[found.group(1).lower()], f"title {found.group(1).lower()}:"
+    paths = pr.get("paths") or []
+    fragments = [k.lower() for p in paths if (m := FRAGMENT.search(p)) and (k := m.group(1)).lower() in FRAGMENTS]
+    kinds = {FRAGMENTS[k] for k in fragments}
+    if len(fragments) >= 3 and len(kinds) >= 2:
+        return "maintenance", "changelog fragments of several kinds"  # release notes gathered or edited
+    if fragments:
+        kind = min(fragments, key=lambda k: ORDER.index(FRAGMENTS[k]))
+        return FRAGMENTS[kind], f"changelog fragment {kind}"
+    if _all(paths, DOCS):
+        return "docs", "only docs files"
+    if _all(paths, TESTS):
+        return "maintenance", "only test files"
+    if _all(paths, UPKEEP):
+        return "maintenance", "only CI or dependency files"
+    if "[NFC]" in title:
+        return "maintenance", "title [NFC]"
+    verb = _verb(title)
+    if verb in VERBS:
+        return VERBS[verb], f"title verb {verb}"
+    if re.search(r"\b(fix|fixes|fixed|bug|crash|regression)\b", title, re.I):
+        return "fix", "title mentions a fix"
+    return OTHER, "no label, issue type, changelog fragment, title or file pattern"
+
+
+def mix(prs: list[dict], now: datetime, rules: dict | None = None, tracker_types: dict | None = None,
+        months: int = MONTHS, base: str | None = None) -> dict | None:
+    """Merged PRs into the default branch (`base`; backports to release branches would count the work twice) of the
+    last `months` calendar months (this one so far) by category and month, how each category was decided, and the update
+    bots' PRs counted apart; None without a merged PR."""
+    first = (now.year * 12 + now.month - 1) - (months - 1)
+    since = f"{first // 12:04d}-{first % 12 + 1:02d}"
+    merged = [p for p in prs if p.get("mg") and p["mg"][:7] >= since and (base is None or p.get("base") in (None, base))]
+    work = [p for p in merged if kind_of(p.get("au"), p.get("at")) in ("person", "agent")]
+    if not work:
+        return None
+    by_month, total, how, examples = {}, Counter(), Counter(), {}
+    for p in sorted(work, key=lambda p: p["mg"]):
+        cat, why = classify(p, rules, (tracker_types or {}).get(p["n"]))
+        by_month.setdefault(p["mg"][:7], Counter())[cat] += 1
+        total[cat] += 1
+        how[why.split(" ")[0] if cat != OTHER else OTHER] += 1
+        examples.setdefault(cat, []).append(p["n"])
+    order = (*CATEGORIES, OTHER)
+    return {"since": since, "months": [{"month": m, "n": sum(c.values()), "counts": {k: c.get(k, 0) for k in order}}
+                                       for m, c in sorted(by_month.items())],
+            "n": len(work), "counts": {k: total.get(k, 0) for k in order},
+            "shares": {k: round(total.get(k, 0) / len(work), 4) for k in order},
+            "decided_by": dict(how.most_common()), "examples": {k: v[-5:] for k, v in examples.items()},
+            "bots": len(merged) - len(work)}
+
+
+def tracker_types(prs: list[dict], issues: list[dict]) -> dict[int, str]:
+    """Each PR's linked Jira or Linear issue type; with several, the most telling (incident, bug, requirement, task)."""
+    from stackvitals.connectors.tracker import pr_links
+    rank = {"INCIDENT": 0, "BUG": 1, "REQUIREMENT": 2, "TASK": 3}
+    types = {i["key"]: i.get("type") or "TASK" for i in issues}
+    out = {}
+    for n, key in pr_links(prs, issues):
+        if n not in out or rank.get(types[key], 3) < rank.get(out[n], 3):
+            out[n] = types[key]
+    return out
+
+
+def by_epic(prs: list[dict], issues: list[dict], now: datetime, months: int = MONTHS, base: str | None = None) -> dict | None:
+    """Merged people's PRs linked to Jira or Linear issues, by the epic (Jira) or project (Linear) those belong to, and
+    the share linked to feature work (requirements), which teams often capitalise; None without a linked PR."""
+    from stackvitals.connectors.tracker import pr_links
+    first = (now.year * 12 + now.month - 1) - (months - 1)
+    since = f"{first // 12:04d}-{first % 12 + 1:02d}"
+    # Into the default branch only, as in the monthly mix: a backport would count the same work twice.
+    work = [p for p in prs if p.get("mg") and p["mg"][:7] >= since and kind_of(p.get("au"), p.get("at")) in ("person", "agent")
+            and (base is None or p.get("base") in (None, base))]
+    by_key = {i["key"]: i for i in issues}
+    linked = {}
+    for n, key in pr_links(work, issues):
+        linked.setdefault(n, []).append(by_key[key])
+    if not linked:
+        return None
+    epics, titles, features = Counter(), {}, 0
+    for found in linked.values():
+        tagged = [i for i in found if i.get("epic")]
+        if tagged:
+            epics[tagged[0]["epic"]] += 1
+            titles.setdefault(tagged[0]["epic"], tagged[0].get("epic_title"))
+        features += any(i.get("type") == "REQUIREMENT" for i in found)
+    total = len(linked)
+    return {"since": since, "linked": total, "no_epic": total - sum(epics.values()),
+            "epics": [{"epic": e, "title": titles.get(e), "prs": n, "share": round(n / total, 4)} for e, n in epics.most_common(10)],
+            "feature_share": round(features / total, 4)}

stackvitals/core/joins.py

@@ -0,0 +1,43 @@
+"""Join keys between modules: CI runs to the pull requests they tested, and how far back the CI history has no gaps."""
+from collections import defaultdict
+from datetime import date
+
+# pull_request_target runs test the base branch's code, not the PR's, so they say nothing about the PR's commits.
+PR_EVENTS = {"pull_request"}
+
+
+def runs_by_pr(runs: list[dict], prs: list[dict]) -> dict[int, list[dict]]:
+    """CI runs of pull_request events keyed by PR number: the number GitHub gives (same-repo PRs), else the PR with the
+    same head owner and branch that was open when the run was created (forks; a reused branch maps to the right PR)."""
+    numbers = {p["n"] for p in prs}
+    by_head = defaultdict(list)
+    for p in prs:
+        if p.get("ho") and p.get("head"):
+            by_head[(p["ho"].lower(), p["head"])].append(p)
+    out = defaultdict(list)
+    for r in runs:
+        if r.get("ev") not in PR_EVENTS:
+            continue
+        hits = [n for n in r.get("pr") or [] if n in numbers]
+        if not hits and r.get("ho") and r.get("br"):
+            cr = r.get("cr") or ""
+            open_then = [p for p in by_head.get((r["ho"].lower(), r["br"]), []) if p["cr"] <= cr <= (p.get("cl") or "9999")]
+            if open_then:
+                hits = [max(open_then, key=lambda p: p["cr"])["n"]]
+        if hits:
+            out[hits[0]].append(r)
+    return dict(out)
+
+
+def coverage_start(state: dict, runs: list[dict]) -> str | None:
+    """Where the CI history is unbroken: the oldest day of the run of consecutive scanned days that ends at the newest one;
+    without that record, the oldest run kept."""
+    days = sorted((state or {}).get("scanned") or {}, reverse=True)
+    if days:
+        start = days[0]
+        for day in days[1:]:
+            if (date.fromisoformat(start) - date.fromisoformat(day)).days != 1:
+                break
+            start = day
+        return f"{start}T00:00:00Z"
+    return min((r["cr"] for r in runs if r.get("cr")), default=None)

stackvitals/core/llmsdoc.py

@@ -0,0 +1,40 @@
+"""llms.txt at the repo root (llmstxt.org): the docs as a short index an AI agent reads first, each page with its title
+and its first sentence, made from docs/ so it can't fall behind them (a test checks it is current)."""
+import re
+from pathlib import Path
+
+# Shown under Optional: true but rarely what an agent needs first.
+OPTIONAL = {"release-checklist.md", "threat-model.md", "roadmap.md", "chaoss.md", "enterprise.md"}
+SUMMARY = ("A free, GitHub-native engineering health suite: one GitHub Action keeps CI, pull request, delivery (DORA), "
+           "community and dependency history on a data branch in your own repo, with a static app, a CLI and an MCP "
+           "server over it. No server of ours, no Docker.")
+
+
+def _first_sentence(text: str) -> str:
+    """The first plain sentence after the title: links and code kept as words, at most 220 characters."""
+    body = []
+    for line in text.splitlines()[1:]:
+        if not line.strip():
+            if body:
+                break
+            continue
+        if line.startswith(("#", "|", "```", "-", ">", "<")):
+            if body:
+                break
+            continue
+        body.append(line.strip())
+    para = re.sub(r"\[([^\]]+)\]\([^)]+\)", r"\1", " ".join(body)).replace("**", "").replace("`", "")
+    first = re.split(r"(?<=[.!?])\s", para, maxsplit=1)[0]
+    return first if len(first) <= 220 else first[:217].rsplit(" ", 1)[0] + "..."
+
+
+def markdown(root: Path) -> str:
+    docs = Path(root) / "docs"
+    pages = sorted(p for p in docs.rglob("*.md"))
+    main, optional = [], []
+    for p in pages:
+        text = p.read_text(encoding="utf-8")
+        title = text.splitlines()[0].lstrip("# ").strip() if text.strip() else p.stem
+        line = f"- [{title}]({p.relative_to(root).as_posix()}): {_first_sentence(text)}"
+        (optional if p.name in OPTIONAL else main).append(line)
+    return "\n".join(["# StackVitals", "", f"> {SUMMARY}", "", "## Docs", "", *main, "", "## Optional", "", *optional, ""])

stackvitals/core/merge_queue.py

@@ -0,0 +1,70 @@
+"""Merge-queue health, which GitHub itself doesn't report: how long pull requests wait in the queue before they merge,
+why they get taken out, and how many removals followed a merge-group run that failed only on jobs known to be flaky."""
+import re
+from collections import Counter
+from datetime import datetime, timedelta
+
+from stackvitals.core.stats import percentile
+from stackvitals.core.time import iso, parse
+
+QUEUE_BRANCH = re.compile(r"^gh-readonly-queue/.+/pr-(\d+)-")
+# A pull request also leaves the queue when it merges; those removals are not trouble. GraphQL spells reasons in lowercase
+# (merged, merge_conflict, failed_checks), webhooks in uppercase, so case is ignored.
+MERGED = {"MERGE", "MERGED", "ALREADY_MERGED"}
+CLOSE_TO_MERGE = timedelta(minutes=5)
+FLAKY = {"flaky", "suspect"}
+FAILED = ("failure", "timed_out")
+LOOK_BACK = timedelta(hours=3)  # a removal is tied to the queue's failed runs for that PR shortly before it
+MIN_N = 10  # fewer merges and the waits are left out (the count stays)
+
+
+def _hours(a: str, b: str) -> float:
+    return round((parse(b) - parse(a)).total_seconds() / 3600, 2)
+
+
+def health(prs: list[dict], ci: dict, job_states: dict, now: datetime, window_days: int, min_n: int = MIN_N) -> dict | None:
+    """{prs, merged, p50_h, p90_h, removals: {reason: n}, removed_by_flakes: [...], runs, failed_runs} over the window,
+    or None when nothing used a merge queue."""
+    since = iso(now - timedelta(days=window_days))
+    queued = [p for p in prs if any(e[1] >= since for e in p.get("mq") or [])]
+    if not queued:
+        return None
+    # A run's final attempt is its answer: a re-run is the same run, not another one.
+    final = {}
+    for r in ci.get("runs") or []:
+        if r.get("ev") == "merge_group" and (r.get("cr") or "") >= since and r.get("att", 1) >= final.get(r["id"], {}).get("att", 0):
+            final[r["id"]] = r
+    runs = list(final.values())
+    by_pr = {}
+    for r in runs:
+        found = QUEUE_BRANCH.match(r.get("br") or "")
+        if found:
+            by_pr.setdefault(int(found.group(1)), []).append(r)
+    failed_jobs = {}
+    for j in ci.get("jobs") or []:
+        if j.get("c") in FAILED:
+            failed_jobs.setdefault((j["run"], j.get("att", 1)), []).append(j.get("n"))
+    waits, removals, flaky = [], Counter(), []
+    for p in queued:
+        events = sorted(p.get("mq") or [], key=lambda e: e[1])
+        if p.get("mg"):
+            entered = [e[1] for e in events if e[0] == "add" and e[1] <= p["mg"]]
+            if entered:
+                waits.append(_hours(entered[-1], p["mg"]))
+        for e in events:
+            if e[0] != "rm" or e[1] < since:
+                continue
+            reason = (e[2] if len(e) > 2 else None) or "UNKNOWN"
+            if reason.upper() in MERGED or (p.get("mg") and abs(parse(e[1]) - parse(p["mg"])) <= CLOSE_TO_MERGE):
+                continue
+            removals[reason] += 1
+            # Every failing run just before the removal (several workflows can fail together), and every job that failed.
+            before = [r for r in by_pr.get(p["n"], []) if r.get("c") in FAILED and iso(parse(e[1]) - LOOK_BACK) <= r["cr"] <= e[1]]
+            jobs = [(r.get("path"), name) for r in before for name in failed_jobs.get((r["id"], r.get("att", 1))) or []]
+            if jobs and all(job_states.get(job) in FLAKY for job in jobs):
+                flaky.append({"pr": p["n"], "at": e[1], "jobs": sorted({name for _path, name in jobs})})
+    enough = len(waits) >= min_n
+    return {"prs": len(queued), "merged": len(waits), "p50_h": percentile(waits, 0.5) if enough else None,
+            "p90_h": percentile(waits, 0.9) if enough else None, "removals": dict(removals.most_common()),
+            "removed_by_flakes": flaky, "runs": len(runs),
+            "failed_runs": sum(1 for r in runs if r.get("c") in FAILED), "window_days": window_days}

stackvitals/core/metrics.py

@@ -0,0 +1,109 @@
+"""The metric registry: every number the suite shows has an id, a version, a one-sentence definition, a minimum sample,
+and comes out as a Measure with n, a range and an as-of time. Benchmarks use the same ids, so a repo's number and its
+peer percentile are the same definition by construction."""
+from dataclasses import asdict, dataclass
+from datetime import datetime
+
+from stackvitals.core import stats
+from stackvitals.core.time import iso
+
+
+@dataclass(frozen=True)
+class Metric:
+    id: str
+    definition: str
+    unit: str  # s, share, count, lines, ms
+    kind: str  # median, p75, share, count
+    min_n: int = 1
+    better: int = 0  # -1 lower is better, 1 higher, 0 neither
+    version: int = 1
+
+
+@dataclass
+class Measure:
+    metric: str
+    version: int
+    value: float | None
+    n: int
+    low: float | None
+    high: float | None
+    unit: str
+    as_of: str
+    window_days: int | None = None
+    note: str | None = None
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+REGISTRY: dict[str, Metric] = {}
+
+
+def register(metric: Metric) -> Metric:
+    REGISTRY[metric.id] = metric
+    return metric
+
+
+def get(metric_id: str) -> Metric:
+    return REGISTRY[metric_id]
+
+
+def all() -> list[Metric]:  # noqa: A001
+    return list(REGISTRY.values())
+
+
+def measure(metric_id: str, values: list[float] | None = None, hits: int | None = None, n: int | None = None,
+            as_of: datetime | str = "", window_days: int | None = None) -> Measure:
+    """One number with its evidence: a median or percentile of `values`, a share of `hits` in `n`, or a count `n`."""
+    m = get(metric_id)
+    stamp = as_of if isinstance(as_of, str) else iso(as_of)
+    low = high = value = None
+    if m.kind in ("median", "p75"):
+        values = [v for v in (values or []) if v is not None]
+        n = len(values)
+        q = 0.5 if m.kind == "median" else 0.75
+        if n >= m.min_n and n:
+            value = stats.median(values) if m.kind == "median" else stats.percentile(values, q)
+            rng = stats.quantile_range(values, q)
+            low, high = rng if rng else (None, None)
+    elif m.kind == "share":
+        n = int(n or 0)
+        if n >= m.min_n and n:
+            value = round((hits or 0) / n, 4)
+            low, high = (round(x, 4) for x in stats.wilson(hits or 0, n))
+    else:
+        n = int(n or 0)
+        value = n
+    note = None if value is not None or m.kind == "count" else f"not enough data (n={n}, needs {m.min_n})"
+    return Measure(m.id, m.version, value, n, low, high, m.unit, stamp, window_days, note)
+
+
+# Review flow: LinearB's four phases, review split into its approve and merge metrics, on GitHub's own timestamps; DevLake's four fields are derived from these.
+for _id, _definition, _min in (
+    ("flow.coding_time", "Seconds from the PR's first commit (authored) to the PR being opened; median.", 10),
+    ("flow.pickup_time", "Seconds from the PR being ready for review (opened, or leaving draft) to the first review submitted "
+                         "by a person other than the author (approval, change request or review comment); bots and agents "
+                         "don't count; median over merged PRs.", 10),
+    ("flow.review_time", "Seconds from the first review activity to the merge; median over merged PRs.", 10),
+    ("flow.approve_time", "Seconds from the first review activity to the first approval; median.", 10),
+    ("flow.merge_time", "Seconds from the first approval to the merge; median.", 10),
+    ("flow.deploy_time", "Seconds from the merge to the end of the first successful production deployment that contains it; median.", 10),
+    ("flow.cycle_time", "Seconds from ready for review to merged; median over merged PRs.", 10),
+):
+    register(Metric(_id, _definition, "s", "median", _min, -1))
+register(Metric("flow.outsider_merge_rate", "Share of outside contributors' PRs (people who are not insiders; bots and "
+                "agents left out) that were merged, among those decided in the window.", "share", "share", 10, 1))
+register(Metric("flow.open_prs", "Open PRs by people, drafts included.", "count", "count"))
+register(Metric("community.first_answer_time", "Seconds from an outside PR or issue being opened to the first answer by a "
+                "maintainer (review, reply, merge or close by someone else); median.", "s", "median", 10, -1))
+register(Metric("ci.flake_rate", "Share of runs of a job or test in the window that flaked (failed and passed on the same "
+                "code).", "share", "share", 5, -1))
+register(Metric("ci.first_try_green", "Share of pushes to the default branch whose checks all passed on the first attempt.",
+                "share", "share", 5, 1))
+register(Metric("ci.push_wait", "Seconds from a push to the default branch until all its checks finished; median.",
+                "s", "median", 5, -1))
+# Cross-module: CI Health's runs joined to Team Flow's pull requests.
+register(Metric("insight.red_ci_share", "Share of people's merged pull requests that spent time ready for review with a "
+                "failing check on their newest commit.", "share", "share", 10, -1))
+register(Metric("insight.red_ci_hours", "Hours a merged pull request spent ready for review with a failing check on its "
+                "newest commit, among those that did; median.", "h", "median", 5, -1))