@getarbiter/cli 0.5.0

package/dist/templates/operations/handbook.md.ejs

@@ -0,0 +1,217 @@
+# Operations Handbook — <%= projectName %>
+
+<!-- arbiter-managed: operations-handbook (#717) -->
+
+This handbook defines the operational baseline for **<%= projectName %>**: observability signals,
+on-call protocol, release gates, and runbook structure.
+
+---
+
+## 1. Four-Signal Observability (RED / USE)
+
+Every service dashboard must track these four signals at all times.
+
+| Signal | Metric type | Alert threshold | Measurement |
+| ------------ | ----------- | --------------- | ----------------------------- |
+| **Latency** | Histogram | p95 > SLA budget | Request duration (ms) |
+| **Traffic** | Counter | Spike > 3× baseline | Requests per second |
+| **Errors** | Counter | Error rate > 1% | 5xx + client-abort count |
+| **Saturation** | Gauge | CPU > 80% or queue depth | Resource utilisation % |
+
+### SLA Budgets
+
+Define service-level objectives below. Tighten during hardening phases.
+
+| Endpoint class | p50 target | p95 target | p99 target |
+| -------------- | ---------- | ---------- | ---------- |
+| Read (GET) | 50 ms | 200 ms | 500 ms |
+| Write (POST/PUT) | 100 ms | 500 ms | 1 000 ms |
+| Background job | — | 30 s | 5 min |
+
+### Alert Routing
+
+- **P1 (service down / error rate > 5%)** → PagerDuty immediately, wake on-call
+- **P2 (p95 latency > 2× budget / error rate 1–5%)** → Slack `#ops-alerts`, respond within 30 min
+- **P3 (saturation trend / minor degradation)** → Slack `#ops-alerts`, address next business day
+<% if (archetype === 'backend-web-db' || archetype === 'data-pipeline') { %>
+
+### Database Signals
+
+Additional signals for data-store health:
+
+| Signal | Metric | Alert threshold |
+| ---------------- | ------------------- | --------------- |
+| Connection pool | Active / max ratio | > 80% for 5 min |
+| Query latency | p99 query time | > 1 s |
+| Replication lag | Replica offset (ms) | > 500 ms |
+| Disk usage | Storage % | > 75% |
+<% } %><% if (archetype === 'frontend-spa') { %>
+
+### Frontend Signals
+
+Additional signals for client-side health:
+
+| Signal | Metric | Alert threshold |
+| ----------- | --------------- | --------------- |
+| Core Web Vitals | LCP, FID, CLS | LCP > 2.5 s |
+| JS error rate | Uncaught errors | > 0.1% sessions |
+| Bundle size | gzipped bytes | > 10% growth |
+<% } %>
+
+---
+
+## 2. On-Call Protocol
+
+### Escalation Chain
+
+1. **Primary on-call** — first to respond; owns incident until resolved or escalated
+2. **Secondary on-call** — escalated after 15 min without response
+3. **Engineering lead** — escalated for P1 incidents exceeding 30 min MTTR
+4. **Stakeholder notification** — for P1 impacting external users, notify within 60 min
+
+### Incident Lifecycle
+
+```
+Alert fires
+  → Acknowledge (< 5 min for P1)
+  → Diagnose (use runbooks below)
+  → Mitigate (restore service first, root-cause later)
+  → Resolve + post-incident report (within 48 h for P1/P2)
+```
+
+### Communication
+
+- War room: `#incident-<YYYY-MM-DD>` Slack channel (create on P1)
+- Status page: update every 15 min during active P1
+- Post-mortem: blameless, filed within 48 h, linked from incident ticket
+
+---
+
+## 3. Release Candidate Checklist
+
+Run this checklist before every production deploy.
+
+### Pre-Deploy Gates
+
+- [ ] `node scripts/check-all.mjs L2` passes on release branch
+- [ ] All open P1/P2 bugs triaged (none blocking release)
+- [ ] Database migrations tested on staging with production-size dataset
+- [ ] Rollback procedure documented and tested
+- [ ] On-call notified of deploy window
+- [ ] Feature flags set to safe defaults (new features behind flag)
+- [ ] Changelog updated (`CHANGELOG.md` or release notes)
+<% if (archetype === 'backend-web-db') { %>
+- [ ] Load test run against staging (k6 / Gatling) — passes SLA budget
+- [ ] API contract tests pass (Pact / Spring Cloud Contract)
+<% } %><% if (archetype === 'data-pipeline') { %>
+- [ ] Schema migration backward-compatible (old producers/consumers unaffected)
+- [ ] Data backfill plan documented if required
+<% } %>
+
+### Deploy Steps
+
+1. Announce deploy in `#deployments`: `[DEPLOY] <%= projectName %> vX.Y.Z — window: HH:MM–HH:MM UTC`
+2. Tag release: `git tag vX.Y.Z && git push --tags`
+3. Trigger CI deploy pipeline (do not deploy manually)
+4. Monitor dashboards for 15 min post-deploy
+5. Announce completion or rollback in `#deployments`
+
+### Rollback Triggers
+
+Roll back immediately if:
+
+- Error rate exceeds 2% for 2+ minutes post-deploy
+- p95 latency exceeds 2× SLA budget for 5+ minutes
+- Any P1 alert fires within 30 min of deploy
+
+---
+
+## 4. Runbook Library
+
+### Template: Service Degradation
+
+**Symptoms:** p95 latency elevated; error rate rising; alerts firing
+
+**Diagnosis:**
+
+```bash
+# Check recent deployments
+git log --oneline -10
+
+# Check error logs (last 15 min)
+# Replace with your log provider CLI
+grep "ERROR" logs/app.log | tail -100
+
+# Check resource saturation
+# Replace with your monitoring CLI
+```
+
+**Mitigations (in order):**
+
+1. If recent deploy: roll back immediately
+2. Restart affected pods/processes (if stateless)
+3. Scale horizontally if saturation is root cause
+4. Enable circuit-breaker if upstream dependency is failing
+5. Escalate to engineering lead if not resolved within 15 min
+
+---
+<% if (archetype === 'backend-web-db' || archetype === 'data-pipeline') { %>
+
+### Template: Database Issues
+
+**Symptoms:** query latency spike; connection pool exhausted; replication lag
+
+**Diagnosis:**
+
+```bash
+# Check slow queries (PostgreSQL example)
+SELECT query, calls, mean_exec_time
+FROM pg_stat_statements
+ORDER BY mean_exec_time DESC
+LIMIT 10;
+
+# Check connection pool
+SELECT count(*), state FROM pg_stat_activity GROUP BY state;
+```
+
+**Mitigations:**
+
+1. Kill long-running queries blocking others
+2. Scale connection pool if within bounds
+3. Add read replica if replication lag is root cause
+4. Page DBA if escalation required
+
+---
+<% } %>
+
+### Template: Dependency Failure
+
+**Symptoms:** timeouts/errors to external service; circuit-breaker open
+
+**Diagnosis:**
+
+1. Check external service status page
+2. Check network connectivity from service pods
+3. Review circuit-breaker metrics
+
+**Mitigations:**
+
+1. Enable fallback mode (degrade gracefully, disable non-critical features)
+2. Cache last-known-good responses if safe
+3. Notify stakeholders if user-visible
+4. Wait for upstream recovery or escalate to vendor
+
+---
+
+## 5. Capacity Planning
+
+Review quarterly. Trigger immediate review if any metric crosses 70% of limit.
+
+| Resource | Current baseline | 70% trigger | 100% limit | Action at trigger |
+| ---------- | ---------------- | ----------- | ---------- | ----------------------- |
+| CPU | — | 56 cores | 80 cores | Add node or right-size |
+| Memory | — | 56 GB | 80 GB | Add node or right-size |
+| Storage | — | 700 GB | 1 TB | Expand volume |
+| DB connections | — | 140 | 200 | Scale pool or add replica |
+
+_Update this table during each quarterly review._

package/dist/templates/perf/bundle-budget.json.ejs

@@ -0,0 +1,29 @@
+{
+  "$schema": "https://bundlesize.io/schema",
+  "$description": <%- JSON.stringify(`Bundle size budgets for ${projectName}. Generated by arbiter (#1127). Enforced by scripts/check-bundle-size.mjs.`) %>,
+  "budgets": [
+    {
+      "name": "main bundle (JS)",
+      "path": "dist/assets/*.js",
+      "maxSize": "250kb",
+      "maxGzipSize": "75kb"
+    },
+    {
+      "name": "vendor chunk (JS)",
+      "path": "dist/assets/vendor-*.js",
+      "maxSize": "400kb",
+      "maxGzipSize": "120kb"
+    },
+    {
+      "name": "main styles (CSS)",
+      "path": "dist/assets/*.css",
+      "maxSize": "50kb",
+      "maxGzipSize": "12kb"
+    }
+  ],
+  "totals": {
+    "maxTotalJsSize": "600kb",
+    "maxTotalJsGzipSize": "180kb",
+    "maxTotalCssSize": "100kb"
+  }
+}

package/dist/templates/perf/k6/reports/csv-report.py.ejs

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# k6 CSV report generator — flattens k6 summary metrics into tabular CSV (#895)
+import csv
+import json
+import sys
+from pathlib import Path
+from datetime import datetime
+
+RESULTS_DIR = Path("perf/k6/results")
+OUTPUT_FILE = RESULTS_DIR / "k6-report.csv"
+
+FIELDS = [
+    "generated_at",
+    "scenario",
+    "passed",
+    "total_requests",
+    "error_rate",
+    "avg_ms",
+    "min_ms",
+    "med_ms",
+    "max_ms",
+    "p90_ms",
+    "p95_ms",
+    "p99_ms",
+    "thresholds_total",
+    "thresholds_failed",
+]
+
+
+def extract_row(name: str, summary: dict, generated_at: str) -> dict:
+    metrics = summary.get("metrics", {})
+    dur = metrics.get("http_req_duration", {}).get("values", {})
+    failed_rate = metrics.get("http_req_failed", {}).get("values", {}).get("rate", 0)
+    total_reqs = int(metrics.get("http_reqs", {}).get("values", {}).get("count", 0))
+
+    thresholds_total = 0
+    thresholds_failed = 0
+    all_passed = True
+    for metric_val in metrics.values():
+        for passed in metric_val.get("thresholds", {}).values():
+            thresholds_total += 1
+            if not passed:
+                thresholds_failed += 1
+                all_passed = False
+
+    return {
+        "generated_at": generated_at,
+        "scenario": name,
+        "passed": "true" if all_passed else "false",
+        "total_requests": total_reqs,
+        "error_rate": round(failed_rate, 6),
+        "avg_ms": round(dur.get("avg", 0), 2),
+        "min_ms": round(dur.get("min", 0), 2),
+        "med_ms": round(dur.get("med", 0), 2),
+        "max_ms": round(dur.get("max", 0), 2),
+        "p90_ms": round(dur.get("p(90)", 0), 2),
+        "p95_ms": round(dur.get("p(95)", 0), 2),
+        "p99_ms": round(dur.get("p(99)", 0), 2),
+        "thresholds_total": thresholds_total,
+        "thresholds_failed": thresholds_failed,
+    }
+
+
+def main() -> int:
+    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    summaries = list(RESULTS_DIR.glob("*-summary.json"))
+    if not summaries:
+        print("No summary files found in", RESULTS_DIR, file=sys.stderr)
+        return 1
+
+    generated_at = datetime.utcnow().isoformat(timespec="seconds") + "Z"
+    rows = []
+    for path in sorted(summaries):
+        name = path.stem.replace("-summary", "")
+        try:
+            data = json.loads(path.read_text())
+            rows.append(extract_row(name, data, generated_at))
+        except Exception as exc:  # noqa: BLE001
+            print(f"Warning: could not parse {path}: {exc}", file=sys.stderr)
+
+    with OUTPUT_FILE.open("w", newline="") as fh:
+        writer = csv.DictWriter(fh, fieldnames=FIELDS)
+        writer.writeheader()
+        writer.writerows(rows)
+
+    print(f"CSV report written to {OUTPUT_FILE}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/dist/templates/perf/k6/reports/html-report.py.ejs

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+# k6 HTML report generator — reads k6 JSON summary files and emits an HTML report (#895)
+import json
+import os
+import sys
+from pathlib import Path
+from datetime import datetime
+
+RESULTS_DIR = Path("perf/k6/results")
+OUTPUT_FILE = RESULTS_DIR / "k6-report.html"
+
+HTML_TEMPLATE = """<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>k6 Performance Report</title>
+  <style>
+    body {{ font-family: system-ui, sans-serif; margin: 2rem; background: #f8f9fa; }}
+    h1 {{ color: #1a1a2e; }}
+    .scenario {{ background: white; border-radius: 8px; padding: 1.5rem; margin-bottom: 1rem;
+                 box-shadow: 0 2px 4px rgba(0,0,0,0.1); }}
+    .metric {{ display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 0.5rem; margin-top: 1rem; }}
+    .metric-box {{ background: #f0f4ff; border-radius: 4px; padding: 0.5rem; text-align: center; }}
+    .metric-value {{ font-size: 1.5rem; font-weight: bold; color: #3b5bdb; }}
+    .pass {{ color: #2f9e44; }} .fail {{ color: #c92a2a; }}
+    table {{ width: 100%; border-collapse: collapse; margin-top: 1rem; }}
+    th, td {{ padding: 0.5rem; text-align: left; border-bottom: 1px solid #e9ecef; }}
+    th {{ background: #e7f5ff; }}
+  </style>
+</head>
+<body>
+  <h1>k6 Performance Report</h1>
+  <p>Generated: {generated_at}</p>
+  {scenarios_html}
+</body>
+</html>"""
+
+
+def _fmt_ms(val: float) -> str:
+    return f"{val:.1f}ms"
+
+
+def _threshold_status(metrics: dict) -> list[tuple[str, bool]]:
+    results = []
+    for key, val in metrics.items():
+        thresholds = val.get("thresholds", {})
+        for thr_key, passed in thresholds.items():
+            results.append((f"{key} — {thr_key}", passed))
+    return results
+
+
+def render_scenario(name: str, summary: dict) -> str:
+    metrics = summary.get("metrics", {})
+    dur = metrics.get("http_req_duration", {})
+    values = dur.get("values", {})
+    p95 = values.get("p(95)", 0)
+    p99 = values.get("p(99)", 0)
+    avg = values.get("avg", 0)
+    failed = metrics.get("http_req_failed", {}).get("values", {}).get("rate", 0)
+    total_reqs = int(metrics.get("http_reqs", {}).get("values", {}).get("count", 0))
+
+    thresholds = _threshold_status(metrics)
+    all_passed = all(ok for _, ok in thresholds)
+    status_cls = "pass" if all_passed else "fail"
+    status_txt = "PASS" if all_passed else "FAIL"
+
+    thr_rows = "".join(
+        f'<tr><td>{t}</td><td class="{("pass" if ok else "fail")}">'
+        f'{"PASS" if ok else "FAIL"}</td></tr>'
+        for t, ok in thresholds
+    )
+
+    return f"""
+    <div class="scenario">
+      <h2>{name} — <span class="{status_cls}">{status_txt}</span></h2>
+      <div class="metric">
+        <div class="metric-box"><div class="metric-value">{_fmt_ms(avg)}</div>avg latency</div>
+        <div class="metric-box"><div class="metric-value">{_fmt_ms(p95)}</div>p95 latency</div>
+        <div class="metric-box"><div class="metric-value">{_fmt_ms(p99)}</div>p99 latency</div>
+        <div class="metric-box"><div class="metric-value">{total_reqs}</div>total requests</div>
+        <div class="metric-box"><div class="metric-value">{failed*100:.2f}%</div>error rate</div>
+      </div>
+      <table><tr><th>Threshold</th><th>Result</th></tr>{thr_rows}</table>
+    </div>"""
+
+
+def main() -> int:
+    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    summaries = list(RESULTS_DIR.glob("*-summary.json"))
+    if not summaries:
+        print("No summary files found in", RESULTS_DIR, file=sys.stderr)
+        return 1
+
+    scenarios_html = ""
+    for path in sorted(summaries):
+        name = path.stem.replace("-summary", "")
+        try:
+            data = json.loads(path.read_text())
+            scenarios_html += render_scenario(name, data)
+        except Exception as exc:  # noqa: BLE001
+            print(f"Warning: could not parse {path}: {exc}", file=sys.stderr)
+
+    html = HTML_TEMPLATE.format(
+        generated_at=datetime.utcnow().isoformat(timespec="seconds") + "Z",
+        scenarios_html=scenarios_html or "<p>No data available.</p>",
+    )
+    OUTPUT_FILE.write_text(html)
+    print(f"HTML report written to {OUTPUT_FILE}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/dist/templates/perf/k6/reports/json-report.py.ejs

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+# k6 JSON report aggregator — merges k6 summary files into a single structured report (#895)
+import json
+import sys
+from pathlib import Path
+from datetime import datetime
+
+RESULTS_DIR = Path("perf/k6/results")
+OUTPUT_FILE = RESULTS_DIR / "k6-report.json"
+
+
+def extract_scenario_summary(name: str, summary: dict) -> dict:
+    metrics = summary.get("metrics", {})
+    dur = metrics.get("http_req_duration", {}).get("values", {})
+    failed_rate = metrics.get("http_req_failed", {}).get("values", {}).get("rate", 0)
+    total_reqs = int(metrics.get("http_reqs", {}).get("values", {}).get("count", 0))
+
+    thresholds: dict[str, bool] = {}
+    all_passed = True
+    for metric_name, metric_val in metrics.items():
+        for thr_key, passed in metric_val.get("thresholds", {}).items():
+            thresholds[f"{metric_name}:{thr_key}"] = passed
+            if not passed:
+                all_passed = False
+
+    return {
+        "scenario": name,
+        "passed": all_passed,
+        "total_requests": total_reqs,
+        "error_rate": round(failed_rate, 6),
+        "latency_ms": {
+            "avg": round(dur.get("avg", 0), 2),
+            "min": round(dur.get("min", 0), 2),
+            "med": round(dur.get("med", 0), 2),
+            "max": round(dur.get("max", 0), 2),
+            "p90": round(dur.get("p(90)", 0), 2),
+            "p95": round(dur.get("p(95)", 0), 2),
+            "p99": round(dur.get("p(99)", 0), 2),
+        },
+        "thresholds": thresholds,
+    }
+
+
+def main() -> int:
+    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    summaries = list(RESULTS_DIR.glob("*-summary.json"))
+    if not summaries:
+        print("No summary files found in", RESULTS_DIR, file=sys.stderr)
+        return 1
+
+    scenarios = []
+    for path in sorted(summaries):
+        name = path.stem.replace("-summary", "")
+        try:
+            data = json.loads(path.read_text())
+            scenarios.append(extract_scenario_summary(name, data))
+        except Exception as exc:  # noqa: BLE001
+            print(f"Warning: could not parse {path}: {exc}", file=sys.stderr)
+
+    overall_passed = all(s["passed"] for s in scenarios)
+    report = {
+        "generated_at": datetime.utcnow().isoformat(timespec="seconds") + "Z",
+        "overall_passed": overall_passed,
+        "scenario_count": len(scenarios),
+        "scenarios": scenarios,
+    }
+
+    OUTPUT_FILE.write_text(json.dumps(report, indent=2))
+    print(f"JSON report written to {OUTPUT_FILE}")
+    return 0 if overall_passed else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/dist/templates/perf/k6/scenarios/breakpoint.js.ejs

@@ -0,0 +1,26 @@
+// k6 breakpoint test — ramp up until the system breaks (#895)
+import { check, sleep } from 'k6'
+import http from 'k6/http'
+
+export const options = {
+  executor: 'ramping-arrival-rate',
+  stages: [
+    { duration: '2h', target: 20000 },
+  ],
+  preAllocatedVUs: 1000,
+  maxVUs: 5000,
+  thresholds: {
+    // intentionally lenient — goal is to find the limit, not pass SLA
+    http_req_failed: ['rate<0.5'],
+  },
+}
+
+const BASE_URL = __ENV.K6_BASE_URL || 'http://localhost:8080'
+
+export default function () {
+  const res = http.get(`${BASE_URL}/api/v1/resource`)
+  check(res, {
+    'responded': (r) => r.status > 0,
+  })
+  sleep(0.1)
+}

package/dist/templates/perf/k6/scenarios/burst.js.ejs

@@ -0,0 +1,43 @@
+// k6 burst test — short bursts of extreme traffic followed by idle periods (#895)
+import { check, sleep } from 'k6'
+import http from 'k6/http'
+
+export const options = {
+  scenarios: {
+    burst: {
+      executor: 'ramping-vus',
+      stages: [
+        // Burst 1
+        { duration: '10s', target: 500 },
+        { duration: '30s', target: 500 },
+        { duration: '10s', target: 10 },
+        // Idle
+        { duration: '1m', target: 10 },
+        // Burst 2
+        { duration: '10s', target: 500 },
+        { duration: '30s', target: 500 },
+        { duration: '10s', target: 10 },
+        // Idle
+        { duration: '1m', target: 10 },
+        // Burst 3
+        { duration: '10s', target: 500 },
+        { duration: '30s', target: 500 },
+        { duration: '10s', target: 0 },
+      ],
+    },
+  },
+  thresholds: {
+    http_req_failed: ['rate<0.05'],
+    http_req_duration: ['p(95)<1500'],
+  },
+}
+
+const BASE_URL = __ENV.K6_BASE_URL || 'http://localhost:8080'
+
+export default function () {
+  const res = http.get(`${BASE_URL}/api/v1/resource`)
+  check(res, {
+    'status is 2xx or 429': (r) => (r.status >= 200 && r.status < 300) || r.status === 429,
+  })
+  sleep(0.5)
+}

package/dist/templates/perf/k6/scenarios/endurance.js.ejs

@@ -0,0 +1,36 @@
+// k6 endurance test — 24-hour sustained load to detect slow degradation (#895)
+import { check, sleep } from 'k6'
+import http from 'k6/http'
+import { Counter, Trend } from 'k6/metrics'
+
+const degradation = new Trend('response_time_trend', true)
+const slowRequests = new Counter('slow_requests')
+
+export const options = {
+  stages: [
+    { duration: '5m', target: 30 },
+    { duration: '23h50m', target: 30 },
+    { duration: '5m', target: 0 },
+  ],
+  thresholds: {
+    http_req_failed: ['rate<0.01'],
+    http_req_duration: ['p(95)<600'],
+    response_time_trend: ['p(95)<600'],
+    slow_requests: ['count<100'],
+  },
+}
+
+const BASE_URL = __ENV.K6_BASE_URL || 'http://localhost:8080'
+
+export default function () {
+  const res = http.get(`${BASE_URL}/api/v1/resource`)
+  degradation.add(res.timings.duration)
+  if (res.timings.duration > 500) {
+    slowRequests.add(1)
+  }
+  check(res, {
+    'status is 200': (r) => r.status === 200,
+    'no degradation > 500ms': (r) => r.timings.duration < 500,
+  })
+  sleep(2)
+}

package/dist/templates/perf/k6/scenarios/load.js.ejs

@@ -0,0 +1,26 @@
+// k6 load test — normal expected load (#895)
+import { check, sleep } from 'k6'
+import http from 'k6/http'
+
+export const options = {
+  stages: [
+    { duration: '2m', target: 50 },
+    { duration: '5m', target: 50 },
+    { duration: '2m', target: 0 },
+  ],
+  thresholds: {
+    http_req_failed: ['rate<0.01'],
+    http_req_duration: ['p(95)<500', 'p(99)<1500'],
+  },
+}
+
+const BASE_URL = __ENV.K6_BASE_URL || 'http://localhost:8080'
+
+export default function () {
+  const res = http.get(`${BASE_URL}/api/v1/resource`)
+  check(res, {
+    'status is 200 or 204': (r) => r.status === 200 || r.status === 204,
+    'response time < 500ms': (r) => r.timings.duration < 500,
+  })
+  sleep(1)
+}

package/dist/templates/perf/k6/scenarios/ramp-down.js.ejs

@@ -0,0 +1,29 @@
+// k6 ramp-down test — decrease load gradually to verify graceful scale-down (#895)
+import { check, sleep } from 'k6'
+import http from 'k6/http'
+
+export const options = {
+  stages: [
+    { duration: '30s', target: 100 },
+    { duration: '1m', target: 90 },
+    { duration: '1m', target: 70 },
+    { duration: '1m', target: 50 },
+    { duration: '1m', target: 30 },
+    { duration: '1m', target: 10 },
+    { duration: '30s', target: 0 },
+  ],
+  thresholds: {
+    http_req_failed: ['rate<0.01'],
+    http_req_duration: ['p(95)<500'],
+  },
+}
+
+const BASE_URL = __ENV.K6_BASE_URL || 'http://localhost:8080'
+
+export default function () {
+  const res = http.get(`${BASE_URL}/api/v1/resource`)
+  check(res, {
+    'status is 200': (r) => r.status === 200,
+  })
+  sleep(1)
+}