LPT Project
Setup Roadmap

System under Test:
Business Owner / Tech Owner:
Entry point(s) and protocol:
Included services and versions:
Excluded dependencies and simulation method:

Journey: [name]
  Client start/end boundary:
  Synchronous calls:
  Async events / queues:
  Cache state and expected hit ratio:
  Database entities, volume, and query patterns:
  Timeouts, retries, rate limits:
  Metrics, logs, traces, dashboard links:

Known capacity limits / maintenance windows:
Unverified assumptions / owner / due date:

import http from 'k6/http';
import { check } from 'k6';

const baseUrl = __ENV.BASE_URL;
const token = __ENV.TEST_TOKEN;

export const options = {
  scenarios: {
    checkout: {
      executor: 'constant-arrival-rate',
      rate: Number(__ENV.RATE || 10),
      timeUnit: '1s',
      duration: __ENV.DURATION || '3m',
      preAllocatedVUs: 20,
      maxVUs: 80,
    },
  },
  thresholds: {
    http_req_failed: ['rate<0.005'],
    http_req_duration: ['p(95)<400', 'p(99)<900'],
    dropped_iterations: ['count==0'],
  },
};

export default function () {
  const response = http.post(`${baseUrl}/api/checkout`,
    JSON.stringify({ sku: __ENV.SKU, quantity: 1 }),
    { headers: { Authorization: `Bearer ${token}`,
      'Content-Type': 'application/json' }, tags: { name: 'checkout' } });
  check(response, { 'created order': (r) => r.status === 201 });
}

mkdir -p artifacts
export LPT_RUN_ID="build-1842-$(date -u +%Y%m%dT%H%M%SZ)"
jmeter -n -t tests/checkout.jmx \
  -JbaseUrl="$BASE_URL" -JrunId="$LPT_RUN_ID" \
  -Jusers=80 -Jramp=120 -Jduration=900 \
  -l artifacts/results.jtl

import csv
import os
import sqlite3
from datetime import datetime, timezone
from pathlib import Path

RUN_ID = os.environ["LPT_RUN_ID"]
JTL_PATH = Path("artifacts/results.jtl")
TRANSACTIONS = {"Login", "Browse catalog", "Checkout transaction"}

db = sqlite3.connect("artifacts/lpt-results.sqlite")
db.execute("""CREATE TABLE IF NOT EXISTS samples (
  sample_id INTEGER PRIMARY KEY, run_id TEXT NOT NULL, transaction_name TEXT NOT NULL,
  timestamp_utc TEXT NOT NULL, elapsed_ms INTEGER NOT NULL,
  success INTEGER NOT NULL, response_code TEXT
)""")

records = []
with JTL_PATH.open(newline="", encoding="utf-8") as source:
    for row in csv.DictReader(source):
        if row["label"] not in TRANSACTIONS:
            continue  # Setup-, Teardown- und technische Sampler ausfiltern
        stamp = datetime.fromtimestamp(
            int(row["timeStamp"]) / 1000, tz=timezone.utc
        ).isoformat()
        records.append((RUN_ID, row["label"], stamp,
                        int(row["elapsed"]),
                        int(row["success"].lower() == "true"),
                        row.get("responseCode", "")))

with db:
  db.execute("DELETE FROM samples WHERE run_id = ?", (RUN_ID,))
  db.executemany("""INSERT INTO samples
      (run_id, transaction_name, timestamp_utc, elapsed_ms, success, response_code)
      VALUES (?, ?, ?, ?, ?, ?)""", records)
db.close()
print(f"{RUN_ID}: {len(records)} Transaktionssamples gespeichert")

import os
from pathlib import Path
import requests

base = os.environ["GRAFANA_URL"].rstrip("/")
token = os.environ["GRAFANA_SERVICE_TOKEN"]
dashboard = os.environ["GRAFANA_DASHBOARD_UID"]
run_id = os.environ["LPT_RUN_ID"]
start_ms = os.environ["RUN_START_MS"]
end_ms = os.environ["RUN_END_MS"]

response = requests.get(
    f"{base}/render/d/{dashboard}/lpt-run",
    params={"from": start_ms, "to": end_ms,
            "var-run_id": run_id, "width": 1600, "height": 1000},
    headers={"Authorization": f"Bearer {token}"}, timeout=90)
response.raise_for_status()
artifact = Path("artifacts") / f"grafana-{run_id}.png"
artifact.parent.mkdir(parents=True, exist_ok=True)
artifact.write_bytes(response.content)
print(f"Dashboard-Snapshot: {artifact}")

Run ID / Build / Skript-Commit:
Zielumgebung / Datenstand / Generator:
Testart / Zeitraum / angebotene Rate:
Ergebnis: PASS | PASS WITH FINDINGS | FAIL
SLI: Durchsatz ___/s · Fehlerquote ___ · P95 ___ ms · P99 ___ ms
Generator: VUs ___ · dropped iterations ___
Top-Befund / Nutzerwirkung:
Engpassbeleg: Dashboard / Trace / Query-Plan / Hostsignal
Abweichung zur Baseline:
Risiken und bekannte Einschränkungen:
Entscheidung / Owner / nächster Schritt: