From 57ef2bd0e31d4d74c73641fce036f32ca5fc85d2 Mon Sep 17 00:00:00 2001 From: Omid Mirzaei Date: Fri, 18 Sep 2026 13:51:50 +0400 Subject: [PATCH 1/4] refuse Railway URLs on the credit-once soak --- internal/soak/url.go | 14 ++++++++++++++ internal/soak/url_test.go | 16 ++++++++++++++++ 2 files changed, 30 insertions(+) create mode 100644 internal/soak/url.go create mode 100644 internal/soak/url_test.go diff --git a/internal/soak/url.go b/internal/soak/url.go new file mode 100644 index 0000000..42525b9 --- /dev/null +++ b/internal/soak/url.go @@ -0,0 +1,14 @@ +package soak + +import ( + "fmt" + "strings" +) + +func GuardURL(raw string) error { + lower := strings.ToLower(raw) + if strings.Contains(lower, "railway.app") || strings.Contains(lower, "up.railway") { + return fmt.Errorf("refuse hosted Railway URL %s; soak is local only", raw) + } + return nil +} diff --git a/internal/soak/url_test.go b/internal/soak/url_test.go new file mode 100644 index 0000000..6e95638 --- /dev/null +++ b/internal/soak/url_test.go @@ -0,0 +1,16 @@ +package soak + +import "testing" + +func TestGuardURLAllowsLocal(t *testing.T) { + if err := GuardURL("http://127.0.0.1:8080"); err != nil { + t.Fatal(err) + } +} + +func TestGuardURLRefusesRailway(t *testing.T) { + err := GuardURL("https://api-production-2ef9b.up.railway.app") + if err == nil { + t.Fatal("expected error") + } +} From c2153b2e533d8a11b2f654c36658d2b8f903b9d5 Mon Sep 17 00:00:00 2001 From: Omid Mirzaei Date: Fri, 18 Sep 2026 13:51:57 +0400 Subject: [PATCH 2/4] send unique deposits then duplicate deliveries --- Makefile | 6 +- cmd/soak/main.go | 200 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 205 insertions(+), 1 deletion(-) create mode 100644 cmd/soak/main.go diff --git a/Makefile b/Makefile index 7f1b65f..e18def2 100644 --- a/Makefile +++ b/Makefile @@ -1,8 +1,9 @@ -.PHONY: build run fmt vet test up down logs migrate seed loadgen demo replay replay-kafka rulepatch shadow +.PHONY: build run fmt vet test up down logs migrate seed loadgen soak demo replay replay-kafka rulepatch shadow build: go build -o bin/engagepulse ./cmd/engagepulse go build -o bin/loadgen ./cmd/loadgen + go build -o bin/soak ./cmd/soak run: go run ./cmd/engagepulse @@ -34,6 +35,9 @@ seed: migrate loadgen: go run ./cmd/loadgen -n 8 +soak: + go run ./cmd/soak + demo: bash ./scripts/demo.sh diff --git a/cmd/soak/main.go b/cmd/soak/main.go new file mode 100644 index 0000000..45f1c9d --- /dev/null +++ b/cmd/soak/main.go @@ -0,0 +1,200 @@ +package main + +import ( + "bytes" + "encoding/json" + "flag" + "fmt" + "io" + "net/http" + "os" + "strconv" + "strings" + "time" + + "github.com/o-mid/engagepulse/internal/domain" + "github.com/o-mid/engagepulse/internal/ingest" + "github.com/o-mid/engagepulse/internal/soak" +) + +func main() { + baseURL := flag.String("url", "http://127.0.0.1:8080", "API base URL (local only)") + secret := flag.String("secret", "hmac_acme_dev_secret", "HMAC secret") + keyID := flag.String("key-id", "v1", "HMAC key id") + apiKey := flag.String("api-key", "ak_acme_dev_001", "API key for GET player") + tenant := flag.String("tenant", "acme-casino", "tenant id") + n := flag.Int("n", 20, "unique first-deposit players") + dup := flag.Int("dup", 3, "extra deliveries of each event_id") + wait := flag.Duration("wait", 60*time.Second, "time to wait for worker catch-up") + flag.Parse() + + if err := soak.GuardURL(*baseURL); err != nil { + fail(err) + } + + client := &http.Client{Timeout: 5 * time.Second} + creditsBefore, err := metric(client, *baseURL, "engagepulse_ledger_credits_total") + if err != nil { + fail(fmt.Errorf("metrics: %w (is make run up?)", err)) + } + + type sent struct { + eventID string + playerID string + } + now := time.Now().UTC() + var batch []sent + for i := 0; i < *n; i++ { + playerID := fmt.Sprintf("soak-%d-%d", now.UnixNano(), i) + eventID := fmt.Sprintf("soak-evt-%d-%d", now.UnixNano(), i) + evt := domain.Event{ + EventID: eventID, + TenantID: *tenant, + PlayerID: playerID, + Type: domain.EventDeposit, + Amount: 50, + OccurredAt: now, + } + if err := postEvent(client, *baseURL, *secret, *keyID, evt); err != nil { + fail(err) + } + batch = append(batch, sent{eventID: eventID, playerID: playerID}) + } + for round := 0; round < *dup; round++ { + for _, item := range batch { + evt := domain.Event{ + EventID: item.eventID, + TenantID: *tenant, + PlayerID: item.playerID, + Type: domain.EventDeposit, + Amount: 50, + OccurredAt: now, + } + if err := postEvent(client, *baseURL, *secret, *keyID, evt); err != nil { + fail(err) + } + } + } + + deadline := time.Now().Add(*wait) + var creditsAfter int + for { + creditsAfter, err = metric(client, *baseURL, "engagepulse_ledger_credits_total") + if err != nil { + fail(err) + } + if creditsAfter-creditsBefore >= *n { + break + } + if time.Now().After(deadline) { + fail(fmt.Errorf("timeout: credits Δ %d want %d", creditsAfter-creditsBefore, *n)) + } + time.Sleep(400 * time.Millisecond) + } + delta := creditsAfter - creditsBefore + if delta != *n { + fail(fmt.Errorf("credits Δ %d want %d unique events", delta, *n)) + } + + for _, item := range batch { + bal, err := playerBalance(client, *baseURL, *apiKey, item.playerID) + if err != nil { + fail(err) + } + if bal != 100 { + fail(fmt.Errorf("player %s balance=%d want 100", item.playerID, bal)) + } + } + fmt.Printf("soak ok unique=%d extra_deliveries=%d credits_delta=%d balance=100\n", *n, *dup, delta) +} + +func postEvent(client *http.Client, base, secret, keyID string, evt domain.Event) error { + body, err := json.Marshal(evt) + if err != nil { + return err + } + req, err := http.NewRequest(http.MethodPost, strings.TrimRight(base, "/")+"/v1/events", bytes.NewReader(body)) + if err != nil { + return err + } + req.Header.Set("Content-Type", "application/json") + req.Header.Set("X-Signature", ingest.Sign(secret, body)) + if strings.TrimSpace(keyID) != "" { + req.Header.Set(ingest.HeaderKeyID, keyID) + } + resp, err := client.Do(req) + if err != nil { + return err + } + defer func() { _ = resp.Body.Close() }() + if resp.StatusCode != http.StatusAccepted { + b, _ := io.ReadAll(resp.Body) + return fmt.Errorf("ingest %d %s: %s", resp.StatusCode, evt.EventID, b) + } + return nil +} + +func metric(client *http.Client, base, name string) (int, error) { + resp, err := client.Get(strings.TrimRight(base, "/") + "/metrics") + if err != nil { + return 0, err + } + defer func() { _ = resp.Body.Close() }() + b, err := io.ReadAll(resp.Body) + if err != nil { + return 0, err + } + total := 0 + found := false + for _, line := range strings.Split(string(b), "\n") { + if line == "" || strings.HasPrefix(line, "#") { + continue + } + if !strings.HasPrefix(line, name) { + continue + } + fields := strings.Fields(line) + if len(fields) < 2 { + continue + } + n, err := strconv.ParseFloat(fields[len(fields)-1], 64) + if err != nil { + continue + } + total += int(n) + found = true + } + if !found { + return 0, nil + } + return total, nil +} + +func playerBalance(client *http.Client, base, apiKey, playerID string) (int64, error) { + req, err := http.NewRequest(http.MethodGet, strings.TrimRight(base, "/")+"/v1/players/"+playerID, nil) + if err != nil { + return 0, err + } + req.Header.Set("X-API-Key", apiKey) + resp, err := client.Do(req) + if err != nil { + return 0, err + } + defer func() { _ = resp.Body.Close() }() + if resp.StatusCode != http.StatusOK { + b, _ := io.ReadAll(resp.Body) + return 0, fmt.Errorf("player %s status %d: %s", playerID, resp.StatusCode, b) + } + var snap struct { + Balance int64 `json:"balance"` + } + if err := json.NewDecoder(resp.Body).Decode(&snap); err != nil { + return 0, err + } + return snap.Balance, nil +} + +func fail(err error) { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) +} From fa12c738df99339d664818d2544fedec401f54f4 Mon Sep 17 00:00:00 2001 From: Omid Mirzaei Date: Fri, 18 Sep 2026 13:51:58 +0400 Subject: [PATCH 3/4] document make soak as a local-only check --- .env.example | 2 ++ README.md | 1 + 2 files changed, 3 insertions(+) diff --git a/.env.example b/.env.example index 9b49d2c..ee8af4e 100644 --- a/.env.example +++ b/.env.example @@ -21,6 +21,8 @@ LOG_LEVEL=info # Do not set this on the public Railway API. # FAIL_INJECT=true +# make soak is local only. It refuses Railway URLs. + # Seed tenants (local demo only). HMAC key id defaults to v1. # acme-casino: api_key=ak_acme_dev_001 hmac=hmac_acme_dev_secret # nova-sports: api_key=ak_nova_dev_001 hmac=hmac_nova_dev_secret diff --git a/README.md b/README.md index 22402cb..21cc62e 100644 --- a/README.md +++ b/README.md @@ -113,6 +113,7 @@ make demo | `make up` | Start Postgres + Redpanda | | `make migrate` | Create / update tables (+ seed brands) | | `make loadgen` | Send signed events | +| `make soak` | Local only: unique first deposits plus duplicate deliveries; credits Δ equals unique ids, each balance 100. Do not point at Railway. | | `make demo` | Guided end-to-end run | | `make replay` | Replay pack vs expected player JSON (needs `DATABASE_URL`) | | `make replay-kafka` | Same packs through ingest → outbox → Kafka → consumer (needs Kafka) | From 16438841005fda99f360d348fb7b88e5de9758fd Mon Sep 17 00:00:00 2001 From: Omid Mirzaei Date: Fri, 18 Sep 2026 13:53:36 +0400 Subject: [PATCH 4/4] reuse the soak error instead of shadowing it --- cmd/soak/main.go | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/cmd/soak/main.go b/cmd/soak/main.go index 45f1c9d..a2dc64b 100644 --- a/cmd/soak/main.go +++ b/cmd/soak/main.go @@ -55,7 +55,7 @@ func main() { Amount: 50, OccurredAt: now, } - if err := postEvent(client, *baseURL, *secret, *keyID, evt); err != nil { + if err = postEvent(client, *baseURL, *secret, *keyID, evt); err != nil { fail(err) } batch = append(batch, sent{eventID: eventID, playerID: playerID}) @@ -70,7 +70,7 @@ func main() { Amount: 50, OccurredAt: now, } - if err := postEvent(client, *baseURL, *secret, *keyID, evt); err != nil { + if err = postEvent(client, *baseURL, *secret, *keyID, evt); err != nil { fail(err) } } @@ -97,7 +97,8 @@ func main() { } for _, item := range batch { - bal, err := playerBalance(client, *baseURL, *apiKey, item.playerID) + var bal int64 + bal, err = playerBalance(client, *baseURL, *apiKey, item.playerID) if err != nil { fail(err) }