Files

275 lines
9.2 KiB
Go

// Open-loop HTTP load generator for track 1 (stdlib only, Go 1.22+).
//
// Сценарий: N синтетических пользователей, у каждого свой чат с историей; смесь запросов через LB:
// GET истории (limit=50), POST сообщения (уникальный Idempotency-Key), GET /users/me.
// Модель — открытая: запросы запускаются по расписанию (rate req/s) независимо от ответов;
// задержка считается ОТ ЗАПЛАНИРОВАННОГО момента отправки (без coordinated omission).
// Вывод — JSON-строки в stdout: {"event":"step",...} на каждую ступень rate. Токены не печатаются.
package main
import (
"bytes"
"crypto/rand"
"encoding/base64"
"encoding/hex"
"encoding/json"
"flag"
"fmt"
"io"
"math"
"net/http"
"os"
"sort"
"strconv"
"strings"
"sync"
"sync/atomic"
"time"
)
type actor struct {
token, chat string
}
var (
target = flag.String("target", "http://lb:8080", "LB base URL")
nUsers = flag.Int("users", 64, "synthetic users (one chat each)")
seed = flag.Int("seed", 30, "messages per chat before measuring")
rates = flag.String("rates", "100,200,300", "comma-separated request rates (req/s)")
duration = flag.Duration("duration", 15*time.Second, "measured time per step")
warmup = flag.Duration("warmup", 3*time.Second, "unmeasured time per step at the same rate")
mixFlag = flag.String("mix", "history=70,post=20,me=10", "request mix, percent")
timeout = flag.Duration("timeout", 5*time.Second, "client timeout per request")
maxIn = flag.Int("maxinflight", 4000, "in-flight cap; above it a request is counted as dropped")
label = flag.String("label", "", "free-form label copied into output")
stopErr = flag.Float64("stoperr", 0.3, "stop the sweep after 2 consecutive steps with error ratio above this")
)
var client, setupClient *http.Client
func rnd(n int) string {
b := make([]byte, n)
_, _ = rand.Read(b)
return hex.EncodeToString(b)
}
func do(method, path string, body []byte, hdr map[string]string) (int, []byte, error) {
return doWith(client, method, path, body, hdr)
}
func doWith(c *http.Client, method, path string, body []byte, hdr map[string]string) (int, []byte, error) {
req, err := http.NewRequest(method, *target+path, bytes.NewReader(body))
if err != nil {
return 0, nil, err
}
if body != nil {
req.Header.Set("Content-Type", "application/json")
}
for k, v := range hdr {
req.Header.Set(k, v)
}
resp, err := c.Do(req)
if err != nil {
return 0, nil, err
}
defer resp.Body.Close()
data, err := io.ReadAll(resp.Body)
return resp.StatusCode, data, err
}
func must(want int, what, method, path string, body []byte, hdr map[string]string) []byte {
code, data, err := doWith(setupClient, method, path, body, hdr) // KDF медленный: отдельный таймаут
if err != nil || code != want {
fmt.Fprintf(os.Stderr, "setup %s failed: code=%d err=%v\n", what, code, err)
os.Exit(2)
}
return data
}
func setup() []actor {
actors := make([]actor, *nUsers)
var wg sync.WaitGroup
sem := make(chan struct{}, 4)
for i := range actors {
wg.Add(1)
go func(i int) {
defer wg.Done()
sem <- struct{}{}
defer func() { <-sem }()
user, pw := "lg_"+rnd(6), "Lg-"+rnd(12)
b, _ := json.Marshal(map[string]string{"username": user, "display_name": "load " + strconv.Itoa(i), "password": pw})
var u struct{ ID string }
_ = json.Unmarshal(must(201, "user", "POST", "/api/v1/users", b, nil), &u)
basic := "Basic " + base64.StdEncoding.EncodeToString([]byte(user+":"+pw))
var s struct{ Token string }
_ = json.Unmarshal(must(201, "login", "POST", "/api/v1/auth/sessions", nil, map[string]string{"Authorization": basic}), &s)
auth := map[string]string{"Authorization": "Bearer " + s.Token}
cb, _ := json.Marshal(map[string]any{"title": "load", "member_ids": []string{u.ID}})
var c struct{ ID string }
_ = json.Unmarshal(must(201, "chat", "POST", "/api/v1/chats", cb, auth), &c)
for k := 0; k < *seed; k++ {
auth["Idempotency-Key"] = rnd(8)
mb, _ := json.Marshal(map[string]string{"text": "seed " + strconv.Itoa(k)})
must(201, "seed", "POST", "/api/v1/chats/"+c.ID+"/messages", mb, auth)
}
actors[i] = actor{token: s.Token, chat: c.ID}
}(i)
}
wg.Wait()
return actors
}
type sample struct {
op int
latency time.Duration // от запланированного момента
service time.Duration // от фактической отправки
status int
}
func pct(v []float64, p float64) float64 {
if len(v) == 0 {
return math.NaN()
}
i := int(math.Ceil(p*float64(len(v)))) - 1
if i < 0 {
i = 0
}
return math.Round(v[i]*100) / 100
}
func main() {
flag.Parse()
client = &http.Client{Timeout: *timeout, Transport: &http.Transport{
MaxIdleConns: 10000, MaxIdleConnsPerHost: 10000, IdleConnTimeout: 30 * time.Second, DisableCompression: true,
}}
setupClient = &http.Client{Timeout: 60 * time.Second}
ops := []string{"history", "post", "me"}
weights := map[string]int{}
for _, part := range strings.Split(*mixFlag, ",") {
kv := strings.SplitN(part, "=", 2)
w, _ := strconv.Atoi(kv[1])
weights[kv[0]] = w
}
var wheel []int
for i, op := range ops {
for k := 0; k < weights[op]; k++ {
wheel = append(wheel, i)
}
}
t0 := time.Now()
actors := setup()
setupSec := time.Since(t0).Seconds()
_ = json.NewEncoder(os.Stdout).Encode(map[string]any{"event": "setup", "label": *label, "users": len(actors), "seed": *seed, "seconds": setupSec})
bad := 0
for _, rs := range strings.Split(*rates, ",") {
if bad >= 2 {
break
}
rate, _ := strconv.ParseFloat(strings.TrimSpace(rs), 64)
var mu sync.Mutex
var samples []sample
var inflight, dropped, errs int64
errKinds := map[string]int{}
total := *warmup + *duration
interval := time.Duration(float64(time.Second) / rate)
start := time.Now().Add(50 * time.Millisecond)
measureFrom := start.Add(*warmup)
_ = json.NewEncoder(os.Stdout).Encode(map[string]any{"event": "step_start", "label": *label, "rate": rate,
"warmup_s": warmup.Seconds(), "duration_s": duration.Seconds(), "ts": float64(start.UnixNano()) / 1e9})
var wg sync.WaitGroup
for i := 0; ; i++ {
sched := start.Add(time.Duration(i) * interval)
if sched.Sub(start) >= total {
break
}
if d := time.Until(sched); d > 0 {
time.Sleep(d)
}
measured := !sched.Before(measureFrom)
if atomic.LoadInt64(&inflight) >= int64(*maxIn) {
if measured {
atomic.AddInt64(&dropped, 1)
}
continue
}
atomic.AddInt64(&inflight, 1)
wg.Add(1)
a := actors[i%len(actors)]
op := wheel[i%len(wheel)]
go func(a actor, op int, sched time.Time, measured bool) {
defer wg.Done()
defer atomic.AddInt64(&inflight, -1)
hdr := map[string]string{"Authorization": "Bearer " + a.token}
var code int
var err error
sent := time.Now()
switch op {
case 0:
code, _, err = do("GET", "/api/v1/chats/"+a.chat+"/messages?limit=50", nil, hdr)
case 1:
hdr["Idempotency-Key"] = rnd(8)
code, _, err = do("POST", "/api/v1/chats/"+a.chat+"/messages", []byte(`{"text":"load message"}`), hdr)
case 2:
code, _, err = do("GET", "/api/v1/users/me", nil, hdr)
}
done := time.Now()
if !measured {
return
}
want := 200
if op == 1 {
want = 201
}
mu.Lock()
defer mu.Unlock()
if err != nil || code != want {
errs++
k := strconv.Itoa(code)
if err != nil {
k = "transport"
if strings.Contains(err.Error(), "Timeout") || strings.Contains(err.Error(), "deadline") {
k = "timeout"
}
}
errKinds[k]++
return
}
samples = append(samples, sample{op, done.Sub(sched), done.Sub(sent), code})
}(a, op, sched, measured)
}
wg.Wait()
lat := make([]float64, 0, len(samples))
svc := make([]float64, 0, len(samples))
perOp := map[string][]float64{}
for _, s := range samples {
ms := float64(s.latency.Microseconds()) / 1000
lat = append(lat, ms)
svc = append(svc, float64(s.service.Microseconds())/1000)
perOp[ops[s.op]] = append(perOp[ops[s.op]], ms)
}
sort.Float64s(lat)
sort.Float64s(svc)
opStats := map[string]any{}
for k, v := range perOp {
sort.Float64s(v)
opStats[k] = map[string]any{"ok": len(v), "p50_ms": pct(v, .5), "p99_ms": pct(v, .99)}
}
attempted := float64(len(samples)) + float64(errs) + float64(dropped)
if (float64(errs)+float64(dropped))/math.Max(attempted, 1) > *stopErr {
bad++
} else {
bad = 0
}
_ = json.NewEncoder(os.Stdout).Encode(map[string]any{
"event": "step", "label": *label, "rate": rate, "duration_s": duration.Seconds(),
"attempted": attempted, "ok": len(samples), "errors": errs, "dropped": dropped, "error_kinds": errKinds,
"throughput_ok_rps": math.Round(float64(len(samples))/duration.Seconds()*10) / 10,
"error_ratio": math.Round((float64(errs)+float64(dropped))/math.Max(attempted, 1)*1e4) / 1e4,
"latency_ms": map[string]float64{"p50": pct(lat, .5), "p90": pct(lat, .9), "p99": pct(lat, .99), "p999": pct(lat, .999), "max": pct(lat, 1)},
"service_ms": map[string]float64{"p50": pct(svc, .5), "p99": pct(svc, .99)},
"per_op": opStats,
})
}
}