AGENT SKILL

k6-load-testing

Invoke this skill when the task is to validate that the system sustains its SLOs at **realistic production throughput over time** — including endurance (soak) testing for memory leaks, connection pool exhaustion, and GC pressure.

使用场景测试与质量
License 许可
GPL-3.0
最近更新
2026-06-06
Stars
★ 0
Forks
0

01 前言 Front Matter

name
k6-load-testing
description
Invoke this skill when the task is to validate that the system sustains its SLOs at **realistic production throughput over time** — including endurance (soak) testing for memory leaks, connection pool exhaustion, and GC pressure.

03 SKILL.md 正文

k6 Load Testing

When to Use

Invoke this skill when the task is to validate that the system sustains its SLOs at realistic production throughput over time — including endurance (soak) testing for memory leaks, connection pool exhaustion, and GC pressure.

This skill covers:

  • Average-load tests: validate SLOs at expected normal traffic (use for regression gates)
  • Soak / endurance tests: validate reliability under sustained load for hours
  • Multi-scenario weighted load: model realistic endpoint traffic mixes

For above-normal load, use k6-stress-testing. For basic smoke/baseline validation, use k6-performance-testing.

Always run in this order: smoke → average-load → stress → soak. Never run a soak test on a system that hasn't first passed average-load and stress.

Executor Selection

Executor Model When to Use
constant-vus Closed Specific concurrent user count; throughput varies with latency
constant-arrival-rate Open Fixed RPS regardless of response time. Preferred for REST API load tests
per-vu-iterations Closed Partition fixed test data across VUs (each VU processes its own slice)

Prefer constant-arrival-rate for REST API load tests. In closed models, slow responses reduce RPS invisibly — the system appears healthy while throughput degrades.

Constant Arrival Rate Load Test (REST API)

import http from 'k6/http';
import { check, sleep } from 'k6';
import { SharedArray } from 'k6/data';

const users = new SharedArray('users', function () {
  return JSON.parse(open('./test-data/users.json'));
});

export const options = {
  scenarios: {
    constant_load: {
      executor: 'constant-arrival-rate',
      rate: 50,                 // 50 iterations per second
      timeUnit: '1s',
      duration: '10m',
      preAllocatedVUs: 20,      // initial VU pool
      maxVUs: 100,              // hard ceiling
    },
  },
  thresholds: {
    http_req_failed:   ['rate<0.01'],          // <1% error rate
    http_req_duration: [
      'p(90)<400',
      'p(95)<800',
      'p(99)<2000',
    ],
    http_req_waiting:  ['p(95)<600'],          // TTFB SLO
    checks:            ['rate>0.99'],
    dropped_iterations: ['count<10'],          // near-zero tolerance for dropped iterations
  },
};

export default function () {
  const user = users[Math.floor(Math.random() * users.length)];
  const res = http.get(`${__ENV.BASE_URL}/api/items`, {
    headers: { Authorization: `Bearer ${user.token}` },
    tags: { endpoint: 'list-items' },
  });
  check(res, {
    'status 200':       (r) => r.status === 200,
    'response < 800ms': (r) => r.timings.duration < 800,
  });
  // Do NOT add sleep() with constant-arrival-rate — pacing is controlled by `rate`/`timeUnit`
}

Soak / Endurance Test

export const options = {
  stages: [
    { duration: '5m',  target: 100 }, // ramp-up
    { duration: '8h',  target: 100 }, // endurance plateau (adjust to 3–72h based on requirements)
    { duration: '5m',  target: 0   }, // ramp-down
  ],
  thresholds: {
    http_req_failed:   ['rate<0.01'],
    http_req_duration: [
      'p(95)<800',
      { threshold: 'p(99)<2000', abortOnFail: true, delayAbortEval: '60s' },
    ],
  },
};

Soak test minimum durations (from k6 official guidance):

  • Minimum useful: 3–4 hours
  • Standard: 8–12 hours
  • Extended: 24–72 hours

What to watch for in .NET during soak:

  • http_req_duration p99 trending upward continuously (memory leak / GC pressure)
  • http_req_failed rate climbing over time (degrading reliability)
  • dropped_iterations counter growing (open model only — indicates saturation)
  • Gen 2 GC collection rate increasing (monitor via Application Insights / dotnet-counters)
  • Thread pool queue length increasing (connection pool exhaustion)

Multi-Scenario Weighted Load (Realistic Traffic Mix)

import http from 'k6/http';

export const options = {
  scenarios: {
    // 70% of load: read endpoint at 70 RPS
    list_items: {
      executor: 'constant-arrival-rate',
      rate: 70, timeUnit: '1s', duration: '10m',
      preAllocatedVUs: 20, maxVUs: 100,
      exec: 'listItems',
      tags: { endpoint: 'list' },
    },
    // 20% of load: write endpoint at 20 RPS
    create_item: {
      executor: 'constant-arrival-rate',
      rate: 20, timeUnit: '1s', duration: '10m',
      preAllocatedVUs: 10, maxVUs: 50,
      exec: 'createItem',
      tags: { endpoint: 'create' },
    },
    // 10% of load: auth endpoint at 10 RPS
    authenticate: {
      executor: 'constant-arrival-rate',
      rate: 10, timeUnit: '1s', duration: '10m',
      preAllocatedVUs: 5, maxVUs: 20,
      exec: 'authenticate',
      tags: { endpoint: 'auth' },
    },
  },
  thresholds: {
    'http_req_duration{endpoint:list}':     ['p(95)<200'],
    'http_req_duration{endpoint:create}':   ['p(95)<500'],
    'http_req_duration{endpoint:auth}':     ['p(95)<300'],
    'http_req_failed':                       ['rate<0.01'],
  },
};

export function listItems() {
  http.get(`${__ENV.BASE_URL}/api/items`);
}

export function createItem() {
  http.post(`${__ENV.BASE_URL}/api/items`, JSON.stringify({ name: 'test' }), {
    headers: { 'Content-Type': 'application/json' },
  });
}

export function authenticate() {
  http.post(`${__ENV.BASE_URL}/api/auth/token`,
    JSON.stringify({ username: 'testuser', password: 'testpass' }),
    { headers: { 'Content-Type': 'application/json' } });
}

export default function () { /* not used when scenarios define exec */ }

Key Load Test Metrics

Metric Type Use For
http_reqs Counter Throughput — N/s in summary = actual RPS
http_req_duration Trend Primary SLO: check p90/p95/p99
http_req_waiting Trend TTFB — server-side processing time
http_req_failed Rate Error rate / error budget
http_req_blocked Trend TCP connection pool exhaustion signal
data_sent / data_received Counter Bandwidth / payload size
vus_max Gauge If equals maxVUs, executor was constrained
dropped_iterations Counter Non-zero = system or VU pool couldn't keep up
checks Rate Functional correctness under load

Throughput formula: RPS = http_reqs.count / test_duration_seconds

SLO Thresholds for .NET REST APIs

Starting point (adjust from production APM data):

thresholds: {
  http_req_failed:   ['rate<0.01'],           // 99.0% success SLO
  http_req_duration: [
    'p(90)<400',    // 90th percentile
    'p(95)<800',    // 95th percentile (primary SLO)
    'p(99)<2000',   // 99th — allows for .NET GC pauses
  ],
  http_req_waiting:  ['p(95)<600'],           // TTFB guard
  checks:            ['rate>0.99'],           // functional correctness
  // Throughput floor
  'http_reqs':       ['rate>50'],             // minimum 50 RPS required
}

Error budget guidance:

  • Mission-critical APIs: < 0.1% error rate
  • Standard APIs: < 1% error rate
  • Health endpoints: p99 < 50ms; error rate < 0.01%

SharedArray for Large Test Data

import { SharedArray } from 'k6/data';

// Parsed ONCE — shared read-only across all VUs (critical for large datasets)
const users = new SharedArray('test-users', function () {
  return JSON.parse(open('./users.json'));
});

// At 100k rows: SharedArray ≈ 250MB vs non-shared ≈ 9GB
export default function () {
  const user = users[Math.floor(Math.random() * users.length)];
  http.get(`${__ENV.BASE_URL}/api/profile/${user.id}`);
}

SharedArray rules:

  • All processing (filtering, mapping) must happen inside the constructor callback
  • Never call .filter() / .map() on a SharedArray outside the constructor
  • Never return a SharedArray from setup() — causes marshalling, loses benefits
  • Open the file inside the constructor, not at the top level

GitHub Actions CI/CD Integration

name: Load Tests
on:
  push:
    branches: [main]
  schedule:
    - cron: '0 2 * * *'  # nightly regression run

jobs:
  load-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup k6
        uses: grafana/setup-k6-action@v1
        with:
          k6-version: '0.56.0'   # pin for reproducibility

      - name: Run load tests
        uses: grafana/run-k6-action@v1
        with:
          path: ./tests/load/*.js
          flags: >-
            --out json=results/k6-output.json
            --env BASE_URL=${{ vars.API_BASE_URL }}
            --summary-trend-stats="avg,min,med,max,p(90),p(95),p(99)"
          fail-fast: true

      - name: Upload results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: k6-load-test-results
          path: results/
          retention-days: 30

Important: Use grafana/setup-k6-action@v1 + grafana/run-k6-action@v1. Do NOT use the archived grafana/k6-action (deprecated July 2024).

Exit code behavior: k6 exits 99 when any threshold fails → GitHub Actions step fails automatically. No extra YAML needed.

Interpreting the End-of-Test Summary

█ THRESHOLDS
  http_req_duration
    ✓ 'p(95)<800'    p(95)=148ms      ← PASSED
    ✗ 'p(99)<2000'   p(99)=2523ms     ← FAILED → exit 99

█ TOTAL RESULTS
  http_req_duration...: avg=140ms  min=119ms  med=140ms  max=2523ms  p(90)=180ms  p(95)=148ms  p(99)=2523ms
  http_req_failed.....: 0.00%
  http_reqs...........: 5000 8.3/s         ← actual throughput vs target
  vus_max.............: 20   min=5   max=20 ← if near maxVUs, executor was constrained
  dropped_iterations..: 0                   ← non-zero = saturation signal

Field guide:

  • avg >> med → high-latency outliers present; investigate p99
  • http_reqs N/s → compare to target arrival rate; divergence = saturation
  • vus_max == maxVUs → VU pool was constrained; increase maxVUs or reduce load
  • dropped_iterations > 0 → system cannot sustain target rate at maxVUs
  • iteration_duration gap vs http_req_duration → the gap is think time + overhead

Sources

04 同仓库更多 Skills

rafsanulhasan
rafsanulhasan/HypermediaEngine

write-tests

Test implementation skill for HypermediaEngine. Takes a confirmed test plan from design-test-cases and produces compilable, runnable xUnit tests following project conventions. Validates coverage quality through mutation testing. Invoked by the sqa-engineer agent after the test plan is approved.

测试与质量
★ 0
rafsanulhasan
rafsanulhasan/HypermediaEngine

write-documentation

Structured documentation writing workflow for HypermediaEngine. Writes or updates README.md files at the repo root and in each project directory (src/, tests/, samples/, etc.) based on current implementation, ADRs, and architecture decisions.

★ 0
rafsanulhasan
rafsanulhasan/HypermediaEngine

write-adr

Writes a numbered Architecture Decision Record (ADR) for a significant architectural choice in the HypermediaEngine project. Invoked by the software-architect agent whenever a consequential design decision is made or ratified. Saves the ADR to docs/architecture/decisions/.

★ 0
rafsanulhasan
rafsanulhasan/HypermediaEngine

tunit-playwright-ui-testing

Comprehensive guidance for writing coded end-to-end UI tests in C# using TUnit.Playwright. Tests inherit from PageTest — the base class manages all browser lifecycle. Covers NuGet setup, PageTest inheritance, Page Object Model, browser configuration, parallelism limiting, and CI integration. Based on the official TUnit docs at https://tunit.dev/docs/examples/playwright.

设计师测试与质量
★ 0
rafsanulhasan
rafsanulhasan/HypermediaEngine

triage

Task classification, decomposition, dependency mapping, and routing skill. Invoked by the triage-agent to break any user request into discrete, independently-routable work items with assigned priorities and agent chains.

Skill与智能体开发
★ 0
rafsanulhasan
rafsanulhasan/HypermediaEngine

system-design

Expert system design skill. Use PROACTIVELY to design systems, review architectures, and assist software engineers in learning design principles and implementing them in the code with design patterns.

设计师视觉设计
★ 0