feat: add proxy-stress-test sample app for e2e regression testing

[slayerjain]

Summary

Adds a Go sample app that exercises Keploy proxy under stress conditions for e2e regression testing.

What the app does

• Makes 42 concurrent HTTPS connections through a forward proxy (tinyproxy) via CONNECT tunnels
• Queries PostgreSQL with 50+ rows having 100KB+ payloads (large DataRow responses)
• Sends HTTP POST through CONNECT tunnel
• OTel SDK exports to localhost:4318 with no collector (stresses error channel)
• Background noise connections between tests

Resource constraints

• App container: 0.5 CPU, 512MB memory (simulates K8s pod)
• Keploy container: throttled to 0.5 CPU via docker update in CI script

Why it's needed

This sample app is used by the `proxy-stress-test` CI pipeline in keploy/keploy to verify that recording and replay work correctly under conditions that previously caused high latency and replay hangs.

Files

• `main.go` — Go HTTP server with /api/transfer, /api/batch-transfer, /api/post-transfer
• `docker-compose.yml` — postgres + tinyproxy + app with CPU/memory limits
• `init.sql` — Seeds 200 rows with 100KB payloads
• `Dockerfile` — Multi-stage Go build
• `test.sh` — Standalone test script with cleanup trap and timeouts

[Copilot]

Pull request overview

Adds a new proxy-stress-test sample Go app + compose environment intended to stress Keploy’s proxy recording/replay via concurrent HTTPS CONNECT tunneling, large PostgreSQL DataRow payloads, and POST-through-proxy flows.

Changes:

• Introduces a Go HTTP server with endpoints that generate proxy + DB stress patterns.
• Adds Docker Compose stack (Postgres + tinyproxy + app) and SQL seeding for large/“wide” rows.
• Adds a standalone test.sh script to run record + replay and validate reports.

Reviewed changes

Copilot reviewed 6 out of 7 changed files in this pull request and generated 14 comments.

Show a summary per file

File	Description
proxy-stress-test/main.go	Implements the stress-test HTTP server, proxy/TLS behavior, Postgres queries, and optional OTel/noise traffic.
proxy-stress-test/docker-compose.yml	Brings up Postgres, tinyproxy, and the app with stress-test env configuration.
proxy-stress-test/init.sql	Seeds large and wide Postgres rows to produce fragmented/large DataRow responses.
proxy-stress-test/test.sh	Automates record + replay phases and checks for races/panics/report status.
proxy-stress-test/Dockerfile	Builds and packages the sample app container image.
proxy-stress-test/go.mod	Defines the module and dependencies for the sample app.
proxy-stress-test/go.sum	Locks dependency checksums for reproducible builds.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

source ./../../.github/workflows/test_workflow_scripts/test-iid.sh will fail because that path doesn't exist in this repository, and with set -u it will also leave $RECORD_BIN/$REPLAY_BIN undefined. Either add the referenced script in this PR or inline/define the needed variables in this script.

Suggested change

	source ./../../.github/workflows/test_workflow_scripts/test-iid.sh
	docker compose build
	sudo rm -rf keploy/
	$RECORD_BIN config --generate
	RECORD_BIN="${RECORD_BIN:-keploy}"
	REPLAY_BIN="${REPLAY_BIN:-keploy}"
	require_binary() {
	local bin_name="$1"
	if [ -x "$bin_name" ] || command -v "$bin_name" >/dev/null 2>&1; then
	return 0
	fi
	echo "Error: Required binary '$bin_name' is not available. Install Keploy or set RECORD_BIN/REPLAY_BIN to the correct executable path, then rerun this script." >&2
	exit 1
	}
	require_binary "$RECORD_BIN"
	require_binary "$REPLAY_BIN"
	docker compose build
	sudo rm -rf keploy/
	"$RECORD_BIN" config --generate

[Copilot]

Using sudo rm -rf keploy/ makes the script fail in environments without sudo (and is brittle in CI). Prefer removing the directory without sudo (or conditionally use sudo only when required after checking ownership/permissions).

Suggested change

	sudo rm -rf keploy/
	if [ -d keploy/ ]; then
	rm -rf keploy/ 2>/dev/null || {
	if command -v sudo >/dev/null 2>&1; then
	sudo rm -rf keploy/
	else
	echo "Unable to remove keploy/. Please adjust permissions or remove the directory manually, then rerun the script." >&2
	exit 1
	fi
	}
	fi

[Copilot]

log.Printf("WARN: ...") introduces a warning-level log line; please avoid adding warnings and instead log at a normal level with a clear next step (e.g., tell the user to start an OTel collector or set OTEL_ENABLED=false).

Suggested change

	log.Printf("WARN: OTel init failed (expected if no collector): %v", err)
	log.Printf("OTel init failed: %v. To enable telemetry, start an OTel collector at %s, or set OTEL_ENABLED=false to run without telemetry.", err, otelEndpoint)

[Copilot]

log.Fatalf("Failed to connect to database: %v", err) doesn’t give the user an actionable next step. Consider including which env var/DSN is being used and a suggestion like verifying DATABASE_URL or that docker compose up db is healthy.

Suggested change

	log.Fatalf("Failed to connect to database: %v", err)
	log.Fatalf("Failed to connect to database using DSN %q: %v. Next step: verify the configured database DSN, confirm Postgres is running and reachable, and check credentials and network access.", dbDSN, err)

[Copilot]

InsecureSkipVerify: true disables TLS certificate verification, which is risky if this sample is ever run outside a controlled test environment. Consider making this opt-in via an env var (default false) and/or restrict it to when a Keploy proxy is explicitly enabled.

[Copilot]

wideRows.Scan(ptrs...) ignores the scan error, which can hide driver/protocol issues (particularly relevant for this stress test). Capture and surface the error (e.g., set result.DBError) and stop iterating on failure.

[Copilot]

After iterating rows.Next(), the code doesn’t check rows.Err(), so mid-stream errors can be silently missed. Check rows.Err() before closing and propagate it into result.DBError.

Suggested change

	}
	}
	if err := rows.Err(); err != nil && result.DBError == "" {
	result.DBError = err.Error()
	}

[Copilot]

On non-2xx HTTP responses, errors is appended to without any cap, which can grow unbounded for large batchSize. Apply the same max-length guard used for the err != nil branch.

Suggested change

	errors = append(errors, fmt.Sprintf("HTTP %d", status))
	if len(errors) < 5 {
	errors = append(errors, fmt.Sprintf("HTTP %d", status))
	}

[Copilot]

Exposing the proxy on the host (3128:3128) can create an open proxy on the developer/CI machine. Consider binding to localhost (e.g., 127.0.0.1:3128:3128) unless host access is required.

Suggested change

	- "3128:3128"
	- "127.0.0.1:3128:3128"

[Copilot]

Allow 0.0.0.0/0 makes tinyproxy accept connections from anywhere that can reach the container. Prefer restricting the allowlist to the Docker network/subnet used by this compose project.

[Copilot]

Pull request overview

Copilot reviewed 6 out of 7 changed files in this pull request and generated 4 comments.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

The keploy record invocation uses --generateGithubActions=false, but the replay command below uses --generate-github-actions=false. Mixing flag names/casing is likely to break on some Keploy CLI versions; please use the same (documented) flag name consistently for both record and test runs.

[Copilot]

keploy test is using --containerName, while other samples in this repo use --container-name (e.g. http-postgres/README.md and fasthttp-postgres/README.md). If --containerName isn’t a valid alias in the Keploy CLI, the replay step will fail—please switch to the same --container-name flag used elsewhere for consistency and compatibility.

Suggested change

	keploy test -c 'docker compose up' --containerName "$container_name" --apiTimeout 60 --delay 20 --generate-github-actions=false &> "${container_name}-replay.txt"
	keploy test -c 'docker compose up' --container-name "$container_name" --apiTimeout 60 --delay 20 --generate-github-actions=false &> "${container_name}-replay.txt"

[Copilot]

The /health wait loop has no overall timeout/attempt limit. If the app never becomes healthy (build failure, port conflict, etc.), this script can hang indefinitely in CI. Consider adding a max wait duration/attempt count and exiting with a helpful error message when exceeded.

[Copilot]

This block isn’t gofmt-formatted (indentation/bracing around the scanErr check is off). Since the repo enables the gofmt linter (see .golangci.yml:16-18), this will fail linting—please run gofmt on the file (or at least fix this block’s formatting).

Suggested change

	break
	}
	}
	break
	}
	}

[Copilot]

Pull request overview

Copilot reviewed 6 out of 7 changed files in this pull request and generated 11 comments.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

concurrentConns is used to size a slice and control a loop; if the env var is set to 0 or a negative value, this will panic at runtime (make([]httpsResult, concurrentConns)). Consider validating/clamping concurrentConns (and similarly BATCH_SIZE) to a sane minimum (>=1) during startup and returning a clear error if invalid.

[Copilot]

time.Second / time.Duration(bgNoiseConns) can evaluate to 0 when BG_NOISE_CONNS is very large, which will cause time.NewTicker(0) to panic. Add a guard to ensure the computed interval is >0 (e.g., cap the max rate or fall back to 1ns) before constructing the ticker.

Suggested change

	ticker := time.NewTicker(time.Second / time.Duration(bgNoiseConns))
	interval := time.Second / time.Duration(bgNoiseConns)
	if interval <= 0 {
	interval = time.Nanosecond
	}
	ticker := time.NewTicker(interval)

[Copilot]

/health calls db.PingContext(r.Context()), but the request context typically has no deadline, so a stalled DB connection can hang the health endpoint indefinitely. Consider wrapping the ping in a short timeout context (e.g., 1–2s) so health checks reliably return.

Suggested change

	if err := db.PingContext(r.Context()); err != nil {
	ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
	defer cancel()
	if err := db.PingContext(ctx); err != nil {

[Copilot]

The comment says the Postgres result sets are queried "concurrently", but the implementation runs the three queries sequentially in a for-loop. Either update the comment to match the current behavior or actually execute these queries concurrently if that concurrency is important for the intended stress profile.

Suggested change

	for i := 0; i < 3; i++ {
	rows, err := db.QueryContext(ctx,
	`SELECT id, name, description, large_payload FROM large_records ORDER BY id LIMIT 100`)
	if err != nil {
	continue
	}
	for rows.Next() {
	var id int
	var name, desc, payload string
	_ = rows.Scan(&id, &name, &desc, &payload)
	dbRows++
	}
	rows.Close()
	}
	var dbWG sync.WaitGroup
	dbRowsCh := make(chan int, 3)
	for i := 0; i < 3; i++ {
	dbWG.Add(1)
	go func() {
	defer dbWG.Done()
	rows, err := db.QueryContext(ctx,
	`SELECT id, name, description, large_payload FROM large_records ORDER BY id LIMIT 100`)
	if err != nil {
	return
	}
	defer rows.Close()
	localRows := 0
	for rows.Next() {
	var id int
	var name, desc, payload string
	_ = rows.Scan(&id, &name, &desc, &payload)
	localRows++
	}
	dbRowsCh <- localRows
	}()
	}
	dbWG.Wait()
	close(dbRowsCh)
	for rowCount := range dbRowsCh {
	dbRows += rowCount
	}

[Copilot]

The service name/version are hard-coded to repro-app/0.1.0, which doesn’t match the sample directory/name (proxy-stress-test) and can make CI traces/logs harder to attribute. Consider renaming these attributes to align with the sample (or sourcing from env/build metadata).

[Copilot]

vimagick/tinyproxy:latest is not pinned, which can make this e2e regression environment non-reproducible (a new image can change behavior unexpectedly). Consider pinning to a specific version tag or immutable digest.

Suggested change

	image: vimagick/tinyproxy:latest
	image: vimagick/tinyproxy@sha256:<replace-with-validated-image-digest>

[Copilot]

The script brings up containers but doesn’t ensure cleanup on early exit (because set -euo pipefail will exit immediately on failure). Add a trap to always run docker compose down (and optionally remove-orphans/volumes) so CI and local runs don’t leave stray containers/networks behind.

Suggested change

	cleanup() {
	exit_code="$1"
	trap - EXIT
	set +e
	if ! docker compose down --remove-orphans; then
	echo "Docker Compose cleanup did not complete successfully. Please run 'docker compose down --remove-orphans' manually and inspect 'docker compose ps' for any remaining resources."
	fi
	exit "$exit_code"
	}
	trap 'cleanup $?' EXIT

[Copilot]

container_kill uses pgrep -n -f 'keploy record' which can match and interrupt an unrelated keploy record process on the same machine. It would be safer to capture the PID of the keploy record invocation you start (or match on a more specific pattern including --container-name $container_name).

[Copilot]

The curl calls don’t set any request timeout, so a hung HTTP call can stall the entire e2e run. Consider adding --max-time (and optionally a small --retry/--retry-connrefused) to the health polling and the API calls to keep CI runs bounded.

Suggested change

	while [ "$app_started" = false ]; do
	if curl -sf http://localhost:8080/health > /dev/null 2>&1; then
	app_started=true
	fi
	sleep 3
	attempt=$((attempt + 1))
	if [ "$attempt" -ge "$max_attempts" ]; then
	echo "App failed to start after $max_attempts attempts"
	exit 1
	fi
	done
	echo "App started"
	curl -sf http://localhost:8080/api/transfer
	curl -sf http://localhost:8080/api/batch-transfer
	curl -sf http://localhost:8080/api/post-transfer
	curl -sf http://localhost:8080/health
	health_check_curl_opts=(--connect-timeout 2 --max-time 5 --retry 2 --retry-delay 1 --retry-connrefused -sf)
	api_curl_opts=(--connect-timeout 2 --max-time 10 -sf)
	while [ "$app_started" = false ]; do
	if curl "${health_check_curl_opts[@]}" http://localhost:8080/health > /dev/null 2>&1; then
	app_started=true
	fi
	sleep 3
	attempt=$((attempt + 1))
	if [ "$attempt" -ge "$max_attempts" ]; then
	echo "App failed to start after $max_attempts attempts. Check docker compose logs and confirm the service is listening on http://localhost:8080/health."
	exit 1
	fi
	done
	echo "App started"
	curl "${api_curl_opts[@]}" http://localhost:8080/api/transfer
	curl "${api_curl_opts[@]}" http://localhost:8080/api/batch-transfer
	curl "${api_curl_opts[@]}" http://localhost:8080/api/post-transfer
	curl "${health_check_curl_opts[@]}" http://localhost:8080/health

[Copilot]

After replay (keploy test -c 'docker compose up' ...), the script doesn’t call docker compose down, which can leave the stack running after the test completes (or fails). Ensure the compose stack is torn down after replay as well (or via a top-level trap).

[Copilot]

Pull request overview

Copilot reviewed 6 out of 7 changed files in this pull request and generated 3 comments.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

docker compose build (and subsequent compose commands) will fail if this script is invoked from outside the proxy-stress-test/ directory (e.g. bash proxy-stress-test/test.sh from repo root). Consider cd-ing to the script directory at the start (and using paths relative to it) so the script is location-independent.

[Copilot]

send_request runs in the background but its exit status is never checked, and the wait inside send_request doesn’t wait for the keploy record process (it only waits for jobs spawned by that background function). If any curl fails, send_request can exit early without interrupting recording, leaving keploy record running/hanging. Capture the background PID (req_pid=$!) and wait for it in the main flow (and/or ensure failures still trigger container_kill).

[Copilot]

errors is capped for network errors (len(errors) < 5), but non-2xx HTTP statuses append without any limit. With a large BATCH_SIZE, this can create a very large response payload and unnecessary memory growth. Consider applying the same cap for non-2xx statuses too.

Suggested change

	errors = append(errors, fmt.Sprintf("HTTP %d", status))
	if len(errors) < 5 {
	errors = append(errors, fmt.Sprintf("HTTP %d", status))
	}

[Copilot]

Pull request overview

Copilot reviewed 6 out of 7 changed files in this pull request and generated 7 comments.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

send_request runs in the background, so exit 1 inside it will not fail the main script; if the app never becomes healthy, keploy record can keep running indefinitely. Consider propagating failures back to the main process (e.g., have the failure path also stop recording and have the main script wait on the request job PID and exit non-zero if it failed).

[Copilot]

container_kill finds a PID via pgrep -f 'keploy record', which can match/kill the wrong process if multiple Keploy runs exist on the host. It will be more reliable to capture the keploy record PID explicitly (or otherwise scope the match) and signal that specific process.

[Copilot]

If PingContext fails, initDB returns without closing the opened *sql.DB, leaking resources on the failure path. Close the DB before returning the ping error.

Suggested change

	if err := db.PingContext(ctx); err != nil {
	if err := db.PingContext(ctx); err != nil {
	if closeErr := db.Close(); closeErr != nil {
	return nil, fmt.Errorf("ping failed: %w; closing DB after failed ping also failed: %v", err, closeErr)
	}

[Copilot]

When HTTP_PROXY_URL is set but cannot be parsed, the proxy configuration is silently ignored and requests go direct, which can make the stress test produce false positives. Consider surfacing this as an error (or at least logging and failing fast) when a non-empty proxy URL is invalid.

Suggested change

	if err == nil {
	t.Proxy = http.ProxyURL(proxyURL)
	}
	if err != nil || proxyURL.Scheme == "" || proxyURL.Host == "" {
	log.Fatalf("Invalid HTTP_PROXY_URL %q. Update HTTP_PROXY_URL to a valid proxy URL such as http://proxy.example:8080 and rerun the stress test.", httpProxyURL)
	}
	t.Proxy = http.ProxyURL(proxyURL)

[Copilot]

backgroundNoise spawns a new goroutine on every tick with no upper bound; with higher BG_NOISE_CONNS this can accumulate and exhaust resources if requests take longer than the tick interval. Consider reusing a fixed worker pool / rate-limited loop (or a semaphore) and reusing the http.Client/Transport.

Suggested change

	log.Printf("Starting background noise: %d outgoing connections/sec", bgNoiseConns)
	ticker := time.NewTicker(time.Second / time.Duration(bgNoiseConns))
	defer ticker.Stop()
	for {
	select {
	case <-ctx.Done():
	return
	case <-ticker.C:
	go func() {
	// Each of these during replay = "no matching mock found" = error to errChannel
	client := &http.Client{Transport: newTransport(), Timeout: 5 * time.Second}
	req, err := http.NewRequest("GET", httpsTarget, nil)
	if err != nil {
	return
	}
	resp, err := client.Do(req)
	if err == nil {
	resp.Body.Close()
	}
	}()
	log.Printf("Starting background noise: %d outgoing connections/sec", bgNoiseConns)
	client := &http.Client{
	Transport: newTransport(),
	Timeout: 5 * time.Second,
	}
	ticker := time.NewTicker(time.Second / time.Duration(bgNoiseConns))
	defer ticker.Stop()
	// Bound the number of in-flight requests so slower responses cannot cause
	// unbounded goroutine growth. Matching the configured request rate keeps the
	// background load steady without exhausting resources.
	inFlight := make(chan struct{}, bgNoiseConns)
	for {
	select {
	case <-ctx.Done():
	return
	case <-ticker.C:
	select {
	case inFlight <- struct{}{}:
	go func() {
	defer func() { <-inFlight }()
	// Each of these during replay = "no matching mock found" = error to errChannel
	req, err := http.NewRequestWithContext(ctx, "GET", httpsTarget, nil)
	if err != nil {
	return
	}
	resp, err := client.Do(req)
	if err == nil {
	resp.Body.Close()
	}
	}()
	default:
	// Skip this tick when all worker slots are busy.
	}

[Copilot]

This log line reports an OTel init error but doesn't provide a clear next step (e.g., run a collector at the configured endpoint or disable OTel via OTEL_ENABLED=false). Adding an actionable hint would make troubleshooting easier.

Suggested change

	log.Printf("OTel init returned error (expected if no collector): %v", err)
	log.Printf("OTel init failed: %v. To enable telemetry, start an OTLP collector at %s. If telemetry is not needed, disable it with OTEL_ENABLED=false.", err, otelEndpoint)

[Copilot]

Use http.StatusInternalServerError instead of the literal 500 for clarity and to avoid magic numbers.

Suggested change

	http.Error(w, err.Error(), 500)
	http.Error(w, err.Error(), http.StatusInternalServerError)

[Copilot]

Pull request overview

Copilot reviewed 6 out of 7 changed files in this pull request and generated 9 comments.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

The pg_size_pretty(avg(...::bigint)) calls will fail because avg(bigint) returns numeric, and Postgres doesn't have pg_size_pretty(numeric). Cast the result of avg(...) to bigint (or compute the average via sum()/count() and cast) so the init script doesn't error during container startup.

Suggested change

	pg_size_pretty(avg(length(large_payload)::bigint)) AS avg_payload,
	pg_size_pretty(sum(length(large_payload)::bigint)) AS total_payload
	FROM large_records
	UNION ALL
	SELECT 'wide_records',
	count(*),
	pg_size_pretty(avg(octet_length(col_01)::bigint)),
	pg_size_pretty(avg(length(large_payload)::bigint)::bigint) AS avg_payload,
	pg_size_pretty(sum(length(large_payload)::bigint)) AS total_payload
	FROM large_records
	UNION ALL
	SELECT 'wide_records',
	count(*),
	pg_size_pretty(avg(octet_length(col_01)::bigint)::bigint),

[Copilot]

Binding Postgres to host port 5432:5432 is likely to conflict with a local Postgres (and differs from other samples that use non-default host ports). Consider removing the host port mapping (the app can reach db on the compose network) or mapping to a non-default host port to make the test more reliable.

Suggested change

	ports:
	- "5432:5432"

[Copilot]

newTransport() may negotiate HTTP/2 with the external HTTPS target. If the goal is to reproduce the proxy bug that keyes off an HTTP/1.1 payload prefix (e.g., starting with POST ), HTTP/2 will prevent that reproduction. Consider explicitly disabling HTTP/2 on the transport to keep the traffic HTTP/1.1 and make the repro deterministic.

[Copilot]

time.NewTicker(time.Second / time.Duration(bgNoiseConns)) will panic if bgNoiseConns is set high enough that the computed interval becomes 0. Consider clamping bgNoiseConns to a safe maximum or computing the interval with a minimum of 1ns/1ms to avoid runtime panics from misconfiguration.

Suggested change

	ticker := time.NewTicker(time.Second / time.Duration(bgNoiseConns))
	interval := time.Second / time.Duration(bgNoiseConns)
	if interval <= 0 {
	interval = time.Nanosecond
	}
	ticker := time.NewTicker(interval)

[Copilot]

In batchTransferHandler, non-2xx HTTP responses always append to errors without any cap, which can grow unbounded if BATCH_SIZE is increased. Consider limiting the number of stored error strings (similar to the len(errors) < 5 check used for err != nil) to keep response size predictable.

[Copilot]

Because the script runs with set -e, a non-zero exit from keploy test (or keploy record) will abort the script before the later diagnostics (panic grep, report parsing, log printing) run. If those diagnostics are important for CI debugging, capture the exit code and continue to the checks (then fail at the end).

[Copilot]

The wide_records query ignores scan/iteration errors: on Scan error it just breaks without surfacing anything in the response, and wideRows.Err() is never checked. If this endpoint is meant to detect Postgres/proxy decoding failures, capture these errors into result.DBError (and ensure wideRows is closed via defer after a successful query).

[Copilot]

The batch DB query loop discards rows.Scan errors and never checks rows.Err(). That can silently undercount dbRows and hide the very Postgres/proxy decode failures this stress test is supposed to surface. Consider handling Scan/Err and returning (or recording) a DB error when they occur.

[Copilot]

OTEL_EXPORTER_OTLP_ENDPOINT is a standard OpenTelemetry env var that is commonly set as a URL (e.g. http://localhost:4318). The OTLP HTTP exporters here use WithEndpoint(otelEndpoint), which expects a host:port (no scheme). Consider either accepting both formats (strip http(s):// when present) or using a custom env var name to avoid surprising misconfiguration.

[Copilot]

Pull request overview

Copilot reviewed 6 out of 7 changed files in this pull request and generated 5 comments.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

initDB() returns early on PingContext error without closing the *sql.DB, which leaks resources (and can keep background goroutines running) on startup failures. Close db before returning the ping error (or defer a close until success is confirmed).

Suggested change

	func initDB() (*sql.DB, error) {
	db, err := sql.Open("postgres", dbDSN)
	if err != nil {
	return nil, err
	}
	db.SetMaxOpenConns(10)
	db.SetMaxIdleConns(5)
	db.SetConnMaxLifetime(5 * time.Minute)
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	if err := db.PingContext(ctx); err != nil {
	func initDB() (db *sql.DB, err error) {
	db, err = sql.Open("postgres", dbDSN)
	if err != nil {
	return nil, err
	}
	defer func() {
	if err != nil {
	_ = db.Close()
	}
	}()
	db.SetMaxOpenConns(10)
	db.SetMaxIdleConns(5)
	db.SetConnMaxLifetime(5 * time.Minute)
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	if err = db.PingContext(ctx); err != nil {

[Copilot]

newTransport() silently ignores invalid HTTP_PROXY_URL values (parse errors), which can cause the test to run without a proxy and invalidate the intended stress scenario. Consider validating/parsing the proxy URL once at startup and failing fast (or at least logging a clear error) when it’s invalid.

[Copilot]

The loop for _, r := range results shadows the r *http.Request parameter from the handler, which is easy to misread and can lead to mistakes when editing this function. Rename the loop variable to avoid shadowing.

Suggested change

	for _, r := range results {
	if r.err != nil {
	result.HTTPSError = r.err.Error()
	} else {
	result.HTTPSStatus = r.status
	for _, res := range results {
	if res.err != nil {
	result.HTTPSError = res.err.Error()
	} else {
	result.HTTPSStatus = res.status

[Copilot]

docker compose up is invoked without --compatibility, but the resource constraints are defined under deploy.resources.limits, which Docker Compose typically ignores unless compatibility mode (or Swarm) is used. If the CPU/memory limit is required for this regression, update the command to run Compose in compatibility mode or switch to Compose-supported limit fields so the stress conditions are actually enforced in CI.

[Copilot]

/health always returns HTTP 200 even when the DB ping fails (status = "db_down: ..."). Since the script uses curl -sf on /health to gate test execution, DB failures won’t fail the readiness check. Consider returning a non-2xx status (e.g., 503) when PingContext fails.

Suggested change

	status := "ok"
	ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
	defer cancel()
	if err := db.PingContext(ctx); err != nil {
	status = "db_down: " + err.Error()
	}
	w.Header().Set("Content-Type", "application/json")
	status := "ok"
	httpStatus := http.StatusOK
	ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
	defer cancel()
	if err := db.PingContext(ctx); err != nil {
	status = "db_down: " + err.Error()
	httpStatus = http.StatusServiceUnavailable
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(httpStatus)

[Copilot]

Pull request overview

Copilot reviewed 6 out of 7 changed files in this pull request and generated 1 comment.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

postTransferHandler takes db *sql.DB but does not use it. Either remove the parameter, rename it to _ to indicate it’s intentionally unused, or use it (e.g., for a lightweight DB query) so the handler signature doesn’t suggest a dependency it doesn’t have.

Suggested change

	func postTransferHandler(db *sql.DB) http.HandlerFunc {
	func postTransferHandler(_ *sql.DB) http.HandlerFunc {