From 2e7a80be9279d1d40b97e2526bcccfe3004fbdaf Mon Sep 17 00:00:00 2001 From: CharaWein Date: Fri, 23 Oct 2026 17:24:54 +0300 Subject: [PATCH 1/8] =?UTF-8?q?lab3:=20=D0=B1=D0=B0=D0=BB=D0=B0=D0=BD?= =?UTF-8?q?=D1=81=D0=B8=D1=80=D0=BE=D0=B2=D0=BA=D0=B0,=20=D0=B8=D0=B4?= =?UTF-8?q?=D0=B5=D0=BC=D0=BF=D0=BE=D1=82=D0=B5=D0=BD=D1=82=D0=BD=D0=BE?= =?UTF-8?q?=D1=81=D1=82=D1=8C,=20=D0=BE=D1=82=D0=BA=D0=B0=D0=B7=20=D1=80?= =?UTF-8?q?=D0=B5=D0=BF=D0=BB=D0=B8=D0=BA=D0=B8,=20=D1=82=D1=80=D0=B5?= =?UTF-8?q?=D0=BA=201?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - X-Instance-Id, обязательный Idempotency-Key (PostgreSQL, одна транзакция) - HAProxy + 2..N реплик API, readiness/drain по SIGTERM, однократные миграции - скрипты stop-one/restore/restart/rolling-update/collect-evidence - трек 1: параметризованный стенд, cmd/bench, оркестратор и анализ - workflow реального прогона Docker-стенда на GitHub Actions Co-Authored-By: Claude Opus 5.5 --- .dockerignore | 2 + .env.example | 13 +- .github/workflows/lab3-stand.yml | 91 +++++ Dockerfile | 54 +++ Makefile | 28 +- REPORT.md | 193 ++++++++++- cmd/api/main.go | 151 ++++++++ cmd/bench/main.go | 328 ++++++++++++++++++ compose.yaml | 131 +++++++ evidence/idempotency_concurrent_native.json | 88 +++++ evidence/local_native_check.txt | 15 + experiments/track1.json | 72 ++++ go.mod | 21 ++ go.sum | 43 +++ infra/haproxy/haproxy.cfg | 59 ++++ internal/config/config.go | 113 ++++++ internal/domain/chat.go | 30 ++ internal/domain/message.go | 25 ++ internal/domain/session.go | 10 + internal/domain/user.go | 25 ++ internal/repository/postgres/chat.go | 159 +++++++++ internal/repository/postgres/message.go | 135 +++++++ internal/repository/postgres/pool.go | 39 +++ internal/repository/postgres/user.go | 77 ++++ internal/repository/redis/message_cache.go | 111 ++++++ internal/repository/redis/session.go | 73 ++++ internal/repository/repository.go | 55 +++ internal/service/auth.go | 99 ++++++ internal/service/chat.go | 138 ++++++++ internal/service/cursor.go | 39 +++ internal/service/errors.go | 12 + internal/service/id.go | 23 ++ internal/service/message.go | 161 +++++++++ internal/service/password.go | 66 ++++ internal/service/user.go | 64 ++++ internal/service/validate.go | 48 +++ internal/transport/http/auth.go | 92 +++++ internal/transport/http/chat.go | 86 +++++ internal/transport/http/health.go | 54 +++ internal/transport/http/internal_stats.go | 39 +++ internal/transport/http/message.go | 75 ++++ internal/transport/http/middleware/auth.go | 48 +++ .../transport/http/middleware/instance.go | 14 + internal/transport/http/middleware/logging.go | 34 ++ .../transport/http/middleware/recovery.go | 25 ++ .../transport/http/middleware/request_id.go | 29 ++ internal/transport/http/middleware/timeout.go | 18 + internal/transport/http/router.go | 54 +++ internal/transport/http/user.go | 49 +++ internal/transport/httputil/response.go | 158 +++++++++ migrations/0001_init.down.sql | 6 + migrations/0001_init.up.sql | 50 +++ migrations/0002_idempotency.down.sql | 1 + migrations/0002_idempotency.up.sql | 18 + scripts/collect-evidence.sh | 67 ++++ scripts/init-secrets.sh | 16 + scripts/restart.sh | 16 + scripts/restore.sh | 17 + scripts/rolling-update.sh | 35 ++ scripts/stop-one.sh | 25 ++ scripts/track1.py | 316 +++++++++++++++++ scripts/track1_report.py | 304 ++++++++++++++++ scripts/win/restart.cmd | 3 + scripts/win/restore.cmd | 3 + scripts/win/stop-one.cmd | 3 + tests/failover_series.py | 171 +++++++++ tests/idempotency_concurrent.py | 89 +++++ tests/negative.py | 58 ++++ 68 files changed, 4747 insertions(+), 17 deletions(-) create mode 100644 .github/workflows/lab3-stand.yml create mode 100644 Dockerfile create mode 100644 cmd/api/main.go create mode 100644 cmd/bench/main.go create mode 100644 compose.yaml create mode 100644 evidence/idempotency_concurrent_native.json create mode 100644 evidence/local_native_check.txt create mode 100644 experiments/track1.json create mode 100644 go.mod create mode 100644 go.sum create mode 100644 infra/haproxy/haproxy.cfg create mode 100644 internal/config/config.go create mode 100644 internal/domain/chat.go create mode 100644 internal/domain/message.go create mode 100644 internal/domain/session.go create mode 100644 internal/domain/user.go create mode 100644 internal/repository/postgres/chat.go create mode 100644 internal/repository/postgres/message.go create mode 100644 internal/repository/postgres/pool.go create mode 100644 internal/repository/postgres/user.go create mode 100644 internal/repository/redis/message_cache.go create mode 100644 internal/repository/redis/session.go create mode 100644 internal/repository/repository.go create mode 100644 internal/service/auth.go create mode 100644 internal/service/chat.go create mode 100644 internal/service/cursor.go create mode 100644 internal/service/errors.go create mode 100644 internal/service/id.go create mode 100644 internal/service/message.go create mode 100644 internal/service/password.go create mode 100644 internal/service/user.go create mode 100644 internal/service/validate.go create mode 100644 internal/transport/http/auth.go create mode 100644 internal/transport/http/chat.go create mode 100644 internal/transport/http/health.go create mode 100644 internal/transport/http/internal_stats.go create mode 100644 internal/transport/http/message.go create mode 100644 internal/transport/http/middleware/auth.go create mode 100644 internal/transport/http/middleware/instance.go create mode 100644 internal/transport/http/middleware/logging.go create mode 100644 internal/transport/http/middleware/recovery.go create mode 100644 internal/transport/http/middleware/request_id.go create mode 100644 internal/transport/http/middleware/timeout.go create mode 100644 internal/transport/http/router.go create mode 100644 internal/transport/http/user.go create mode 100644 internal/transport/httputil/response.go create mode 100644 migrations/0001_init.down.sql create mode 100644 migrations/0001_init.up.sql create mode 100644 migrations/0002_idempotency.down.sql create mode 100644 migrations/0002_idempotency.up.sql create mode 100755 scripts/collect-evidence.sh create mode 100755 scripts/init-secrets.sh create mode 100755 scripts/restart.sh create mode 100755 scripts/restore.sh create mode 100755 scripts/rolling-update.sh create mode 100755 scripts/stop-one.sh create mode 100644 scripts/track1.py create mode 100644 scripts/track1_report.py create mode 100644 scripts/win/restart.cmd create mode 100644 scripts/win/restore.cmd create mode 100644 scripts/win/stop-one.cmd create mode 100644 tests/failover_series.py create mode 100644 tests/idempotency_concurrent.py create mode 100644 tests/negative.py diff --git a/.dockerignore b/.dockerignore index bc16e556..a77c4191 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,5 @@ __pycache__ node_modules evidence .DS_Store +bin +experiments diff --git a/.env.example b/.env.example index d32b9be0..b6af8723 100644 --- a/.env.example +++ b/.env.example @@ -7,7 +7,18 @@ SESSION_TTL_SECONDS=3600 # Choose credentials locally. File paths contain no secret values. DATABASE_URL_FILE=/run/secrets/database_url # Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres +SESSION_STORE=redis CACHE_URL_FILE=/run/secrets/cache_url API_REPLICAS=2 IDEMPOTENCY_TTL_SECONDS=86400 +# Graceful shutdown: after SIGTERM readiness=503 for DRAIN_DELAY, then Shutdown up to SHUTDOWN_TIMEOUT. +DRAIN_DELAY=3s +SHUTDOWN_TIMEOUT=8s +# Tuning knobs (track 1 experiments; defaults shown). +DB_POOL_MAX=20 +CACHE_INVALIDATION=version +LB_BALANCE=roundrobin +API_CPUS=0.50 +API_MEMORY=256M +PG_CPUS=1.00 +PG_MAX_CONNECTIONS=100 diff --git a/.github/workflows/lab3-stand.yml b/.github/workflows/lab3-stand.yml new file mode 100644 index 00000000..ae002123 --- /dev/null +++ b/.github/workflows/lab3-stand.yml @@ -0,0 +1,91 @@ +# Реальный прогон Docker-стенда lab3 на GitHub-hosted runner (ubuntu, 4 vCPU / 16 GB). +# Нужен потому, что на машине разработки нет аппаратной виртуализации для Docker Desktop. +# Все результаты — настоящие измерения; сокращённая методика трека 1 описана в REPORT.md. +name: lab3 stand + +on: + push: + branches: [lab3] + workflow_dispatch: + +permissions: + contents: read + +env: + PYTHONUTF8: "1" + +jobs: + levels-3-4: + name: Уровни 3–4 (smoke, failover, persistence, идемпотентность, серия отказов, rolling update) + runs-on: ubuntu-24.04 + timeout-minutes: 30 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Секреты и запуск стенда + run: | + chmod +x scripts/*.sh + sh scripts/init-secrets.sh + docker compose --env-file .env config --quiet + docker compose --env-file .env up -d --build --wait + - name: make check + сбор доказательств + run: | + make check PYTHON=python + PYTHON=python sh scripts/collect-evidence.sh + - name: Окружение runner + if: always() + run: | + { nproc; free -m; docker version --format '{{.Server.Version}}'; docker compose version; } > evidence/runner.txt + docker compose ps -a > evidence/docker_ps_final.txt || true + docker compose logs --no-color lb > evidence/lb_log.txt 2>&1 || true + - uses: actions/upload-artifact@v4 + if: always() + with: + name: evidence-levels-3-4 + path: evidence/ + + track1: + name: Трек 1 — ${{ matrix.series }} + runs-on: ubuntu-24.04 + timeout-minutes: 40 + strategy: + fail-fast: false + matrix: + include: + - series: A_fixed_total + configs: "" + levels: "4,16,64" + - series: B_scale_out + configs: "1x0.50,2x0.50,4x0.50" + levels: "4,16,64" + - series: D_improvement + configs: "" + levels: "32,64" + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + - uses: actions/setup-go@v5 + with: + go-version-file: go.mod + - name: Секреты + run: chmod +x scripts/*.sh && sh scripts/init-secrets.sh + - name: Серия ${{ matrix.series }} + run: | + python scripts/track1.py --series ${{ matrix.series }} \ + --configs "${{ matrix.configs }}" --levels "${{ matrix.levels }}" \ + --duration 15s --warmup 3s --repeats 3 \ + --output evidence/track1/raw_${{ matrix.series }}.jsonl + - name: Окружение runner + if: always() + run: | + mkdir -p evidence/track1 + { nproc; free -m; lscpu | grep -E 'Model name|^CPU\(s\)'; } > evidence/track1/runner_${{ matrix.series }}.txt + - uses: actions/upload-artifact@v4 + if: always() + with: + name: track1-${{ matrix.series }} + path: evidence/track1/ diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..7bbb0a8c --- /dev/null +++ b/Dockerfile @@ -0,0 +1,54 @@ +# ============================================================ +# Stage 1: builder — компилируем статический бинарник +# ============================================================ +FROM golang:1.26-alpine AS builder + +WORKDIR /src + +# Сначала манифесты зависимостей — кэшируем слой. +COPY go.mod go.sum ./ +RUN go mod download + +# Затем исходники. +COPY . . + +# Статический бинарник с оптимизациями: +# CGO_ENABLED=0 — статическая линковка (не требует libc) +# -ldflags="-s -w" — убираем отладочную информацию +# -trimpath — убираем пути сборки из бинарника +RUN CGO_ENABLED=0 GOOS=linux go build \ + -ldflags="-s -w" \ + -trimpath \ + -o /out/api \ + ./cmd/api + +# ============================================================ +# Stage 2: runtime — минимальный образ только с бинарником +# ============================================================ +FROM alpine:3.20 + +# ca-certificates — для HTTPS в lab2+ +# tzdata — для корректной работы с временными зонами +RUN apk --no-cache add ca-certificates tzdata + +# Непривилегированный пользователь (UID/GID 1001). +RUN addgroup -g 1001 -S appgroup && \ + adduser -u 1001 -S appuser -G appgroup + +WORKDIR /app + +# Копируем бинарник и сразу выставляем владельца. +COPY --from=builder --chown=appuser:appgroup /out/api /app/api + +# Переключаемся на непривилегированного пользователя. +USER 1001:1001 + +# Информативно: какой порт слушает приложение. +EXPOSE 8080 + +# Healthcheck: readiness (БД + Redis + не в режиме drain). +HEALTHCHECK --interval=5s --timeout=2s --start-period=5s --retries=3 \ + CMD wget --spider -q http://localhost:8080/health/ready || exit 1 + +# Exec-форма CMD — критично для доставки SIGTERM в приложение. +CMD ["/app/api"] \ No newline at end of file diff --git a/Makefile b/Makefile index 5d86d171..af273256 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-failover +.PHONY: help check validate test load test-persistence test-failover up down test-idempotency test-failover-series track1 track1-quick track1-report help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -28,3 +28,29 @@ test-persistence: test-failover: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2) $(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +# --- Студенческие цели (lab3) --- +up: + sh scripts/init-secrets.sh + docker compose --env-file .env up -d --build --wait + +down: + docker compose --env-file .env stop + +test-idempotency: + $(PYTHON) tests/idempotency_concurrent.py --base-url "$(BASE_URL)" $(TLS_ARGS) + +test-failover-series: + $(PYTHON) tests/failover_series.py --base-url "$(BASE_URL)" $(TLS_ARGS) --output evidence/failover_series.json + +# --- Трек 5.1: цена масштабирования (отдельный compose-проект на :18080) --- +track1: + $(PYTHON) scripts/track1.py --resume + $(PYTHON) scripts/track1_report.py + +track1-quick: + $(PYTHON) scripts/track1.py --quick --output evidence/track1/raw_quick.jsonl + $(PYTHON) scripts/track1_report.py --input evidence/track1/raw_quick.jsonl --outdir evidence/track1/quick + +track1-report: + $(PYTHON) scripts/track1_report.py diff --git a/REPORT.md b/REPORT.md index c2679005..a1a19131 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,200 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Вейнмайер Андрей Андреевич, БВТ2303 +- Целевая оценка: 5 (уровни 3, 4 и трек 1 «Цена масштабирования») - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Основа: собственная lab2 — https://gitea.privcloud.tech/WeinmaierAndrew/mtusi2026lab2 +- Использованные источники: + - Контракт: contracts/openapi.json, contracts/README.md (раздел «Балансировка и повторная отправка») + - Go: net/http (Server.Shutdown), log/slog, sync/atomic, crypto/sha256 + - Библиотеки: github.com/jackc/pgx/v5, github.com/redis/go-redis/v9, golang.org/x/crypto/argon2 + - Документация: HAProxy 3.0 (server-template, resolvers, http-check, retry-on), Docker Compose services/deploy, PostgreSQL INSERT … ON CONFLICT + - AI-ассистент использован для переноса кода lab2, реализации идемпотентности, конфигурации LB и скриптов; код проверен вручную и тестами. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +### Версии +| Компонент | Образ / версия | +| --- | --- | +| API builder / runtime | golang:1.26-alpine / alpine:3.20 (multi-stage, бинарник static, USER 1001) | +| LB | haproxy:3.0.5-alpine | +| БД | postgres:16.4-alpine | +| Сессии + кэш | redis:7.4.1-alpine (AOF, appendfsync everysec) | +| Миграции | migrate/migrate:v4.17.0 | + +Prerequisites: Docker Engine/Desktop с Compose v2, Python 3.9+, POSIX shell (Linux/macOS/WSL или Git Bash). + +### Команды + +```sh +# 1. Локальные .env и secrets/ (случайный пароль БД; повторный запуск ничего не перезаписывает) +sh scripts/init-secrets.sh + +# 2. Проверка и запуск: postgres/redis → migrate (однократно) → api ×2 → lb +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --wait + +# 3. Готовность и проверки +curl -i http://localhost:8080/health/ready +make test +make test-failover ACTION_SCRIPT=scripts/stop-one.sh +sh scripts/restore.sh # вернуть остановленную реплику +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-idempotency +make test-failover-series + +# Все доказательства одной командой (пишет в evidence/): +sh scripts/collect-evidence.sh +``` + +Windows: `python3` там часто заглушка — используйте `make ... PYTHON=python` и `PYTHONUTF8=1`. Python на Windows не исполняет `.sh` напрямую (WinError 193), поэтому для публичных тестов есть обёртки: `ACTION_SCRIPT=scripts/win/stop-one.cmd`, `scripts/win/restart.cmd` (вызывают Git Bash). + +Число реплик: `API_REPLICAS` в `.env` или `docker compose up -d --scale api=4`. + +Остановка без потери данных: `docker compose --env-file .env stop`. +Намеренное удаление учебных данных: `docker compose --env-file .env down -v` (удаляет volumes pg_data и redis_data). ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +клиент ──► lb (HAProxy :8080, единственный опубликованный порт; :8404 stats, только 127.0.0.1) + │ roundrobin, active check GET /health/ready каждые 1 s, DNS Docker + ▼ + api × N (сеть front+back, портов наружу нет, без container_name) + │ + ├──► postgres (сеть back): users, chats, chat_members, messages, idempotency_keys + └──► redis (сеть back): сессии (AOF), кэш истории (версия чата) +migrate (one-shot) ──► postgres — до старта api +``` + +**Перенесено из lab2 без изменений:** API, валидация, Argon2id, keyset-пагинация, сессии в Redis с TTL (переживают рестарт благодаря AOF), кэш истории с версионированием чата. + +**Изменено в lab3:** + +1. **X-Instance-Id** — middleware на самом внешнем уровне, есть в каждом ответе API, включая ошибки и health. Значение = hostname процесса; в Docker это короткий ID контейнера, поэтому `stop-one.sh` однозначно находит контейнер (`docker compose ps -q api` + сравнение префикса). Переопределяется `INSTANCE_ID`. В lab7 будет заменён на непрозрачный alias. +2. **Идемпотентность POST сообщения** (`internal/repository/postgres/message.go`, миграция `0002_idempotency`): + - заголовок обязателен, `^[A-Za-z0-9._:-]{1,128}$`, иначе 400; + - область: `PRIMARY KEY (user_id, chat_id, key)` (метод всегда POST, путь задаётся chat_id); + - `request_hash` = SHA-256 от канонического JSON уже разобранного тела, поэтому порядок ключей/пробелы не важны; + - в **одной транзакции**: удалить просроченный ключ этой области → `INSERT message` → `INSERT idempotency_keys … ON CONFLICT DO NOTHING`. Конкурентный запрос с тем же ключом через другую реплику блокируется на уникальном индексе до COMMIT первой транзакции, получает конфликт, откатывает своё сообщение и возвращает сохранённое (тот же 201 и тот же Message) или 409 при другом body; + - если первая транзакция откатилась (транзиентная 5xx), ключ не фиксируется и повтор выполняется заново; + - авторизация и членство в чате проверяются до обращения к ключу, т. е. при каждом повторе; + - TTL `IDEMPOTENCY_TTL_SECONDS` (86400); фоновая очистка раз в час (идемпотентный DELETE, безопасен с любой реплики). +3. **Миграции** — отдельный one-shot сервис `migrate` (golang-migrate хранит версию и берёт advisory lock); `api` зависит от него через `service_completed_successfully`, поэтому реплики не гоняются за схему. DSN читается из secret, пароль не хранится в compose.yaml (в lab2 был захардкожен — исправлено). +4. **Graceful shutdown**: по SIGTERM `/health/ready` сразу отвечает 503, процесс продолжает обслуживать запросы `DRAIN_DELAY=3s` (HAProxy за это время исключает его: inter 1s × fall 2), затем `http.Server.Shutdown` с `SHUTDOWN_TIMEOUT=8s`. `stop_grace_period: 15s` > 3 + 8, поэтому SIGKILL не обрывает запросы. +5. **LB HAProxy**: `server-template api 8 api:8080` + `resolvers docker` (127.0.0.11) — новые/пересозданные реплики подхватываются без перезапуска LB; `retry-on conn-failure` + `option redispatch` — повтор только когда запрос ещё не отправлен, поэтому неидемпотентные POST /users и /chats не дублируются. Sticky sessions нет: состояние общее. +6. **Ресурсы** (переопределяются переменными для трека 1): api 0.5 CPU/256M, lb 0.5/128M, postgres 1.0/512M, redis 0.5/256M. Сети: `front` (lb↔api) и `back` (api↔хранилища) — LB не видит БД. + +**Критичные зависимости readiness:** PostgreSQL и Redis (сессии нужны каждому защищённому запросу) + флаг drain. `/health/live` — только жизнь процесса. + +**Тайминги обнаружения отказа:** +| Механизм | Параметры | Максимальное время | +| --- | --- | --- | +| Graceful stop (SIGTERM) | readiness 503 → inter 1s, fall 2 | ≈2 s, всё это время реплика ещё обслуживает запросы → ошибок нет | +| Падение процесса (kill) | conn refused → `retry-on conn-failure`, redispatch; check fall 2 | запросы перенаправляются сразу; из пула ≈2 s | +| Зависание без ответа | timeout server 15s, check timeout = inter | ≈2 s до исключения; запросы в полёте получат 504 | + +**Соответствие .env.example:** APP_HOST/APP_PORT/APP_ENV/SESSION_TTL_SECONDS/IDEMPOTENCY_TTL_SECONDS — как есть; DATABASE_URL_FILE и CACHE_URL_FILE — docker secrets `/run/secrets/*`; SESSION_STORE=redis (сессии в Redis с lab2); API_REPLICAS → `deploy.replicas`; DRAIN_DELAY/SHUTDOWN_TIMEOUT — добавлены. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +### Что уже проверено -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Docker Desktop на машине разработки не запускает движок (`backend state: hasNoVirtualization=true` — выключена аппаратная виртуализация / нет WSL2), поэтому логика приложения проверена **нативно**: PostgreSQL 17 (initdb), fakeredis (TCP) вместо Redis, 2 процесса API с разными `INSTANCE_ID` за временным round-robin прокси (заменитель HAProxy только для этой проверки). Это доказывает корректность кода, но **не** инфраструктуры Compose/HAProxy. + +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл | +| --- | --- | --- | --- | +| Публичный smoke | tests/smoke.py | PASS: lab3 public API scenario | evidence/local_native_check.txt | +| Негативные проверки lab2 | tests/negative.py | PASS | evidence/local_native_check.txt | +| Отказ реплики, ≥2 реплик до отказа | tests/resilience.py --mode failover | PASS, observed 2, 21 успешных записей, 7 ошибок переходного периода, первая запись после hook за 3.7 s, дублей нет | evidence/local_native_check.txt | +| Конкурентный повтор одного ключа через разные реплики | tests/idempotency_concurrent.py (10 раундов × 16 параллельно) | PASS: 160/160 → 201 с одинаковым Message, 1 сообщение на ключ, 2 реплики, 409 на другой body, ключ изолирован по чату/пользователю, посторонний — 404 | evidence/idempotency_concurrent_native.json | +| compose.yaml корректен | docker compose --env-file .env config --quiet | OK; 2 реплики, лимиты, опубликован только lb | — | + +### На Docker-стенде (заполнить после `sh scripts/collect-evidence.sh`) + +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл | +| --- | --- | --- | --- | +| ≥2 X-Instance-Id через LB с одной сессией | collect-evidence: instances + make test-failover | TODO | evidence/instances.txt | +| Публичный smoke | make test | TODO | evidence/smoke.txt | +| Отказ любой одной реплики ≤10 s | make test-failover ×2 + restore | TODO | evidence/failover_1.txt, failover_2.txt | +| Persistence с прежним токеном | make test-persistence ACTION_SCRIPT=scripts/restart.sh | TODO | evidence/persistence.txt | +| Идемпотентность параллельно | make test-idempotency | TODO | evidence/idempotency_concurrent.json | +| 4: поочерёдный отказ каждой реплики, RPS/ошибки/восстановление | make test-failover-series | TODO | evidence/failover_series.json | +| 4: rolling update под нагрузкой | scripts/rolling-update.sh + tests/load.py | TODO | evidence/rolling_update*.{txt,json} | +| 4: лимиты, нет портов api, нет container_name | docker compose config, docker compose ps | TODO | evidence/docker_ps.txt | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Методика (уровень 4), `tests/failover_series.py`: closed-loop нагрузка 4 потока через LB (POST сообщения с повтором того же ключа после неопределённого ответа + GET истории), прогрев 5 s; для каждой реплики по очереди `docker stop -t 15` → наблюдение 15 s → `docker start` → ожидание healthy и появления в ответах LB → 3 s паузы. Метрики: успешные RPS до/во время, число ошибок, время от начала остановки до последней ошибки, время, когда остановленная реплика последний раз ответила, время восстановления. В конце — полная история: нет дублей текста и ID, все подтверждённые сообщения на месте. + +Rolling update (`scripts/rolling-update.sh`): build → migrate → для каждой старой реплики `up --scale api=N+1 --no-recreate` → ждать healthy → `docker stop` старой (drain) → `rm`. Во время замены 60 s нагрузки `tests/load.py`. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| kill одного процесса API (нативно) | краткие ошибки, затем запись через вторую реплику | 7 ошибок, PASS | первая запись 3.7 s; потерь/дублей нет | +| docker stop реплики 1 под нагрузкой | 0–единицы ошибок благодаря drain | TODO | TODO | +| docker stop реплики 2 под нагрузкой | то же | TODO | TODO | +| rolling update | 0 ошибок | TODO | TODO | +| restart всего стенда | сессия и данные сохранены | TODO | TODO | + +## Трек 5.1: цена масштабирования + +### Вопрос и гипотезы + +Помогает ли добавление API-реплик, где точка насыщения стенда и почему рост реплик перестаёт помогать? Гипотезы записаны **до** измерений в [experiments/track1.json](experiments/track1.json): + +| Серия | Что меняем | Гипотеза | +| --- | --- | --- | +| A_fixed_total | 1×1.0 / 2×0.5 / 4×0.25 CPU API (сумма 1.0 CPU, 768M) | пиковый RPS не растёт (тот же бюджет), p95 немного хуже из-за накладных расходов процессов и пулов; выигрыш реплик — только отказоустойчивость | +| B_scale_out | 1/2/4/8 реплик по 0.5 CPU, БД 1.0, LB 0.5, Redis 0.5 | рост почти линейный, пока узкое место — CPU API; затем остановка на общей зависимости | +| C_shared_resources | 4×0.5 API; PG 1→2 CPU, LB 0.5→1, Redis 0.5→1 | RPS поднимает только рост ресурса той зависимости, которая насыщена в B | +| D_improvement | 4×0.5 API: baseline vs 3 кандидата | инвалидация кэша через SCAN (наследие lab2) делает O(keyspace/100) запросов к Redis на каждую запись; ключ с версией чата (`CACHE_INVALIDATION=version`, 1 INCR) поднимает RPS. Альтернативы: `DB_POOL_MAX=8`, `LB_BALANCE=leastconn` | + +### Методика (повторяемая) + +- Отдельный compose-проект `mtusi2026lab3-bench` (порт 18080, свои volumes) — рабочие данные стенда не трогаются. Конфигурация задаётся только переменными окружения compose (`API_REPLICAS`, `API_CPUS`, `API_MEMORY`, `PG_CPUS`, `LB_CPUS`, `REDIS_CPUS`, `DB_POOL_MAX`, `CACHE_INVALIDATION`, `LB_BALANCE`); образ API один и тот же. +- Нагрузка — [cmd/bench](cmd/bench/main.go) (Go, closed-loop): 50% POST сообщения с уникальным Idempotency-Key, 50% GET истории `limit=50`; 8 чатов × 2 участника; без повторов; таймаут 5 s. Уровни параллелизма 1/4/8/16/32/64, прогрев 5 s, измерение 30 s, 3 повтора (серия D: 16/32/64, 5 повторов). Поддерживается и open-loop (`-rate`) с отсчётом задержки от запланированного момента (поправка на coordinated omission). +- Фоновый keyspace Redis — 10 000 синтетических ключей `pad:*` (≈ активные сессии и прочие данные). Это параметр профиля: от него зависит цена SCAN. +- Во время каждого прогона ~1 раз в секунду: `docker stats` всех контейнеров (CPU нормируется на лимит роли) и `pg_stat_activity` (активные соединения); до/после — счётчики пула pgx каждой реплики (внутренний порт 9090, не публикуется и не проксируется LB, читается через `docker exec`). +- Правила анализа фиксированы в [scripts/track1_report.py](scripts/track1_report.py): медиана по повторам; насыщение — первый уровень, где RPS вырос < 10%; узкое место — роль с максимальной утилизацией CPU от лимита (≥ 0.85 — насыщена) + доля ожиданий пула; улучшение **подтверждено**, только если на уровнях ≥ точки насыщения min(RPS кандидата) > max(RPS baseline) по всем повторам, p95 не хуже и ошибок не больше. + +Запуск (Docker-стенд должен работать; основной стенд лучше остановить, чтобы не делить CPU): + +```sh +make track1-quick PYTHON=python # ~15 мин, 1 повтор — проверка, что всё работает +make track1 PYTHON=python # полная методика (~2–3 ч), продолжает после обрыва (--resume) +# Результаты: evidence/track1/raw.jsonl (сырые данные), summary.csv, summary.md, report.html (графики) +python scripts/track1.py --cleanup --series none # удалить bench-проект и его volumes +``` + +Перед прогоном зафиксировать в этом разделе: CPU/RAM хоста и лимиты Docker Desktop (скрипт пишет их в каждую строку raw.jsonl), версии образов. + +### Проверка инструментов (без Docker) + +Нативно (PostgreSQL 17, fakeredis, 2 процесса API в режимах `scan` и `version`, round-robin прокси) проверено: smoke и конкурентная идемпотентность проходят в обоих режимах кэша; `bin/bench` выдаёт корректную смесь (≈50/50) и распределение по репликам; `/internal/stats` отдаёт счётчики пула; `track1_report.py` строит таблицы, графики и вердикт по синтетическому файлу (не сохранён в evidence — это не результат). **Реальных измерений трека пока нет.** + +### Результаты + +TODO после `make track1`: перенести из evidence/track1/summary.md таблицы по сериям, графики из report.html и выводы: + +| Серия | Наблюдение | Узкое место (утилизация) | Вывод | +| --- | --- | --- | --- | +| A_fixed_total | TODO | TODO | TODO | +| B_scale_out | TODO | TODO | TODO: с какого N рост прекращается и почему | +| C_shared_resources | TODO | TODO | TODO: какой ресурс снимает насыщение | +| D_improvement | TODO | TODO | TODO: какое улучшение подтверждено (или ни одно) | + +### Ограничения трека + +- Один хост: генератор нагрузки, LB, API и БД делят физические ядра; лимиты Docker — это квоты CFS, а не выделенные ядра. Если пик упирается в CPU клиента, это видно по CPU хоста, и вывод о стенде делать нельзя. +- Closed-loop показывает пропускную способность при заданном параллелизме, но не задержку при фиксированной входящей нагрузке; для отдельных точек можно повторить с `-rate`. +- История растёт во время серии; GET читает первые 50 сообщений чата по индексу, поэтому стоимость чтения от объёма почти не зависит, но размер таблиц растёт. +- Утилизация из `docker stats` усредняется с шагом ~1–2 s; короткие всплески не видны. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Выдерживается отказ одной API-реплики (процесс/контейнер). Не выдерживается: отказ LB, PostgreSQL, Redis, хоста — это SPOF (один узел, БД не реплицирована). +- Миграции совместимы с работающей версией только при подходе expand→contract; `0002` только добавляет таблицу, поэтому старые реплики продолжают работать во время rolling update. Деструктивные миграции так применять нельзя. +- Idempotency-ключи хранятся в PostgreSQL рядом с сообщением — атомарность без распределённых транзакций, ценой одной лишней записи на POST. +- Ошибки, сгенерированные самим HAProxy (502/503/504), не содержат X-Instance-Id — это допускается контрактом. +- Результаты Docker-стенда (таблицы TODO выше) ещё не получены из-за отсутствия виртуализации на машине разработки; после включения VT-x/WSL2 — запустить `sh scripts/collect-evidence.sh` и заполнить таблицы. diff --git a/cmd/api/main.go b/cmd/api/main.go new file mode 100644 index 00000000..14b53ed9 --- /dev/null +++ b/cmd/api/main.go @@ -0,0 +1,151 @@ +package main + +import ( + "context" + "errors" + "log/slog" + "net/http" + "os" + "os/signal" + "sync/atomic" + "syscall" + "time" + + "github.com/charawein/mtusi2026lab3/internal/config" + "github.com/charawein/mtusi2026lab3/internal/repository/postgres" + redisrepo "github.com/charawein/mtusi2026lab3/internal/repository/redis" + "github.com/charawein/mtusi2026lab3/internal/service" + transporthttp "github.com/charawein/mtusi2026lab3/internal/transport/http" +) + +func main() { + cfg := config.Load() + logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: cfg.LogLevel})) + slog.SetDefault(logger) + + if cfg.DatabaseURL == "" { + slog.Error("DATABASE_URL_FILE is not set or empty") + os.Exit(1) + } + if cfg.CacheURL == "" { + slog.Error("CACHE_URL_FILE is not set or empty") + os.Exit(1) + } + + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + pool, err := postgres.NewPool(ctx, cfg.DatabaseURL, cfg.DBPoolMax) + cancel() + if err != nil { + slog.Error("connect to postgres", "err", err) + os.Exit(1) + } + defer pool.Close() + + rctx, rcancel := context.WithTimeout(context.Background(), 10*time.Second) + redisClient, err := redisrepo.NewClient(rctx, cfg.CacheURL) + rcancel() + if err != nil { + slog.Error("connect to redis", "err", err) + os.Exit(1) + } + defer redisClient.Close() + + userRepo := postgres.NewUserRepository(pool) + chatRepo := postgres.NewChatRepository(pool) + msgRepo := postgres.NewMessageRepository(pool) + sessRepo := redisrepo.NewSessionRepository(redisClient) + + userSvc := service.NewUserService(userRepo) + chatSvc := service.NewChatService(chatRepo, userRepo) + + var msgCache *redisrepo.MessageCache + if cfg.CacheEnabled { + msgCache = redisrepo.NewMessageCache(redisClient, cfg.CacheInvalidation) + } + msgSvc := service.NewMessageService(msgRepo, chatRepo, msgCache, cfg.IdempotencyTTL) + + authSvc := service.NewAuthService(userRepo, sessRepo, cfg.SessionTTL()) + + // draining выставляется по SIGTERM: /health/ready начинает отвечать 503, + // LB исключает реплику, и только затем закрывается listener. + var draining atomic.Bool + router := transporthttp.NewRouter(userSvc, chatSvc, msgSvc, authSvc, pool, redisClient, cfg.InstanceID, &draining) + + // Очистка просроченных ключей идемпотентности. Запрос идемпотентен, + // поэтому параллельный запуск на всех репликах безопасен. + cleanupCtx, cleanupStop := context.WithCancel(context.Background()) + defer cleanupStop() + go func() { + t := time.NewTicker(time.Hour) + defer t.Stop() + for { + select { + case <-cleanupCtx.Done(): + return + case <-t.C: + ctx, cancel := context.WithTimeout(cleanupCtx, 30*time.Second) + if n, err := msgRepo.DeleteExpiredKeys(ctx, cfg.IdempotencyTTL); err != nil { + slog.Warn("idempotency cleanup failed", "err", err) + } else if n > 0 { + slog.Info("idempotency keys expired", "deleted", n) + } + cancel() + } + } + }() + + srv := &http.Server{ + Addr: cfg.Addr(), + Handler: router, + ReadHeaderTimeout: 5 * time.Second, + ReadTimeout: 15 * time.Second, + WriteTimeout: 15 * time.Second, + IdleTimeout: 60 * time.Second, + } + + // Внутренний endpoint метрик для экспериментов (трек 1). Порт не публикуется + // и не проксируется LB: читается только через docker exec внутри контейнера. + internalSrv := &http.Server{ + Addr: cfg.InternalAddr, + Handler: transporthttp.NewInternalStatsHandler(pool, cfg), + ReadHeaderTimeout: 2 * time.Second, + } + go func() { + if err := internalSrv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { + slog.Warn("internal stats server failed", "err", err) + } + }() + defer internalSrv.Close() + + errCh := make(chan error, 1) + go func() { + slog.Info("server starting", "addr", cfg.Addr(), "instance_id", cfg.InstanceID) + if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { + errCh <- err + } + }() + + sigCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT) + defer stop() + + select { + case err := <-errCh: + slog.Error("server failed", "err", err) + os.Exit(1) + case <-sigCtx.Done(): + slog.Info("shutdown signal received, draining", "delay", cfg.DrainDelay) + } + + // Перестаём быть ready и даём LB время заметить это (inter*fall у HAProxy), + // продолжая обслуживать уже направленные к нам запросы. + draining.Store(true) + time.Sleep(cfg.DrainDelay) + + shutdownCtx, cancel := context.WithTimeout(context.Background(), cfg.ShutdownTimeout) + defer cancel() + if err := srv.Shutdown(shutdownCtx); err != nil { + slog.Error("graceful shutdown failed", "err", err) + os.Exit(1) + } + slog.Info("server stopped") +} diff --git a/cmd/bench/main.go b/cmd/bench/main.go new file mode 100644 index 00000000..71212ea1 --- /dev/null +++ b/cmd/bench/main.go @@ -0,0 +1,328 @@ +// Command bench — генератор нагрузки для трека 1 (цена масштабирования). +// +// Профиль: смесь POST сообщения (с Idempotency-Key) и GET истории (limit=50) +// по нескольким чатам; каждый запрос идёт через LB с Bearer-токеном. +// +// Режимы: +// - closed loop (-concurrency N): N воркеров, каждый ждёт ответ перед следующим +// запросом. Показывает пропускную способность при фиксированном параллелизме. +// - open loop (-rate R): запросы назначаются по расписанию R/s независимо от +// ответов; задержка считается от НАЗНАЧЕННОГО момента, поэтому ожидание в +// очереди клиента входит в latency (поправка на coordinated omission). +// +// Повторов нет: ошибка/timeout учитывается как ошибка. Токены не печатаются. +package main + +import ( + "bytes" + "crypto/rand" + "encoding/base64" + "encoding/hex" + "encoding/json" + "flag" + "fmt" + "io" + "math" + mrand "math/rand/v2" + "net" + "net/http" + "os" + "sort" + "sync" + "sync/atomic" + "time" +) + +type actor struct { + token string + chat string +} + +type sample struct { + write bool + ok bool + latency time.Duration + class string +} + +type result struct { + mu sync.Mutex + samples []sample + instances map[string]int + dropped atomic.Int64 +} + +func (r *result) add(s sample, instance string) { + r.mu.Lock() + r.samples = append(r.samples, s) + if instance != "" { + r.instances[instance]++ + } + r.mu.Unlock() +} + +func randHex(n int) string { + b := make([]byte, n) + _, _ = rand.Read(b) + return hex.EncodeToString(b) +} + +func main() { + base := flag.String("base-url", "http://localhost:8080", "LB URL") + duration := flag.Duration("duration", 30*time.Second, "measured duration") + warmup := flag.Duration("warmup", 5*time.Second, "warmup (not measured)") + concurrency := flag.Int("concurrency", 8, "closed-loop workers (ignored when -rate > 0)") + rate := flag.Float64("rate", 0, "open-loop arrival rate, req/s (0 = closed loop)") + maxInflight := flag.Int("max-inflight", 512, "open-loop: max concurrent requests; excess arrivals are dropped and counted") + writeRatio := flag.Float64("write-ratio", 0.5, "fraction of POST message") + chats := flag.Int("chats", 8, "number of chats/users") + timeout := flag.Duration("timeout", 5*time.Second, "per-request timeout") + label := flag.String("label", "", "free-form label copied to output") + out := flag.String("output", "", "append JSON line to file") + flag.Parse() + + transport := &http.Transport{ + MaxIdleConns: 2048, + MaxIdleConnsPerHost: 2048, + IdleConnTimeout: 30 * time.Second, + DialContext: (&net.Dialer{Timeout: 2 * time.Second}).DialContext, + } + client := &http.Client{Transport: transport, Timeout: *timeout} + + actors, err := setup(client, *base, *chats) + if err != nil { + fmt.Fprintln(os.Stderr, "setup failed:", err) + os.Exit(1) + } + + res := &result{instances: map[string]int{}} + var measuring atomic.Bool + var seq atomic.Int64 + + do := func(scheduled time.Time) { + n := seq.Add(1) + a := actors[int(n)%len(actors)] + // Независимо от выбора actor: иначе при чётном числе actor и 0.5 одни бы только писали. + write := mrand.Float64() < *writeRatio + var req *http.Request + if write { + body, _ := json.Marshal(map[string]string{"text": "bench " + randHex(8)}) + req, _ = http.NewRequest("POST", *base+"/api/v1/chats/"+a.chat+"/messages", bytes.NewReader(body)) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Idempotency-Key", randHex(16)) + } else { + req, _ = http.NewRequest("GET", *base+"/api/v1/chats/"+a.chat+"/messages?limit=50", nil) + } + req.Header.Set("Authorization", "Bearer "+a.token) + resp, err := client.Do(req) + lat := time.Since(scheduled) + s := sample{write: write, latency: lat} + inst := "" + switch { + case err != nil: + s.class = "transport" + if e, ok := err.(net.Error); ok && e.Timeout() { + s.class = "timeout" + } + default: + _, _ = io.Copy(io.Discard, resp.Body) + resp.Body.Close() + inst = resp.Header.Get("X-Instance-Id") + want := http.StatusOK + if write { + want = http.StatusCreated + } + s.ok = resp.StatusCode == want + if !s.ok { + s.class = fmt.Sprintf("http_%d", resp.StatusCode) + } + } + if measuring.Load() { + res.add(s, inst) + } + } + + start := time.Now() + measureStart := start.Add(*warmup) + end := measureStart.Add(*duration) + go func() { + time.Sleep(time.Until(measureStart)) + measuring.Store(true) + time.Sleep(time.Until(end)) + measuring.Store(false) + }() + + var wg sync.WaitGroup + if *rate > 0 { + sem := make(chan struct{}, *maxInflight) + interval := time.Duration(float64(time.Second) / *rate) + next := time.Now() + for next.Before(end) { + if d := time.Until(next); d > 0 { + time.Sleep(d) + } + scheduled := next + next = next.Add(interval) + select { + case sem <- struct{}{}: + wg.Add(1) + go func() { + defer wg.Done() + defer func() { <-sem }() + do(scheduled) + }() + default: + if measuring.Load() { + res.dropped.Add(1) + } + } + } + } else { + for i := 0; i < *concurrency; i++ { + wg.Add(1) + go func() { + defer wg.Done() + for time.Now().Before(end) { + do(time.Now()) + } + }() + } + } + wg.Wait() + + report := summarize(res, *duration) + report["label"] = *label + report["mode"] = map[bool]string{true: "open", false: "closed"}[*rate > 0] + report["concurrency"] = *concurrency + report["rate"] = *rate + report["write_ratio"] = *writeRatio + report["chats"] = *chats + report["duration_s"] = duration.Seconds() + report["warmup_s"] = warmup.Seconds() + report["timestamp"] = time.Now().UTC().Format(time.RFC3339) + line, _ := json.Marshal(report) + fmt.Println(string(line)) + if *out != "" { + f, err := os.OpenFile(*out, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o644) + if err == nil { + _, _ = f.Write(append(line, '\n')) + f.Close() + } + } +} + +func percentiles(lat []time.Duration) map[string]float64 { + if len(lat) == 0 { + return map[string]float64{"p50": 0, "p95": 0, "p99": 0, "max": 0} + } + sort.Slice(lat, func(i, j int) bool { return lat[i] < lat[j] }) + p := func(q float64) float64 { + i := int(math.Ceil(q*float64(len(lat)))) - 1 + if i < 0 { + i = 0 + } + return float64(lat[i].Microseconds()) / 1000 + } + return map[string]float64{"p50": p(.50), "p95": p(.95), "p99": p(.99), "max": float64(lat[len(lat)-1].Microseconds()) / 1000} +} + +func summarize(r *result, d time.Duration) map[string]any { + var all, w, rd []time.Duration + errs := map[string]int{} + ok, okW, okR := 0, 0, 0 + for _, s := range r.samples { + if !s.ok { + errs[s.class]++ + continue + } + ok++ + all = append(all, s.latency) + if s.write { + okW++ + w = append(w, s.latency) + } else { + okR++ + rd = append(rd, s.latency) + } + } + total := len(r.samples) + errN := total - ok + return map[string]any{ + "requests": total, + "ok": ok, + "errors": errN, + "error_ratio": ratio(errN, total), + "errors_by_class": errs, + "dropped": r.dropped.Load(), + "ok_rps": float64(ok) / d.Seconds(), + "ok_write_rps": float64(okW) / d.Seconds(), + "ok_read_rps": float64(okR) / d.Seconds(), + "latency_ms": percentiles(all), + "write_ms": percentiles(w), + "read_ms": percentiles(rd), + "instances": r.instances, + } +} + +func ratio(a, b int) float64 { + if b == 0 { + return 0 + } + return float64(a) / float64(b) +} + +// setup создаёт пары пользователей, сессии и по одному чату на пару. +func setup(c *http.Client, base string, n int) ([]actor, error) { + post := func(path string, body any, hdr map[string]string) (map[string]any, error) { + var rdr io.Reader + if body != nil { + raw, _ := json.Marshal(body) + rdr = bytes.NewReader(raw) + } + req, _ := http.NewRequest("POST", base+path, rdr) + 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 nil, err + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusCreated { + return nil, fmt.Errorf("POST %s: status %d", path, resp.StatusCode) + } + var m map[string]any + return m, json.NewDecoder(resp.Body).Decode(&m) + } + var actors []actor + for i := 0; i < n; i++ { + var ids [2]string + var tokens [2]string + for j := 0; j < 2; j++ { + name := "bench_" + randHex(6) + pw := "Bench-" + randHex(12) + u, err := post("/api/v1/users", map[string]string{"username": name, "display_name": "Bench", "password": pw}, nil) + if err != nil { + return nil, err + } + ids[j] = u["id"].(string) + cred := base64.StdEncoding.EncodeToString([]byte(name + ":" + pw)) + s, err := post("/api/v1/auth/sessions", nil, map[string]string{"Authorization": "Basic " + cred}) + if err != nil { + return nil, err + } + tokens[j] = s["token"].(string) + } + ch, err := post("/api/v1/chats", map[string]any{"title": "bench", "member_ids": []string{ids[0], ids[1]}}, + map[string]string{"Authorization": "Bearer " + tokens[0]}) + if err != nil { + return nil, err + } + chat := ch["id"].(string) + actors = append(actors, actor{token: tokens[0], chat: chat}, actor{token: tokens[1], chat: chat}) + } + return actors, nil +} diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..41db643f --- /dev/null +++ b/compose.yaml @@ -0,0 +1,131 @@ +# Lab3: клиент → HAProxy → API × N → общие PostgreSQL (данные, идемпотентность) и Redis (сессии, кэш). +# Запуск: scripts/init-secrets.sh && docker compose --env-file .env up -d --build --wait +name: mtusi2026lab3 + +x-api-env: &api-env + APP_HOST: ${APP_HOST:-0.0.0.0} + APP_PORT: ${APP_PORT:-8080} + APP_ENV: ${APP_ENV:-lab} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_STORE: ${SESSION_STORE:-redis} + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + DRAIN_DELAY: ${DRAIN_DELAY:-3s} + SHUTDOWN_TIMEOUT: ${SHUTDOWN_TIMEOUT:-8s} + DB_POOL_MAX: ${DB_POOL_MAX:-20} + CACHE_INVALIDATION: ${CACHE_INVALIDATION:-version} + +services: + lb: + image: haproxy:3.0.5-alpine + ports: + - "127.0.0.1:${LB_PORT:-8080}:8080" + - "127.0.0.1:${LB_STATS_PORT:-8404}:8404" + environment: + LB_BALANCE: ${LB_BALANCE:-roundrobin} + volumes: + - ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + depends_on: + api: + condition: service_healthy + restart: unless-stopped + networks: [front] + deploy: + resources: + limits: { cpus: "${LB_CPUS:-0.50}", memory: 128M } + + api: + build: . + image: mtusi2026lab3-api:local + # Без container_name и без ports: реплики доступны только через lb. + environment: *api-env + secrets: [database_url, cache_url] + depends_on: + migrate: + condition: service_completed_successfully + postgres: + condition: service_healthy + redis: + condition: service_healthy + healthcheck: + test: ["CMD", "wget", "--spider", "-q", "http://localhost:8080/health/ready"] + interval: 5s + timeout: 2s + retries: 3 + start_period: 5s + # DRAIN_DELAY + SHUTDOWN_TIMEOUT < stop_grace_period, иначе SIGKILL оборвёт запросы. + stop_grace_period: 15s + restart: unless-stopped + networks: [front, back] + deploy: + replicas: ${API_REPLICAS:-2} + resources: + limits: { cpus: "${API_CPUS:-0.50}", memory: "${API_MEMORY:-256M}" } + + # Однократные миграции до старта API: реплики не гоняются за схему. + migrate: + image: migrate/migrate:v4.17.0 + volumes: + - ./migrations:/migrations:ro + secrets: [database_url] + entrypoint: ["/bin/sh", "-c", "exec migrate -path /migrations -database \"$$(cat /run/secrets/database_url)\" up"] + depends_on: + postgres: + condition: service_healthy + restart: "no" + networks: [back] + + postgres: + image: postgres:16.4-alpine + command: ["postgres", "-c", "max_connections=${PG_MAX_CONNECTIONS:-100}"] + environment: + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + POSTGRES_DB: messenger + secrets: [postgres_password] + volumes: + - pg_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 5 + restart: unless-stopped + networks: [back] + deploy: + resources: + limits: { cpus: "${PG_CPUS:-1.00}", memory: "${PG_MEMORY:-512M}" } + + redis: + image: redis:7.4.1-alpine + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"] + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 5 + restart: unless-stopped + networks: [back] + deploy: + resources: + limits: { cpus: "${REDIS_CPUS:-0.50}", memory: 256M } + +networks: + # front: lb ↔ api; back: api ↔ хранилища. LB не видит БД. + front: + back: + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url + +volumes: + pg_data: + redis_data: diff --git a/evidence/idempotency_concurrent_native.json b/evidence/idempotency_concurrent_native.json new file mode 100644 index 00000000..0d310544 --- /dev/null +++ b/evidence/idempotency_concurrent_native.json @@ -0,0 +1,88 @@ +{ + "rounds": 10, + "parallel_per_round": 16, + "distinct_instances_seen": 2, + "duplicates_found": 0, + "per_round": [ + { + "round": 0, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 1, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 2, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 3, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 4, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 5, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 6, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 7, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 8, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 9, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + } + ] +} diff --git a/evidence/local_native_check.txt b/evidence/local_native_check.txt new file mode 100644 index 00000000..46f8a162 --- /dev/null +++ b/evidence/local_native_check.txt @@ -0,0 +1,15 @@ +# Нативная проверка логики приложения (НЕ Docker-стенд) +# Дата: 2026-10-23T08:43Z; Windows 10, Go go1.26.0, PostgreSQL 17 (локальный initdb), fakeredis 2.40 (TCP) вместо Redis, +# 2 процесса API (INSTANCE_ID=local-8081/local-8082) за временным round-robin прокси на Python (заменитель HAProxy только для этой проверки). +# Причина: Docker Desktop на машине разработки не стартует (backend state: hasNoVirtualization=true). + +$ python tests/smoke.py +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. + +$ python tests/negative.py +PASS: negative checks + +$ python tests/resilience.py --mode failover (hook: kill процесса TARGET_INSTANCE_ID) +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 21, "failed_attempts": 7, "first_recovery_seconds": 3.719} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/experiments/track1.json b/experiments/track1.json new file mode 100644 index 00000000..7ac811db --- /dev/null +++ b/experiments/track1.json @@ -0,0 +1,72 @@ +{ + "description": "Трек 1: цена масштабирования. Профиль: closed-loop, 50% POST сообщения / 50% GET истории limit=50, 8 чатов по 2 участника, без повторов. Отдельный compose-проект mtusi2026lab3-bench на порту 18080 — рабочие данные стенда не трогаются.", + "project": "mtusi2026lab3-bench", + "lb_port": 18080, + "base_env": { + "PG_CPUS": "1.00", + "PG_MEMORY": "512M", + "PG_MAX_CONNECTIONS": "200", + "LB_CPUS": "0.50", + "REDIS_CPUS": "0.50", + "DB_POOL_MAX": "20", + "CACHE_INVALIDATION": "scan", + "LB_BALANCE": "roundrobin", + "SESSION_TTL_SECONDS": "86400" + }, + "redis_padding_keys": 10000, + "load": { + "levels": [1, 4, 8, 16, 32, 64], + "duration": "30s", + "warmup": "5s", + "write_ratio": 0.5, + "chats": 8, + "repeats": 3 + }, + "series": [ + { + "name": "A_fixed_total", + "title": "Фиксированный суммарный бюджет API: 1.0 CPU / 768M", + "hypothesis": "При фиксированном суммарном CPU рост числа реплик не увеличивает пиковый RPS (тот же бюджет) и немного ухудшает p95 из-за накладных расходов на процесс и пул соединений; выигрыш реплик — только отказоустойчивость.", + "configs": [ + {"label": "1x1.00", "API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M"}, + {"label": "2x0.50", "API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M"}, + {"label": "4x0.25", "API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M"} + ] + }, + { + "name": "B_scale_out", + "title": "Рост ресурсов: реплики по 0.5 CPU, БД 1.0 CPU, LB 0.5 CPU", + "hypothesis": "Пиковый RPS растёт почти линейно, пока узкое место — CPU API; затем рост останавливается на общей зависимости (PostgreSQL, Redis или LB), чья утилизация CPU приближается к лимиту.", + "configs": [ + {"label": "1x0.50", "API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M"}, + {"label": "2x0.50", "API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M"}, + {"label": "4x0.50", "API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M"}, + {"label": "8x0.50", "API_REPLICAS": "8", "API_CPUS": "0.50", "API_MEMORY": "256M"} + ] + }, + { + "name": "C_shared_resources", + "title": "4×0.5 CPU API, меняем ресурсы общих зависимостей", + "hypothesis": "Если насыщение B вызвано общей зависимостью, увеличение её CPU поднимает пиковый RPS, а увеличение CPU других зависимостей — нет.", + "configs": [ + {"label": "pg1_lb0.5_redis0.5", "API_REPLICAS": "4", "API_CPUS": "0.50"}, + {"label": "pg2", "API_REPLICAS": "4", "API_CPUS": "0.50", "PG_CPUS": "2.00"}, + {"label": "lb1", "API_REPLICAS": "4", "API_CPUS": "0.50", "LB_CPUS": "1.00"}, + {"label": "redis1", "API_REPLICAS": "4", "API_CPUS": "0.50", "REDIS_CPUS": "1.00"} + ] + }, + { + "name": "D_improvement", + "title": "Кандидаты улучшения на 4×0.5 CPU", + "hypothesis": "Инвалидация кэша истории через SCAN (lab2) делает O(keyspace/100) запросов к Redis на каждую запись; ключ с версией чата (CACHE_INVALIDATION=version) делает 1 INCR и поднимает RPS записи при большом keyspace. Альтернативы: меньший пул на реплику, leastconn.", + "levels": [16, 32, 64], + "repeats": 5, + "configs": [ + {"label": "baseline_scan", "API_REPLICAS": "4", "API_CPUS": "0.50"}, + {"label": "cache_version", "API_REPLICAS": "4", "API_CPUS": "0.50", "CACHE_INVALIDATION": "version"}, + {"label": "pool_8", "API_REPLICAS": "4", "API_CPUS": "0.50", "DB_POOL_MAX": "8"}, + {"label": "leastconn", "API_REPLICAS": "4", "API_CPUS": "0.50", "LB_BALANCE": "leastconn"} + ] + } + ] +} diff --git a/go.mod b/go.mod new file mode 100644 index 00000000..335dbf9c --- /dev/null +++ b/go.mod @@ -0,0 +1,21 @@ +module github.com/charawein/mtusi2026lab3 + +go 1.26.0 + +require ( + github.com/google/uuid v1.6.0 + github.com/jackc/pgx/v5 v5.11.0 + github.com/redis/go-redis/v9 v9.23.0 + golang.org/x/crypto v0.58.0 +) + +require ( + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + go.uber.org/atomic v1.12.0 // indirect + golang.org/x/sync v0.24.0 // indirect + golang.org/x/sys v0.49.0 // indirect + golang.org/x/text v0.43.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..3f1c7851 --- /dev/null +++ b/go.sum @@ -0,0 +1,43 @@ +github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= +github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= +github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= +github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg= +github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= +github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= +github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw= +github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s= +github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= +github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs= +github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s= +go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE= +go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54= +golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w= +golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA= +golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= +golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA= +golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc= +golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/infra/haproxy/haproxy.cfg b/infra/haproxy/haproxy.cfg new file mode 100644 index 00000000..05fa5e61 --- /dev/null +++ b/infra/haproxy/haproxy.cfg @@ -0,0 +1,59 @@ +# HAProxy — единственная публичная точка входа (lab3). +# Backend-адреса берутся из встроенного DNS Docker (service name "api"), +# поэтому масштабирование/пересоздание реплик не требует перезапуска LB. + +global + log stdout format raw local0 info + maxconn 2048 + +defaults + mode http + log global + option httplog + option dontlognull + timeout connect 2s + timeout client 30s + timeout server 15s + timeout http-request 10s + timeout queue 5s + # Повтор только при ошибке установки соединения (запрос ещё не отправлен), + # поэтому неидемпотентные POST /users, /chats не дублируются. + retries 2 + retry-on conn-failure + option redispatch 1 + +resolvers docker + nameserver dns 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + # Как долго держать последний ответ DNS при ошибке/пропаже записи. + hold valid 5s + hold other 5s + hold refused 5s + hold nx 2s + hold timeout 5s + hold obsolete 2s + accepted_payload_size 8192 + +frontend public + bind :8080 + default_backend api + +backend api + # roundrobin по умолчанию; leastconn — вариант для эксперимента трека 1 (env LB_BALANCE). + balance "${LB_BALANCE}" + # Активная проверка готовности: 503 во время drain или без БД/Redis. + option httpchk + http-check send meth GET uri /health/ready + http-check expect status 200 + # Период проверки 1s, исключение после 2 неудач (~2s), возврат после 2 успехов. + default-server check inter 1s fastinter 500ms downinter 1s fall 2 rise 2 resolvers docker resolve-prefer ipv4 init-addr none + # До 8 слотов под реплики сервиса api; лишние слоты остаются в MAINT. + server-template api 8 api:8080 + +frontend stats + bind :8404 + stats enable + stats uri /stats + stats refresh 2s diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 00000000..0c28cfbb --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,113 @@ +package config + +import ( + "log/slog" + "os" + "strconv" + "strings" + "time" +) + +type Config struct { + Host string + Port string + Env string + SessionTTLSeconds int + DatabaseURL string + CacheURL string + SessionStore string + LogLevel slog.Level + ShutdownTimeout time.Duration + CacheEnabled bool + InstanceID string + IdempotencyTTL time.Duration + DrainDelay time.Duration + DBPoolMax int32 + CacheInvalidation string + InternalAddr string +} + +func Load() Config { + return Config{ + Host: getEnv("APP_HOST", "0.0.0.0"), + Port: getEnv("APP_PORT", "8080"), + Env: getEnv("APP_ENV", "lab"), + SessionTTLSeconds: getInt("SESSION_TTL_SECONDS", 3600), + DatabaseURL: readSecretFile("DATABASE_URL_FILE"), + CacheURL: readSecretFile("CACHE_URL_FILE"), + SessionStore: getEnv("SESSION_STORE", "postgres"), + LogLevel: parseLevel(getEnv("LOG_LEVEL", "info")), + ShutdownTimeout: parseDuration(getEnv("SHUTDOWN_TIMEOUT", "8s")), + CacheEnabled: getEnv("CACHE_ENABLED", "true") == "true", + InstanceID: instanceID(), + IdempotencyTTL: time.Duration(getInt("IDEMPOTENCY_TTL_SECONDS", 86400)) * time.Second, + DrainDelay: parseDuration(getEnv("DRAIN_DELAY", "3s")), + DBPoolMax: int32(max(1, getInt("DB_POOL_MAX", 20))), + CacheInvalidation: getEnv("CACHE_INVALIDATION", "version"), + InternalAddr: getEnv("INTERNAL_ADDR", ":9090"), + } +} + +// instanceID — идентификатор реплики для X-Instance-Id. По умолчанию hostname, +// который в Docker равен короткому ID контейнера: так stop-one.sh однозначно +// находит контейнер. В lab7 его заменит непрозрачный alias. +func instanceID() string { + if v := os.Getenv("INSTANCE_ID"); v != "" { + return v + } + if h, err := os.Hostname(); err == nil && h != "" { + return h + } + return "unknown" +} + +func (c Config) SessionTTL() time.Duration { + return time.Duration(c.SessionTTLSeconds) * time.Second +} + +func (c Config) Addr() string { return c.Host + ":" + c.Port } + +func getEnv(key, def string) string { + if v := os.Getenv(key); v != "" { + return v + } + return def +} + +func getInt(key string, def int) int { + if v := os.Getenv(key); v != "" { + if n, err := strconv.Atoi(v); err == nil { + return n + } + } + return def +} + +func readSecretFile(envKey string) string { + path := os.Getenv(envKey) + if path == "" { + return "" + } + b, err := os.ReadFile(path) + if err != nil { + slog.Warn("secret file not readable", "path", path, "err", err) + return "" + } + return strings.TrimSpace(string(b)) +} + +func parseLevel(s string) slog.Level { + var l slog.Level + if err := l.UnmarshalText([]byte(s)); err != nil { + return slog.LevelInfo + } + return l +} + +func parseDuration(s string) time.Duration { + d, err := time.ParseDuration(s) + if err != nil { + return 8 * time.Second + } + return d +} diff --git a/internal/domain/chat.go b/internal/domain/chat.go new file mode 100644 index 00000000..5307e69c --- /dev/null +++ b/internal/domain/chat.go @@ -0,0 +1,30 @@ +package domain + +import ( + "encoding/json" + "time" +) + +type Chat struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt time.Time `json:"created_at"` +} + +func (c Chat) MarshalJSON() ([]byte, error) { + type Alias Chat + members := c.MemberIDs + if members == nil { + members = []string{} + } + return json.Marshal(&struct { + Alias + MemberIDs []string `json:"member_ids"` + CreatedAt string `json:"created_at"` + }{ + Alias: Alias(c), + MemberIDs: members, + CreatedAt: c.CreatedAt.UTC().Truncate(time.Second).Format(time.RFC3339), + }) +} diff --git a/internal/domain/message.go b/internal/domain/message.go new file mode 100644 index 00000000..08099f4a --- /dev/null +++ b/internal/domain/message.go @@ -0,0 +1,25 @@ +package domain + +import ( + "encoding/json" + "time" +) + +type Message struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt time.Time `json:"created_at"` +} + +func (m Message) MarshalJSON() ([]byte, error) { + type Alias Message + return json.Marshal(&struct { + Alias + CreatedAt string `json:"created_at"` + }{ + Alias: Alias(m), + CreatedAt: m.CreatedAt.UTC().Truncate(time.Second).Format(time.RFC3339), + }) +} diff --git a/internal/domain/session.go b/internal/domain/session.go new file mode 100644 index 00000000..2a42b94a --- /dev/null +++ b/internal/domain/session.go @@ -0,0 +1,10 @@ +package domain + +import "time" + +type Session struct { + Token string `json:"token"` + UserID string `json:"-"` + ExpiresAt time.Time `json:"expires_at"` + CreatedAt time.Time `json:"-"` +} diff --git a/internal/domain/user.go b/internal/domain/user.go new file mode 100644 index 00000000..e1d91c41 --- /dev/null +++ b/internal/domain/user.go @@ -0,0 +1,25 @@ +package domain + +import ( + "encoding/json" + "time" +) + +type User struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt time.Time `json:"created_at"` +} + +// MarshalJSON форматирует CreatedAt в RFC3339 без микросекунд. +func (u User) MarshalJSON() ([]byte, error) { + type Alias User + return json.Marshal(&struct { + Alias + CreatedAt string `json:"created_at"` + }{ + Alias: Alias(u), + CreatedAt: u.CreatedAt.UTC().Truncate(time.Second).Format(time.RFC3339), + }) +} diff --git a/internal/repository/postgres/chat.go b/internal/repository/postgres/chat.go new file mode 100644 index 00000000..95349384 --- /dev/null +++ b/internal/repository/postgres/chat.go @@ -0,0 +1,159 @@ +package postgres + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" +) + +type ChatRepository struct { + pool *pgxpool.Pool +} + +func NewChatRepository(pool *pgxpool.Pool) *ChatRepository { + return &ChatRepository{pool: pool} +} + +func (r *ChatRepository) Create(ctx context.Context, chat *domain.Chat) error { + tx, err := r.pool.Begin(ctx) + if err != nil { + return fmt.Errorf("begin tx: %w", err) + } + defer func() { _ = tx.Rollback(ctx) }() + + const insertChat = `INSERT INTO chats (id, title, created_at) VALUES ($1::uuid, $2, $3)` + if _, err := tx.Exec(ctx, insertChat, chat.ID, chat.Title, chat.CreatedAt); err != nil { + return fmt.Errorf("insert chat: %w", err) + } + + const insertMember = `INSERT INTO chat_members (chat_id, user_id) VALUES ($1::uuid, $2::uuid)` + for _, uid := range chat.MemberIDs { + if _, err := tx.Exec(ctx, insertMember, chat.ID, uid); err != nil { + return fmt.Errorf("insert member %s: %w", uid, err) + } + } + + if err := tx.Commit(ctx); err != nil { + return fmt.Errorf("commit tx: %w", err) + } + return nil +} + +func (r *ChatRepository) GetByID(ctx context.Context, id string) (*domain.Chat, error) { + const q = `SELECT id, title, created_at FROM chats WHERE id = $1::uuid` + var c domain.Chat + err := r.pool.QueryRow(ctx, q, id).Scan(&c.ID, &c.Title, &c.CreatedAt) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, repository.ErrNotFound + } + return nil, fmt.Errorf("select chat: %w", err) + } + + const qMembers = `SELECT user_id FROM chat_members WHERE chat_id = $1::uuid ORDER BY user_id` + rows, err := r.pool.Query(ctx, qMembers, id) + if err != nil { + return nil, fmt.Errorf("select members: %w", err) + } + defer rows.Close() + c.MemberIDs = []string{} + for rows.Next() { + var uid string + if err := rows.Scan(&uid); err != nil { + return nil, fmt.Errorf("scan member: %w", err) + } + c.MemberIDs = append(c.MemberIDs, uid) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("iterate members: %w", err) + } + return &c, nil +} + +func (r *ChatRepository) IsMember(ctx context.Context, chatID, userID string) (bool, error) { + const q = `SELECT 1 FROM chat_members WHERE chat_id = $1::uuid AND user_id = $2::uuid` + var one int + err := r.pool.QueryRow(ctx, q, chatID, userID).Scan(&one) + if err == nil { + return true, nil + } + if !errors.Is(err, pgx.ErrNoRows) { + return false, fmt.Errorf("check membership: %w", err) + } + const qChat = `SELECT 1 FROM chats WHERE id = $1::uuid` + err = r.pool.QueryRow(ctx, qChat, chatID).Scan(&one) + if err == nil { + return false, nil + } + if errors.Is(err, pgx.ErrNoRows) { + return false, repository.ErrNotFound + } + return false, fmt.Errorf("check chat exists: %w", err) +} + +func (r *ChatRepository) ListByMember(ctx context.Context, userID string, cursor time.Time, cursorID string, limit int) ([]*domain.Chat, error) { + const qChats = ` + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE m.user_id = $1::uuid + AND (c.created_at, c.id) > ($2::timestamptz, $3::uuid) + ORDER BY c.created_at, c.id + LIMIT $4 + ` + rows, err := r.pool.Query(ctx, qChats, userID, cursor, cursorID, limit) + if err != nil { + return nil, fmt.Errorf("list chats: %w", err) + } + defer rows.Close() + + chats := []*domain.Chat{} + var chatIDs []string + for rows.Next() { + var c domain.Chat + if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil { + return nil, fmt.Errorf("scan chat: %w", err) + } + c.MemberIDs = []string{} + chats = append(chats, &c) + chatIDs = append(chatIDs, c.ID) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("iterate chats: %w", err) + } + if len(chats) == 0 { + return chats, nil + } + + const qMembers = `SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY($1::uuid[]) ORDER BY chat_id, user_id` + memberRows, err := r.pool.Query(ctx, qMembers, chatIDs) + if err != nil { + return nil, fmt.Errorf("list members: %w", err) + } + defer memberRows.Close() + + byChat := make(map[string][]string) + for memberRows.Next() { + var chatID, uid string + if err := memberRows.Scan(&chatID, &uid); err != nil { + return nil, fmt.Errorf("scan member: %w", err) + } + byChat[chatID] = append(byChat[chatID], uid) + } + if err := memberRows.Err(); err != nil { + return nil, fmt.Errorf("iterate members: %w", err) + } + for _, c := range chats { + if members, ok := byChat[c.ID]; ok { + c.MemberIDs = members + } + } + return chats, nil +} diff --git a/internal/repository/postgres/message.go b/internal/repository/postgres/message.go new file mode 100644 index 00000000..324afbe6 --- /dev/null +++ b/internal/repository/postgres/message.go @@ -0,0 +1,135 @@ +package postgres + +import ( + "context" + "fmt" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" +) + +type MessageRepository struct { + pool *pgxpool.Pool +} + +func NewMessageRepository(pool *pgxpool.Pool) *MessageRepository { + return &MessageRepository{pool: pool} +} + +func (r *MessageRepository) Create(ctx context.Context, msg *domain.Message) error { + const q = ` + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5) + ` + if _, err := r.pool.Exec(ctx, q, msg.ID, msg.ChatID, msg.SenderID, msg.Text, msg.CreatedAt); err != nil { + return fmt.Errorf("insert message: %w", err) + } + return nil +} + +// CreateIdempotent вставляет сообщение и ключ в одной транзакции. +// Конкурентные запросы с одним ключом сериализуются уникальным индексом +// idempotency_keys: второй INSERT ждёт завершения первой транзакции, после +// COMMIT получает конфликт (DO NOTHING), откатывает своё сообщение и читает +// уже сохранённое. Если первая транзакция откатилась (транзиентная ошибка), +// вторая просто продолжает — неуспешный результат не фиксируется. +func (r *MessageRepository) CreateIdempotent(ctx context.Context, msg *domain.Message, key, requestHash string, ttl time.Duration) (*domain.Message, bool, error) { + tx, err := r.pool.Begin(ctx) + if err != nil { + return nil, false, fmt.Errorf("begin tx: %w", err) + } + defer func() { _ = tx.Rollback(ctx) }() + + // Ключ старше TTL больше не защищает от повтора — освобождаем его. + const deleteExpired = ` + DELETE FROM idempotency_keys + WHERE user_id = $1::uuid AND chat_id = $2::uuid AND key = $3 + AND created_at < now() - make_interval(secs => $4) + ` + if _, err := tx.Exec(ctx, deleteExpired, msg.SenderID, msg.ChatID, key, ttl.Seconds()); err != nil { + return nil, false, fmt.Errorf("delete expired key: %w", err) + } + + const insertMsg = ` + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5) + ` + if _, err := tx.Exec(ctx, insertMsg, msg.ID, msg.ChatID, msg.SenderID, msg.Text, msg.CreatedAt); err != nil { + return nil, false, fmt.Errorf("insert message: %w", err) + } + + const insertKey = ` + INSERT INTO idempotency_keys (user_id, chat_id, key, request_hash, message_id) + VALUES ($1::uuid, $2::uuid, $3, $4, $5::uuid) + ON CONFLICT (user_id, chat_id, key) DO NOTHING + ` + tag, err := tx.Exec(ctx, insertKey, msg.SenderID, msg.ChatID, key, requestHash, msg.ID) + if err != nil { + return nil, false, fmt.Errorf("insert idempotency key: %w", err) + } + if tag.RowsAffected() == 1 { + if err := tx.Commit(ctx); err != nil { + return nil, false, fmt.Errorf("commit tx: %w", err) + } + return msg, true, nil + } + + // Ключ уже занят подтверждённой записью: наше сообщение не сохраняем. + _ = tx.Rollback(ctx) + + const selectStored = ` + SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.created_at + FROM idempotency_keys k + JOIN messages m ON m.id = k.message_id + WHERE k.user_id = $1::uuid AND k.chat_id = $2::uuid AND k.key = $3 + ` + var storedHash string + var m domain.Message + err = r.pool.QueryRow(ctx, selectStored, msg.SenderID, msg.ChatID, key). + Scan(&storedHash, &m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt) + if err != nil { + return nil, false, fmt.Errorf("select stored message: %w", err) + } + if storedHash != requestHash { + return nil, false, repository.ErrConflict + } + return &m, false, nil +} + +// DeleteExpiredKeys удаляет ключи старше TTL. Безопасно выполнять с любой реплики. +func (r *MessageRepository) DeleteExpiredKeys(ctx context.Context, ttl time.Duration) (int64, error) { + const q = `DELETE FROM idempotency_keys WHERE created_at < now() - make_interval(secs => $1)` + tag, err := r.pool.Exec(ctx, q, ttl.Seconds()) + if err != nil { + return 0, fmt.Errorf("delete expired keys: %w", err) + } + return tag.RowsAffected(), nil +} + +func (r *MessageRepository) ListByChat(ctx context.Context, chatID string, cursor time.Time, cursorID string, limit int) ([]*domain.Message, error) { + const q = ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1::uuid + AND (created_at, id) > ($2::timestamptz, $3::uuid) + ORDER BY created_at, id + LIMIT $4 + ` + rows, err := r.pool.Query(ctx, q, chatID, cursor, cursorID, limit) + if err != nil { + return nil, fmt.Errorf("list messages: %w", err) + } + defer rows.Close() + msgs := []*domain.Message{} + for rows.Next() { + var m domain.Message + if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil { + return nil, fmt.Errorf("scan message: %w", err) + } + msgs = append(msgs, &m) + } + return msgs, rows.Err() +} diff --git a/internal/repository/postgres/pool.go b/internal/repository/postgres/pool.go new file mode 100644 index 00000000..67c329f2 --- /dev/null +++ b/internal/repository/postgres/pool.go @@ -0,0 +1,39 @@ +package postgres + +import ( + "context" + "fmt" + "time" + + "github.com/jackc/pgx/v5/pgxpool" +) + +// NewPool создаёт пул соединений с PostgreSQL. +// Параметры ограничены, чтобы не перегрузить БД. +func NewPool(ctx context.Context, dsn string, maxConns int32) (*pgxpool.Pool, error) { + cfg, err := pgxpool.ParseConfig(dsn) + if err != nil { + return nil, fmt.Errorf("parse dsn: %w", err) + } + + cfg.MaxConns = maxConns + cfg.MinConns = min(2, maxConns) + cfg.MaxConnIdleTime = 5 * time.Minute + cfg.MaxConnLifetime = 30 * time.Minute + cfg.HealthCheckPeriod = 30 * time.Second + + pool, err := pgxpool.NewWithConfig(ctx, cfg) + if err != nil { + return nil, fmt.Errorf("create pool: %w", err) + } + + // Проверяем, что соединение работает. + pingCtx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + if err := pool.Ping(pingCtx); err != nil { + pool.Close() + return nil, fmt.Errorf("ping: %w", err) + } + + return pool, nil +} diff --git a/internal/repository/postgres/user.go b/internal/repository/postgres/user.go new file mode 100644 index 00000000..c18f4039 --- /dev/null +++ b/internal/repository/postgres/user.go @@ -0,0 +1,77 @@ +package postgres + +import ( + "context" + "errors" + "fmt" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" +) + +type UserRepository struct { + pool *pgxpool.Pool +} + +func NewUserRepository(pool *pgxpool.Pool) *UserRepository { + return &UserRepository{pool: pool} +} + +func (r *UserRepository) Create(ctx context.Context, user *domain.User, passwordHash string) error { + const q = ` + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES ($1::uuid, $2, $3, $4, $5) + ` + _, err := r.pool.Exec(ctx, q, user.ID, user.Username, user.DisplayName, passwordHash, user.CreatedAt) + if err != nil { + var pgErr *pgconn.PgError + if errors.As(err, &pgErr) && pgErr.Code == "23505" { + return repository.ErrConflict + } + return fmt.Errorf("insert user: %w", err) + } + return nil +} + +func (r *UserRepository) GetByID(ctx context.Context, id string) (*domain.User, error) { + const q = `SELECT id, username, display_name, created_at FROM users WHERE id = $1::uuid` + var u domain.User + err := r.pool.QueryRow(ctx, q, id).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, repository.ErrNotFound + } + return nil, fmt.Errorf("select user by id: %w", err) + } + return &u, nil +} + +func (r *UserRepository) GetByUsername(ctx context.Context, username string) (*domain.User, error) { + const q = `SELECT id, username, display_name, created_at FROM users WHERE username = $1` + var u domain.User + err := r.pool.QueryRow(ctx, q, username).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, repository.ErrNotFound + } + return nil, fmt.Errorf("select user by username: %w", err) + } + return &u, nil +} + +func (r *UserRepository) GetPasswordHash(ctx context.Context, userID string) (string, error) { + const q = `SELECT password_hash FROM users WHERE id = $1::uuid` + var hash string + err := r.pool.QueryRow(ctx, q, userID).Scan(&hash) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return "", repository.ErrNotFound + } + return "", fmt.Errorf("select password hash: %w", err) + } + return hash, nil +} diff --git a/internal/repository/redis/message_cache.go b/internal/repository/redis/message_cache.go new file mode 100644 index 00000000..f1cb7b08 --- /dev/null +++ b/internal/repository/redis/message_cache.go @@ -0,0 +1,111 @@ +package redis + +import ( + "context" + "encoding/json" + "fmt" + "log/slog" + "time" + + "github.com/redis/go-redis/v9" + + "github.com/charawein/mtusi2026lab3/internal/domain" +) + +// Режимы инвалидации кэша истории (CACHE_INVALIDATION): +// - "scan" (поведение lab2): ключ без версии; запись делает INCR версии и +// удаляет ключи чата через SCAN — O(размер keyspace) запросов к Redis на запись; +// - "version": версия чата входит в ключ; запись делает только INCR, старые +// ключи становятся недостижимыми и истекают по TTL. O(1) на запись. +const ( + InvalidationScan = "scan" + InvalidationVersion = "version" +) + +type MessageCache struct { + client *redis.Client + versionedKeys bool +} + +func NewMessageCache(client *redis.Client, mode string) *MessageCache { + return &MessageCache{client: client, versionedKeys: mode != InvalidationScan} +} + +type cacheEntry struct { + Items []*domain.Message `json:"items"` + NextCursor string `json:"next_cursor"` +} + +func (c *MessageCache) cacheKey(chatID string, version int64, cursor string, limit int) string { + if c.versionedKeys { + return fmt.Sprintf("messages:%s:v%d:%s:%d", chatID, version, cursor, limit) + } + return fmt.Sprintf("messages:%s:%s:%d", chatID, cursor, limit) +} + +func versionKey(chatID string) string { + return "chat_version:" + chatID +} + +// GetVersion возвращает текущую версию чата. 0, если ключа нет. +func (c *MessageCache) GetVersion(ctx context.Context, chatID string) int64 { + v, err := c.client.Get(ctx, versionKey(chatID)).Int64() + if err != nil { + return 0 + } + return v +} + +// IncrVersion увеличивает версию чата. Используется в Send для инвалидации. +func (c *MessageCache) IncrVersion(ctx context.Context, chatID string) int64 { + v, err := c.client.Incr(ctx, versionKey(chatID)).Result() + if err != nil { + slog.Warn("redis incr version failed", "chat_id", chatID, "err", err) + return 0 + } + return v +} + +func (c *MessageCache) Get(ctx context.Context, chatID string, version int64, cursor string, limit int) ([]*domain.Message, string, bool) { + raw, err := c.client.Get(ctx, c.cacheKey(chatID, version, cursor, limit)).Bytes() + if err != nil { + return nil, "", false + } + var e cacheEntry + if err := json.Unmarshal(raw, &e); err != nil { + return nil, "", false + } + return e.Items, e.NextCursor, true +} + +func (c *MessageCache) Set(ctx context.Context, chatID string, version int64, cursor string, limit int, items []*domain.Message, next string) { + e := cacheEntry{Items: items, NextCursor: next} + raw, err := json.Marshal(e) + if err != nil { + slog.Warn("marshal cache entry failed", "err", err) + return + } + if err := c.client.Set(ctx, c.cacheKey(chatID, version, cursor, limit), raw, 30*time.Second).Err(); err != nil { + // Redis недоступен — не падаем, работаем без кэша. + slog.Warn("redis set failed", "chat_id", chatID, "err", err) + } +} + +// OnWrite вызывается после успешной записи сообщения, до ответа клиенту. +// Ошибки Redis игнорируются — при недоступности кэш устареет по TTL. +func (c *MessageCache) OnWrite(ctx context.Context, chatID string) { + c.IncrVersion(ctx, chatID) + if !c.versionedKeys { + _ = c.Invalidate(ctx, chatID) + } +} + +// Invalidate удаляет все ключи messages:{chatID}:* через SCAN. +func (c *MessageCache) Invalidate(ctx context.Context, chatID string) error { + pattern := fmt.Sprintf("messages:%s:*", chatID) + iter := c.client.Scan(ctx, 0, pattern, 100).Iterator() + for iter.Next(ctx) { + _ = c.client.Del(ctx, iter.Val()).Err() + } + return iter.Err() +} diff --git a/internal/repository/redis/session.go b/internal/repository/redis/session.go new file mode 100644 index 00000000..892070aa --- /dev/null +++ b/internal/repository/redis/session.go @@ -0,0 +1,73 @@ +package redis + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/redis/go-redis/v9" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" +) + +type SessionRepository struct { + client *redis.Client +} + +func NewSessionRepository(client *redis.Client) *SessionRepository { + return &SessionRepository{client: client} +} + +func (r *SessionRepository) Create(ctx context.Context, s *domain.Session) error { + key := "session:" + s.Token + ttl := time.Until(s.ExpiresAt) + if ttl <= 0 { + return fmt.Errorf("session already expired") + } + if err := r.client.Set(ctx, key, s.UserID, ttl).Err(); err != nil { + return fmt.Errorf("set session: %w", err) + } + return nil +} + +func (r *SessionRepository) GetByToken(ctx context.Context, token string) (*domain.Session, error) { + key := "session:" + token + userID, err := r.client.Get(ctx, key).Result() + if err != nil { + if errors.Is(err, redis.Nil) { + return nil, repository.ErrNotFound + } + return nil, fmt.Errorf("get session: %w", err) + } + ttl, err := r.client.TTL(ctx, key).Result() + if err != nil { + return nil, fmt.Errorf("ttl: %w", err) + } + return &domain.Session{ + Token: token, + UserID: userID, + ExpiresAt: time.Now().UTC().Add(ttl), + }, nil +} + +func (r *SessionRepository) Delete(ctx context.Context, token string) error { + return r.client.Del(ctx, "session:"+token).Err() +} + +func (r *SessionRepository) DeleteExpired(ctx context.Context) error { + return nil +} + +func NewClient(ctx context.Context, url string) (*redis.Client, error) { + opts, err := redis.ParseURL(url) + if err != nil { + return nil, fmt.Errorf("parse redis url: %w", err) + } + client := redis.NewClient(opts) + if err := client.Ping(ctx).Err(); err != nil { + return nil, fmt.Errorf("ping redis: %w", err) + } + return client, nil +} diff --git a/internal/repository/repository.go b/internal/repository/repository.go new file mode 100644 index 00000000..0baad7b2 --- /dev/null +++ b/internal/repository/repository.go @@ -0,0 +1,55 @@ +package repository + +import ( + "context" + "time" + + "github.com/charawein/mtusi2026lab3/internal/domain" +) + +var ErrNotFound = errNotFound{} + +type errNotFound struct{} + +func (errNotFound) Error() string { return "not found" } + +var ErrConflict = errConflict{} + +type errConflict struct{} + +func (errConflict) Error() string { return "conflict" } + +// UserRepository +type UserRepository interface { + Create(ctx context.Context, user *domain.User, passwordHash string) error + GetByID(ctx context.Context, id string) (*domain.User, error) + GetByUsername(ctx context.Context, username string) (*domain.User, error) + GetPasswordHash(ctx context.Context, userID string) (string, error) +} + +// ChatRepository +type ChatRepository interface { + Create(ctx context.Context, chat *domain.Chat) error + GetByID(ctx context.Context, id string) (*domain.Chat, error) + IsMember(ctx context.Context, chatID, userID string) (bool, error) + ListByMember(ctx context.Context, userID string, cursor time.Time, cursorID string, limit int) ([]*domain.Chat, error) +} + +// MessageRepository +type MessageRepository interface { + Create(ctx context.Context, msg *domain.Message) error + // CreateIdempotent атомарно создаёт сообщение и запись ключа идемпотентности. + // Если ключ уже есть с тем же requestHash — возвращает ранее созданное сообщение + // и created=false; с другим requestHash — ErrConflict. + CreateIdempotent(ctx context.Context, msg *domain.Message, key, requestHash string, ttl time.Duration) (stored *domain.Message, created bool, err error) + DeleteExpiredKeys(ctx context.Context, ttl time.Duration) (int64, error) + ListByChat(ctx context.Context, chatID string, cursor time.Time, cursorID string, limit int) ([]*domain.Message, error) +} + +// SessionRepository +type SessionRepository interface { + Create(ctx context.Context, s *domain.Session) error + GetByToken(ctx context.Context, token string) (*domain.Session, error) + Delete(ctx context.Context, token string) error + DeleteExpired(ctx context.Context) error +} diff --git a/internal/service/auth.go b/internal/service/auth.go new file mode 100644 index 00000000..f04d6e16 --- /dev/null +++ b/internal/service/auth.go @@ -0,0 +1,99 @@ +package service + +import ( + "context" + "crypto/rand" + "encoding/base64" + "errors" + "fmt" + "time" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" +) + +type AuthService struct { + users repository.UserRepository + sessions repository.SessionRepository + ttl time.Duration +} + +func NewAuthService(users repository.UserRepository, sessions repository.SessionRepository, ttl time.Duration) *AuthService { + return &AuthService{users: users, sessions: sessions, ttl: ttl} +} + +func (s *AuthService) Login(ctx context.Context, username, password string) (*domain.Session, *domain.User, error) { + u, err := s.users.GetByUsername(ctx, username) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + _, _ = hashPassword("dummy-password-for-timing") + return nil, nil, ErrUnauthorized + } + return nil, nil, err + } + + hash, err := s.users.GetPasswordHash(ctx, u.ID) + if err != nil { + return nil, nil, err + } + + if err := verifyPassword(password, hash); err != nil { + if errors.Is(err, ErrPasswordMismatch) { + return nil, nil, ErrUnauthorized + } + return nil, nil, fmt.Errorf("verify password: %w", err) + } + + token, err := generateToken() + if err != nil { + return nil, nil, fmt.Errorf("generate token: %w", err) + } + + now := nowUTC() + sess := &domain.Session{ + Token: token, + UserID: u.ID, + ExpiresAt: now.Add(s.ttl), + CreatedAt: now, + } + if err := s.sessions.Create(ctx, sess); err != nil { + return nil, nil, err + } + return sess, u, nil +} + +func (s *AuthService) ValidateSession(ctx context.Context, token string) (*domain.User, error) { + sess, err := s.sessions.GetByToken(ctx, token) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrUnauthorized + } + // Redis недоступен — возвращаем 401, чтобы клиент перелогинился, + // либо 503, если хотим явно показать проблему зависимости. + return nil, ErrUnauthorized // ← было: return nil, err + } + if nowUTC().After(sess.ExpiresAt) { + _ = s.sessions.Delete(ctx, token) + return nil, ErrUnauthorized + } + u, err := s.users.GetByID(ctx, sess.UserID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrUnauthorized + } + return nil, err + } + return u, nil +} + +func (s *AuthService) Logout(ctx context.Context, token string) error { + return s.sessions.Delete(ctx, token) +} + +func generateToken() (string, error) { + b := make([]byte, 32) + if _, err := rand.Read(b); err != nil { + return "", err + } + return base64.RawURLEncoding.EncodeToString(b), nil +} diff --git a/internal/service/chat.go b/internal/service/chat.go new file mode 100644 index 00000000..ce9bc8fd --- /dev/null +++ b/internal/service/chat.go @@ -0,0 +1,138 @@ +package service + +import ( + "context" + "errors" + "time" + + "github.com/google/uuid" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" +) + +type ChatService struct { + chats repository.ChatRepository + users repository.UserRepository +} + +func NewChatService(chats repository.ChatRepository, users repository.UserRepository) *ChatService { + return &ChatService{chats: chats, users: users} +} + +func (s *ChatService) Create(ctx context.Context, callerID, title string, memberIDs []string) (*domain.Chat, error) { + if !validateTitle(title) { + return nil, ErrInvalidInput + } + if len(memberIDs) == 0 || len(memberIDs) > 100 { + return nil, ErrInvalidInput + } + + // Нормализация UUID: убираем разницу регистра. + normalized := make([]string, 0, len(memberIDs)) + seen := make(map[string]struct{}, len(memberIDs)) + callerFound := false + callerParsed, err := uuid.Parse(callerID) + if err != nil { + return nil, ErrInvalidInput + } + callerID = callerParsed.String() + + for _, id := range memberIDs { + parsed, err := uuid.Parse(id) + if err != nil { + return nil, ErrInvalidInput + } + id = parsed.String() + if _, dup := seen[id]; dup { + return nil, ErrInvalidInput + } + seen[id] = struct{}{} + normalized = append(normalized, id) + if id == callerID { + callerFound = true + } + } + if !callerFound { + return nil, ErrInvalidInput + } + + for id := range seen { + if _, err := s.users.GetByID(ctx, id); err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrInvalidInput + } + return nil, err + } + } + + c := &domain.Chat{ + ID: newID(), + Title: title, + MemberIDs: normalized, + CreatedAt: nowUTC(), + } + if err := s.chats.Create(ctx, c); err != nil { + return nil, err + } + return c, nil +} + +func (s *ChatService) Get(ctx context.Context, callerID, chatID string) (*domain.Chat, error) { + parsed, err := uuid.Parse(chatID) + if err != nil { + return nil, ErrInvalidInput + } + chatID = parsed.String() + + ok, err := s.chats.IsMember(ctx, chatID, callerID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrNotFound + } + return nil, err + } + if !ok { + return nil, ErrNotFound + } + c, err := s.chats.GetByID(ctx, chatID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrNotFound + } + return nil, err + } + return c, nil +} + +func (s *ChatService) List(ctx context.Context, callerID, cursor string, limit int) ([]*domain.Chat, string, error) { + if limit < 1 || limit > 100 { + return nil, "", ErrInvalidInput + } + + cursorTime := time.Unix(0, 0).UTC() + cursorID := "00000000-0000-0000-0000-000000000000" + if cursor != "" { + t, id, err := decodeCursor(cursor, callerID) + if err != nil { + return nil, "", err + } + cursorTime, cursorID = t, id + } + + items, err := s.chats.ListByMember(ctx, callerID, cursorTime, cursorID, limit+1) + if err != nil { + return nil, "", err + } + if items == nil { + items = []*domain.Chat{} + } + + var next string + if len(items) > limit { + items = items[:limit] + last := items[limit-1] + next = encodeCursor(callerID, last.CreatedAt, last.ID) + } + return items, next, nil +} diff --git a/internal/service/cursor.go b/internal/service/cursor.go new file mode 100644 index 00000000..6839197f --- /dev/null +++ b/internal/service/cursor.go @@ -0,0 +1,39 @@ +package service + +import ( + "encoding/base64" + "strings" + "time" + + "github.com/google/uuid" +) + +func encodeCursor(scope string, createdAt time.Time, id string) string { + raw := scope + "|" + createdAt.UTC().Format(time.RFC3339Nano) + "|" + id + return base64.RawURLEncoding.EncodeToString([]byte(raw)) +} + +func decodeCursor(cursor, expectedScope string) (time.Time, string, error) { + raw, err := base64.RawURLEncoding.DecodeString(cursor) + if err != nil { + return time.Time{}, "", ErrInvalidInput + } + parts := strings.SplitN(string(raw), "|", 3) + if len(parts) != 3 { + return time.Time{}, "", ErrInvalidInput + } + if _, err := uuid.Parse(parts[0]); err != nil { + return time.Time{}, "", ErrInvalidInput + } + if parts[0] != expectedScope { + return time.Time{}, "", ErrInvalidInput + } + t, err := time.Parse(time.RFC3339Nano, parts[1]) + if err != nil { + return time.Time{}, "", ErrInvalidInput + } + if _, err := uuid.Parse(parts[2]); err != nil { + return time.Time{}, "", ErrInvalidInput + } + return t, parts[2], nil +} diff --git a/internal/service/errors.go b/internal/service/errors.go new file mode 100644 index 00000000..6ea9c84a --- /dev/null +++ b/internal/service/errors.go @@ -0,0 +1,12 @@ +package service + +import "errors" + +var ( + ErrInvalidInput = errors.New("invalid input") + ErrUnauthorized = errors.New("unauthorized") + ErrNotFound = errors.New("not found") + ErrConflict = errors.New("conflict") + ErrUnavailable = errors.New("unavailable") + ErrPasswordMismatch = errors.New("password mismatch") +) diff --git a/internal/service/id.go b/internal/service/id.go new file mode 100644 index 00000000..34874b45 --- /dev/null +++ b/internal/service/id.go @@ -0,0 +1,23 @@ +package service + +import ( + "crypto/rand" + "fmt" + "time" +) + +func newID() string { + var b [16]byte + if _, err := rand.Read(b[:]); err != nil { + panic(fmt.Sprintf("crypto/rand failed: %v", err)) + } + b[6] = (b[6] & 0x0f) | 0x40 + b[8] = (b[8] & 0x3f) | 0x80 + return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:16]) +} + +// nowUTC возвращает время UTC с точностью до секунд. +// PostgreSQL и Python-клиент тестов ожидают формат без наносекунд. +func nowUTC() time.Time { + return time.Now().UTC().Truncate(time.Second) +} diff --git a/internal/service/message.go b/internal/service/message.go new file mode 100644 index 00000000..9c04bcc1 --- /dev/null +++ b/internal/service/message.go @@ -0,0 +1,161 @@ +package service + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "errors" + "regexp" + "time" + + "github.com/google/uuid" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" + redisrepo "github.com/charawein/mtusi2026lab3/internal/repository/redis" +) + +type MessageService struct { + messages repository.MessageRepository + chats repository.ChatRepository + cache *redisrepo.MessageCache + idempotencyTTL time.Duration +} + +func NewMessageService(messages repository.MessageRepository, chats repository.ChatRepository, cache *redisrepo.MessageCache, idempotencyTTL time.Duration) *MessageService { + return &MessageService{messages: messages, chats: chats, cache: cache, idempotencyTTL: idempotencyTTL} +} + +var idempotencyKeyRe = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`) + +// requestHash — отпечаток семантики тела запроса. Хешируем уже разобранные поля, +// а не сырые байты, поэтому порядок ключей и пробелы в JSON не влияют на результат. +func requestHash(text string) string { + raw, _ := json.Marshal(struct { + Text string `json:"text"` + }{Text: text}) + sum := sha256.Sum256(raw) + return hex.EncodeToString(sum[:]) +} + +// Send создаёт сообщение с обязательным Idempotency-Key. Повтор с тем же ключом +// и телом возвращает исходное сообщение, с другим телом — ErrConflict. +// Доступ к чату проверяется при каждом повторе. +func (s *MessageService) Send(ctx context.Context, senderID, chatID, text, idempotencyKey string) (*domain.Message, error) { + if !idempotencyKeyRe.MatchString(idempotencyKey) { + return nil, ErrInvalidInput + } + parsed, err := uuid.Parse(chatID) + if err != nil { + return nil, ErrInvalidInput + } + chatID = parsed.String() + + if !validateText(text) { + return nil, ErrInvalidInput + } + ok, err := s.chats.IsMember(ctx, chatID, senderID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrNotFound + } + return nil, err + } + if !ok { + return nil, ErrNotFound + } + + m := &domain.Message{ + ID: newID(), + ChatID: chatID, + SenderID: senderID, + Text: text, + CreatedAt: nowUTC(), + } + stored, created, err := s.messages.CreateIdempotent(ctx, m, idempotencyKey, requestHash(text), s.idempotencyTTL) + if err != nil { + if errors.Is(err, repository.ErrConflict) { + return nil, ErrConflict + } + return nil, err + } + if !created { + return stored, nil + } + + // Инвалидация: увеличение версии чата (+ SCAN-удаление в режиме scan). + if s.cache != nil { + s.cache.OnWrite(ctx, chatID) + } + return m, nil +} + +func (s *MessageService) List(ctx context.Context, callerID, chatID, cursor string, limit int) ([]*domain.Message, string, error) { + parsed, err := uuid.Parse(chatID) + if err != nil { + return nil, "", ErrInvalidInput + } + chatID = parsed.String() + + if limit < 1 || limit > 100 { + return nil, "", ErrInvalidInput + } + + ok, err := s.chats.IsMember(ctx, chatID, callerID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, "", ErrNotFound + } + return nil, "", err + } + if !ok { + return nil, "", ErrNotFound + } + + // Проверяем кэш. Если версия изменилась между GetVersion и Get — не используем. + var versionBefore int64 + if s.cache != nil { + versionBefore = s.cache.GetVersion(ctx, chatID) // ← GetVersion не возвращает ошибку, ок + if items, next, hit := s.cache.Get(ctx, chatID, versionBefore, cursor, limit); hit { // ← Get: при ошибке false + // Проверяем, что версия не изменилась с момента Set + if s.cache.GetVersion(ctx, chatID) == versionBefore { + return items, next, nil + } + } + } + + cursorTime := time.Unix(0, 0).UTC() + cursorID := "00000000-0000-0000-0000-000000000000" + if cursor != "" { + t, id, err := decodeCursor(cursor, chatID) + if err != nil { + return nil, "", err + } + cursorTime, cursorID = t, id + } + + items, err := s.messages.ListByChat(ctx, chatID, cursorTime, cursorID, limit+1) + if err != nil { + return nil, "", err + } + if items == nil { + items = []*domain.Message{} + } + + var next string + if len(items) > limit { + items = items[:limit] + last := items[limit-1] + next = encodeCursor(chatID, last.CreatedAt, last.ID) + } + + // Записываем в кэш только если версия не изменилась за время чтения БД. + if s.cache != nil { + versionAfter := s.cache.GetVersion(ctx, chatID) + if versionBefore == versionAfter { + s.cache.Set(ctx, chatID, versionBefore, cursor, limit, items, next) + } + } + return items, next, nil +} diff --git a/internal/service/password.go b/internal/service/password.go new file mode 100644 index 00000000..f722a92c --- /dev/null +++ b/internal/service/password.go @@ -0,0 +1,66 @@ +package service + +import ( + "crypto/rand" + "crypto/subtle" + "encoding/base64" + "fmt" + "strings" + + "golang.org/x/crypto/argon2" +) + +const ( + argonTime = 1 + argonMemory = 64 * 1024 + argonThreads = 4 + argonKeyLen = 32 + argonSaltLen = 16 +) + +func hashPassword(password string) (string, error) { + salt := make([]byte, argonSaltLen) + if _, err := rand.Read(salt); err != nil { + return "", fmt.Errorf("generate salt: %w", err) + } + hash := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen) + return fmt.Sprintf( + "$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s", + argon2.Version, argonMemory, argonTime, argonThreads, + base64.RawStdEncoding.EncodeToString(salt), + base64.RawStdEncoding.EncodeToString(hash), + ), nil +} + +func verifyPassword(password, encoded string) error { + parts := strings.Split(encoded, "$") + if len(parts) != 6 || parts[1] != "argon2id" { + return fmt.Errorf("invalid hash format") + } + var version int + if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil { + return fmt.Errorf("parse version: %w", err) + } + if version != argon2.Version { + return fmt.Errorf("incompatible version: %d", version) + } + var mem uint32 + var iters uint32 + var threads uint8 + if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &mem, &iters, &threads); err != nil { + return fmt.Errorf("parse params: %w", err) + } + salt, err := base64.RawStdEncoding.DecodeString(parts[4]) + if err != nil { + return fmt.Errorf("decode salt: %w", err) + } + want, err := base64.RawStdEncoding.DecodeString(parts[5]) + if err != nil { + return fmt.Errorf("decode hash: %w", err) + } + got := argon2.IDKey([]byte(password), salt, iters, mem, threads, uint32(len(want))) + if subtle.ConstantTimeCompare(got, want) != 1 { + return ErrPasswordMismatch + } + return nil +} diff --git a/internal/service/user.go b/internal/service/user.go new file mode 100644 index 00000000..4c60c471 --- /dev/null +++ b/internal/service/user.go @@ -0,0 +1,64 @@ +package service + +import ( + "context" + "errors" + "fmt" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/repository" +) + +type UserService struct { + users repository.UserRepository +} + +func NewUserService(users repository.UserRepository) *UserService { + return &UserService{users: users} +} + +// Register создаёт нового пользователя. Возвращает ErrInvalidInput при невалидных +// данных и ErrConflict, если username занят. +func (s *UserService) Register(ctx context.Context, username, displayName, password string) (*domain.User, error) { + if !validateUsername(username) { + return nil, ErrInvalidInput + } + if !validateDisplayName(displayName) { + return nil, ErrInvalidInput + } + if !validatePassword(password) { + return nil, ErrInvalidInput + } + + hash, err := hashPassword(password) + if err != nil { + return nil, fmt.Errorf("hash password: %w", err) + } + + u := &domain.User{ + ID: newID(), + Username: username, + DisplayName: displayName, + CreatedAt: nowUTC(), + } + if err := s.users.Create(ctx, u, hash); err != nil { + if errors.Is(err, repository.ErrConflict) { + return nil, ErrConflict + } + return nil, err + } + return u, nil +} + +// GetByID возвращает пользователя. Возвращает ErrNotFound, если такого нет. +// Используется middleware аутентификации для проверки X-User-Id. +func (s *UserService) GetByID(ctx context.Context, id string) (*domain.User, error) { + u, err := s.users.GetByID(ctx, id) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrNotFound + } + return nil, err + } + return u, nil +} diff --git a/internal/service/validate.go b/internal/service/validate.go new file mode 100644 index 00000000..854c09d9 --- /dev/null +++ b/internal/service/validate.go @@ -0,0 +1,48 @@ +package service + +import ( + "regexp" + "strings" + "unicode/utf8" +) + +var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) + +func validatePassword(s string) bool { + n := utf8.RuneCountInString(s) + return n >= 12 && n <= 128 +} + +// validateUsername проверяет формат username по README: строго [a-z0-9_]{3,32}. +func validateUsername(s string) bool { + return usernameRe.MatchString(s) +} + +// validateDisplayName проверяет display_name: 1–100 Unicode code points, +// не состоит только из пробельных символов. +func validateDisplayName(s string) bool { + if strings.TrimSpace(s) == "" { + return false + } + n := utf8.RuneCountInString(s) + return n >= 1 && n <= 100 +} + +// validateTitle проверяет title чата: 1–100 code points, не только пробелы. +func validateTitle(s string) bool { + if strings.TrimSpace(s) == "" { + return false + } + n := utf8.RuneCountInString(s) + return n >= 1 && n <= 100 +} + +// validateText проверяет text сообщения: 1–4000 code points, не только пробелы. +// В lab4 появится возможность отправить пустой text, если есть attachment_ids. +func validateText(s string) bool { + if strings.TrimSpace(s) == "" { + return false + } + n := utf8.RuneCountInString(s) + return n >= 1 && n <= 4000 +} diff --git a/internal/transport/http/auth.go b/internal/transport/http/auth.go new file mode 100644 index 00000000..fff964e8 --- /dev/null +++ b/internal/transport/http/auth.go @@ -0,0 +1,92 @@ +package http + +import ( + "encoding/base64" + "net/http" + "strings" + "time" + + "github.com/charawein/mtusi2026lab3/internal/domain" + "github.com/charawein/mtusi2026lab3/internal/service" + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +type AuthHandler struct { + auth *service.AuthService +} + +func NewAuthHandler(auth *service.AuthService) *AuthHandler { + return &AuthHandler{auth: auth} +} + +type sessionResponse struct { + Token string `json:"token"` + TokenType string `json:"token_type"` + ExpiresAt string `json:"expires_at"` + User *domain.User `json:"user"` +} + +func (h *AuthHandler) CreateSession(w http.ResponseWriter, r *http.Request) { + username, password, ok := parseBasicAuth(r.Header.Get("Authorization")) + if !ok { + w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`) + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + sess, u, err := h.auth.Login(r.Context(), username, password) + if err != nil { + if err == service.ErrUnauthorized { + w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`) + } + httputil.WriteError(w, r, err) + return + } + + // Формат RFC3339 без микросекунд: "2026-10-09T19:00:36Z". + // Python-клиент тестов ожидает 'Z' в конце строки. + httputil.WriteJSON(w, r, http.StatusCreated, sessionResponse{ + Token: sess.Token, + TokenType: "Bearer", + ExpiresAt: sess.ExpiresAt.UTC().Truncate(time.Second).Format(time.RFC3339), + User: u, + }) +} + +func (h *AuthHandler) RevokeSession(w http.ResponseWriter, r *http.Request) { + token := bearerToken(r) + if token == "" { + w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`) + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + if err := h.auth.Logout(r.Context(), token); err != nil { + httputil.WriteError(w, r, err) + return + } + w.WriteHeader(http.StatusNoContent) +} + +func parseBasicAuth(h string) (string, string, bool) { + const prefix = "Basic " + if !strings.HasPrefix(h, prefix) { + return "", "", false + } + raw, err := base64.StdEncoding.DecodeString(h[len(prefix):]) + if err != nil { + return "", "", false + } + parts := strings.SplitN(string(raw), ":", 2) + if len(parts) != 2 { + return "", "", false + } + return parts[0], parts[1], true +} + +func bearerToken(r *http.Request) string { + h := r.Header.Get("Authorization") + if !strings.HasPrefix(h, "Bearer ") { + return "" + } + return strings.TrimPrefix(h, "Bearer ") +} diff --git a/internal/transport/http/chat.go b/internal/transport/http/chat.go new file mode 100644 index 00000000..48971798 --- /dev/null +++ b/internal/transport/http/chat.go @@ -0,0 +1,86 @@ +package http + +import ( + "log/slog" + "net/http" + + "github.com/charawein/mtusi2026lab3/internal/service" + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +type ChatHandler struct { + chats *service.ChatService +} + +func NewChatHandler(chats *service.ChatService) *ChatHandler { + return &ChatHandler{chats: chats} +} + +func (h *ChatHandler) CreateChat(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + var body struct { + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + } + if err := httputil.DecodeJSON(r, &body); err != nil { + httputil.WriteError(w, r, err) + return + } + + c, err := h.chats.Create(r.Context(), uid, body.Title, body.MemberIDs) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusCreated, c) +} + +func (h *ChatHandler) ListChats(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + limit, err := httputil.ParseLimit(r) + if err != nil { + httputil.WriteError(w, r, err) + return + } + cursor := r.URL.Query().Get("cursor") + + items, next, err := h.chats.List(r.Context(), uid, cursor, limit) + if err != nil { + // ВРЕМЕННО: логируем точную ошибку + slog.Error("ListChats failed", "err", err, "uid", uid, "cursor", cursor, "limit", limit) + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusOK, httputil.PageResponse{Items: items, NextCursor: httputil.NextOrNull(next)}) +} + +func (h *ChatHandler) GetChat(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + chatID := r.PathValue("chat_id") + if chatID == "" { + httputil.WriteError(w, r, service.ErrInvalidInput) + return + } + + c, err := h.chats.Get(r.Context(), uid, chatID) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusOK, c) +} diff --git a/internal/transport/http/health.go b/internal/transport/http/health.go new file mode 100644 index 00000000..393eeded --- /dev/null +++ b/internal/transport/http/health.go @@ -0,0 +1,54 @@ +package http + +import ( + "context" + "net/http" + "sync/atomic" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + "github.com/redis/go-redis/v9" + + "github.com/charawein/mtusi2026lab3/internal/service" + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +type HealthHandler struct { + pool *pgxpool.Pool + redis *redis.Client + draining *atomic.Bool +} + +func NewHealthHandler(pool *pgxpool.Pool, redisClient *redis.Client, draining *atomic.Bool) *HealthHandler { + return &HealthHandler{pool: pool, redis: redisClient, draining: draining} +} + +// Live проверяет только жизнь процесса. +func (h *HealthHandler) Live(w http.ResponseWriter, r *http.Request) { + httputil.WriteJSON(w, r, http.StatusOK, healthResponse{Status: "ok"}) +} + +// Ready проверяет доступность PostgreSQL и Redis. +// После SIGTERM возвращает 503, чтобы LB исключил реплику до закрытия listener. +func (h *HealthHandler) Ready(w http.ResponseWriter, r *http.Request) { + if h.draining.Load() { + httputil.WriteError(w, r, service.ErrUnavailable) + return + } + ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second) + defer cancel() + + if err := h.pool.Ping(ctx); err != nil { + httputil.WriteError(w, r, service.ErrUnavailable) + return + } + if err := h.redis.Ping(ctx).Err(); err != nil { + httputil.WriteError(w, r, service.ErrUnavailable) + return + } + httputil.WriteJSON(w, r, http.StatusOK, healthResponse{Status: "ok"}) +} + +type healthResponse struct { + Status string `json:"status"` +} diff --git a/internal/transport/http/internal_stats.go b/internal/transport/http/internal_stats.go new file mode 100644 index 00000000..e53c274d --- /dev/null +++ b/internal/transport/http/internal_stats.go @@ -0,0 +1,39 @@ +package http + +import ( + "encoding/json" + "net/http" + "runtime" + + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/charawein/mtusi2026lab3/internal/config" +) + +// NewInternalStatsHandler отдаёт счётчики пула PostgreSQL и рантайма Go. +// Нужен для поиска точки насыщения пула в экспериментах трека 1: +// рост empty_acquire_count/acquire_duration означает ожидание свободного соединения. +func NewInternalStatsHandler(pool *pgxpool.Pool, cfg config.Config) http.Handler { + mux := http.NewServeMux() + mux.HandleFunc("GET /internal/stats", func(w http.ResponseWriter, r *http.Request) { + st := pool.Stat() + body := map[string]any{ + "instance_id": cfg.InstanceID, + "cache_invalidation": cfg.CacheInvalidation, + "pool": map[string]any{ + "max_conns": st.MaxConns(), + "total_conns": st.TotalConns(), + "acquired_conns": st.AcquiredConns(), + "idle_conns": st.IdleConns(), + "acquire_count": st.AcquireCount(), + "empty_acquire_count": st.EmptyAcquireCount(), + "canceled_acquire_count": st.CanceledAcquireCount(), + "acquire_duration_ms": st.AcquireDuration().Milliseconds(), + }, + "goroutines": runtime.NumGoroutine(), + } + w.Header().Set("Content-Type", "application/json") + _ = json.NewEncoder(w).Encode(body) + }) + return mux +} diff --git a/internal/transport/http/message.go b/internal/transport/http/message.go new file mode 100644 index 00000000..c812ebe7 --- /dev/null +++ b/internal/transport/http/message.go @@ -0,0 +1,75 @@ +package http + +import ( + "net/http" + + "github.com/charawein/mtusi2026lab3/internal/service" + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +type MessageHandler struct { + messages *service.MessageService +} + +func NewMessageHandler(messages *service.MessageService) *MessageHandler { + return &MessageHandler{messages: messages} +} + +func (h *MessageHandler) SendMessage(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + chatID := r.PathValue("chat_id") + if chatID == "" { + httputil.WriteError(w, r, service.ErrInvalidInput) + return + } + + var body struct { + Text string `json:"text"` + } + if err := httputil.DecodeJSON(r, &body); err != nil { + httputil.WriteError(w, r, err) + return + } + + // Повтор с тем же ключом возвращает тот же 201 и то же сообщение. + key := r.Header.Get("Idempotency-Key") + m, err := h.messages.Send(r.Context(), uid, chatID, body.Text, key) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusCreated, m) +} + +func (h *MessageHandler) ListMessages(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + chatID := r.PathValue("chat_id") + if chatID == "" { + httputil.WriteError(w, r, service.ErrInvalidInput) + return + } + + limit, err := httputil.ParseLimit(r) + if err != nil { + httputil.WriteError(w, r, err) + return + } + cursor := r.URL.Query().Get("cursor") + + items, next, err := h.messages.List(r.Context(), uid, chatID, cursor, limit) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusOK, httputil.PageResponse{Items: items, NextCursor: httputil.NextOrNull(next)}) +} diff --git a/internal/transport/http/middleware/auth.go b/internal/transport/http/middleware/auth.go new file mode 100644 index 00000000..40040e6e --- /dev/null +++ b/internal/transport/http/middleware/auth.go @@ -0,0 +1,48 @@ +package middleware + +import ( + "errors" + "log/slog" + "net/http" + "strings" + + "github.com/charawein/mtusi2026lab3/internal/service" + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +// Auth проверяет Authorization: Bearer через AuthService. +func Auth(auth *service.AuthService) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + header := r.Header.Get("Authorization") + if !strings.HasPrefix(header, "Bearer ") { + writeUnauthorized(w, r) + return + } + token := strings.TrimPrefix(header, "Bearer ") + if token == "" { + writeUnauthorized(w, r) + return + } + + u, err := auth.ValidateSession(r.Context(), token) + if err != nil { + if errors.Is(err, service.ErrUnauthorized) { + writeUnauthorized(w, r) + return + } + slog.Error("auth: unexpected", "err", err) + httputil.WriteError(w, r, nil) + return + } + + ctx := httputil.ContextWithUserID(r.Context(), u.ID) + next.ServeHTTP(w, r.WithContext(ctx)) + }) + } +} + +func writeUnauthorized(w http.ResponseWriter, r *http.Request) { + w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`) + httputil.WriteError(w, r, service.ErrUnauthorized) +} diff --git a/internal/transport/http/middleware/instance.go b/internal/transport/http/middleware/instance.go new file mode 100644 index 00000000..46849b14 --- /dev/null +++ b/internal/transport/http/middleware/instance.go @@ -0,0 +1,14 @@ +package middleware + +import "net/http" + +// InstanceID добавляет X-Instance-Id ко всем ответам API, включая ошибки и health. +// Значение задаётся один раз при старте процесса и не меняется до его завершения. +func InstanceID(id string) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("X-Instance-Id", id) + next.ServeHTTP(w, r) + }) + } +} diff --git a/internal/transport/http/middleware/logging.go b/internal/transport/http/middleware/logging.go new file mode 100644 index 00000000..71174d1b --- /dev/null +++ b/internal/transport/http/middleware/logging.go @@ -0,0 +1,34 @@ +package middleware + +import ( + "log/slog" + "net/http" + "time" + + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +type statusRecorder struct { + http.ResponseWriter + status int +} + +func (r *statusRecorder) WriteHeader(code int) { + r.status = code + r.ResponseWriter.WriteHeader(code) +} + +func Logging(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + start := time.Now() + rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK} + next.ServeHTTP(rec, r) + slog.Info("http request", + "request_id", httputil.RequestIDFrom(r.Context()), + "method", r.Method, + "path", r.URL.Path, + "status", rec.status, + "duration_ms", time.Since(start).Milliseconds(), + ) + }) +} diff --git a/internal/transport/http/middleware/recovery.go b/internal/transport/http/middleware/recovery.go new file mode 100644 index 00000000..586f8175 --- /dev/null +++ b/internal/transport/http/middleware/recovery.go @@ -0,0 +1,25 @@ +package middleware + +import ( + "log/slog" + "net/http" + + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +func Recovery(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + defer func() { + if rec := recover(); rec != nil { + slog.Error("panic in handler", + "panic", rec, + "request_id", httputil.RequestIDFrom(r.Context()), + "method", r.Method, + "path", r.URL.Path, + ) + httputil.WriteError(w, r, nil) + } + }() + next.ServeHTTP(w, r) + }) +} diff --git a/internal/transport/http/middleware/request_id.go b/internal/transport/http/middleware/request_id.go new file mode 100644 index 00000000..cda3ba61 --- /dev/null +++ b/internal/transport/http/middleware/request_id.go @@ -0,0 +1,29 @@ +package middleware + +import ( + "crypto/rand" + "fmt" + "net/http" + + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +func RequestID(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + id := r.Header.Get("X-Request-Id") + if id == "" { + id = newRequestID() + } + w.Header().Set("X-Request-Id", id) + ctx := httputil.ContextWithRequestID(r.Context(), id) + next.ServeHTTP(w, r.WithContext(ctx)) + }) +} + +func newRequestID() string { + var b [12]byte + if _, err := rand.Read(b[:]); err != nil { + panic(fmt.Sprintf("crypto/rand failed: %v", err)) + } + return fmt.Sprintf("%x", b[:]) +} diff --git a/internal/transport/http/middleware/timeout.go b/internal/transport/http/middleware/timeout.go new file mode 100644 index 00000000..037d59bf --- /dev/null +++ b/internal/transport/http/middleware/timeout.go @@ -0,0 +1,18 @@ +package middleware + +import ( + "context" + "net/http" + "time" +) + +// Timeout ограничивает время выполнения запроса. +func Timeout(d time.Duration) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + ctx, cancel := context.WithTimeout(r.Context(), d) + defer cancel() + next.ServeHTTP(w, r.WithContext(ctx)) + }) + } +} diff --git a/internal/transport/http/router.go b/internal/transport/http/router.go new file mode 100644 index 00000000..90a069c5 --- /dev/null +++ b/internal/transport/http/router.go @@ -0,0 +1,54 @@ +package http + +import ( + "net/http" + "sync/atomic" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + "github.com/redis/go-redis/v9" + + "github.com/charawein/mtusi2026lab3/internal/service" + "github.com/charawein/mtusi2026lab3/internal/transport/http/middleware" +) + +func NewRouter( + users *service.UserService, + chats *service.ChatService, + messages *service.MessageService, + auth *service.AuthService, + pool *pgxpool.Pool, + redisClient *redis.Client, + instanceID string, + draining *atomic.Bool, +) http.Handler { + userH := NewUserHandler(users) + chatH := NewChatHandler(chats) + msgH := NewMessageHandler(messages) + authH := NewAuthHandler(auth) + healthH := NewHealthHandler(pool, redisClient, draining) + + mux := http.NewServeMux() + + mux.HandleFunc("GET /health/live", healthH.Live) + mux.HandleFunc("GET /health/ready", healthH.Ready) + mux.HandleFunc("POST /api/v1/users", userH.CreateUser) + mux.HandleFunc("POST /api/v1/auth/sessions", authH.CreateSession) + + authMW := middleware.Auth(auth) + + mux.Handle("DELETE /api/v1/auth/sessions/current", authMW(http.HandlerFunc(authH.RevokeSession))) + mux.Handle("GET /api/v1/users/me", authMW(http.HandlerFunc(userH.CurrentUser))) + mux.Handle("POST /api/v1/chats", authMW(http.HandlerFunc(chatH.CreateChat))) + mux.Handle("GET /api/v1/chats", authMW(http.HandlerFunc(chatH.ListChats))) + mux.Handle("GET /api/v1/chats/{chat_id}", authMW(http.HandlerFunc(chatH.GetChat))) + mux.Handle("POST /api/v1/chats/{chat_id}/messages", authMW(http.HandlerFunc(msgH.SendMessage))) + mux.Handle("GET /api/v1/chats/{chat_id}/messages", authMW(http.HandlerFunc(msgH.ListMessages))) + + handler := middleware.Logging(mux) + handler = middleware.Recovery(handler) + handler = middleware.Timeout(5 * time.Second)(handler) + handler = middleware.RequestID(handler) + handler = middleware.InstanceID(instanceID)(handler) + return handler +} diff --git a/internal/transport/http/user.go b/internal/transport/http/user.go new file mode 100644 index 00000000..3180e9df --- /dev/null +++ b/internal/transport/http/user.go @@ -0,0 +1,49 @@ +package http + +import ( + "net/http" + + "github.com/charawein/mtusi2026lab3/internal/service" + "github.com/charawein/mtusi2026lab3/internal/transport/httputil" +) + +type UserHandler struct { + users *service.UserService +} + +func NewUserHandler(users *service.UserService) *UserHandler { + return &UserHandler{users: users} +} + +func (h *UserHandler) CreateUser(w http.ResponseWriter, r *http.Request) { + var body struct { + Username string `json:"username"` + DisplayName string `json:"display_name"` + Password string `json:"password"` + } + if err := httputil.DecodeJSON(r, &body); err != nil { + httputil.WriteError(w, r, err) + return + } + + u, err := h.users.Register(r.Context(), body.Username, body.DisplayName, body.Password) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusCreated, u) +} + +func (h *UserHandler) CurrentUser(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + u, err := h.users.GetByID(r.Context(), uid) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusOK, u) +} diff --git a/internal/transport/httputil/response.go b/internal/transport/httputil/response.go new file mode 100644 index 00000000..0dbf4bf5 --- /dev/null +++ b/internal/transport/httputil/response.go @@ -0,0 +1,158 @@ +package httputil + +import ( + "context" + "encoding/json" + "errors" + "log/slog" + "net/http" + "strconv" + + "github.com/charawein/mtusi2026lab3/internal/service" +) + +// requestIDKey — ключ контекста для X-Request-Id. +type requestIDKey struct{} + +// ContextWithRequestID кладёт request_id в контекст. Используется middleware.RequestID. +func ContextWithRequestID(ctx context.Context, id string) context.Context { + return context.WithValue(ctx, requestIDKey{}, id) +} + +// RequestIDFrom извлекает request_id из контекста. +func RequestIDFrom(ctx context.Context) string { + if v, ok := ctx.Value(requestIDKey{}).(string); ok { + return v + } + return "" +} + +// userIDKey — ключ контекста для аутентифицированного user_id. +type userIDKey struct{} + +// ContextWithUserID кладёт user_id в контекст. Используется middleware.Auth. +func ContextWithUserID(ctx context.Context, id string) context.Context { + return context.WithValue(ctx, userIDKey{}, id) +} + +// UserIDFromContext извлекает user_id из контекста. +func UserIDFromContext(ctx context.Context) string { + if v, ok := ctx.Value(userIDKey{}).(string); ok { + return v + } + return "" +} + +// errorBody — формат тела ошибки по contracts/openapi.json. +type errorBody struct { + Error errorDetail `json:"error"` +} + +type errorDetail struct { + Code string `json:"code"` + Message string `json:"message"` + RequestID string `json:"request_id"` +} + +// WriteJSON пишет JSON-ответ с заданным статусом. +func WriteJSON(w http.ResponseWriter, r *http.Request, status int, v any) { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(status) + if v == nil { + return + } + if err := json.NewEncoder(w).Encode(v); err != nil { + slog.Error("failed to encode response", "err", err, "request_id", RequestIDFrom(r.Context())) + } +} + +// WriteError мапит доменную ошибку в HTTP-статус и пишет тело в формате контракта. +func WriteError(w http.ResponseWriter, r *http.Request, err error) { + status, code := mapError(err) + reqID := RequestIDFrom(r.Context()) + if reqID == "" { + reqID = "missing-request-id" + } + body := errorBody{Error: errorDetail{ + Code: code, + Message: messageFor(code), + RequestID: reqID, + }} + WriteJSON(w, r, status, body) +} + +func mapError(err error) (int, string) { + switch { + case errors.Is(err, service.ErrInvalidInput): + return http.StatusBadRequest, "invalid_request" + case errors.Is(err, service.ErrUnauthorized): + return http.StatusUnauthorized, "unauthorized" + case errors.Is(err, service.ErrNotFound): + return http.StatusNotFound, "not_found" + case errors.Is(err, service.ErrConflict): + return http.StatusConflict, "conflict" + case errors.Is(err, service.ErrUnavailable): + return http.StatusServiceUnavailable, "unavailable" + default: + return http.StatusInternalServerError, "internal_error" + } +} + +func messageFor(code string) string { + switch code { + case "invalid_request": + return "Неверный запрос" + case "unauthorized": + return "Требуется аутентификация" + case "not_found": + return "Объект не найден" + case "conflict": + return "Конфликт" + case "internal_error": + return "Внутренняя ошибка" + case "unavailable": + return "Сервис недоступен" + default: + return "Ошибка" + } +} + +// DecodeJSON парсит тело запроса в v, строго запрещая неизвестные поля. +func DecodeJSON(r *http.Request, v any) error { + dec := json.NewDecoder(r.Body) + dec.DisallowUnknownFields() + if err := dec.Decode(v); err != nil { + return service.ErrInvalidInput + } + if dec.More() { + return service.ErrInvalidInput + } + return nil +} + +// ParseLimit читает query-параметр limit с дефолтом и границами по контракту. +func ParseLimit(r *http.Request) (int, error) { + s := r.URL.Query().Get("limit") + if s == "" { + return 50, nil + } + n, err := strconv.Atoi(s) + if err != nil || n < 1 || n > 100 { + return 0, service.ErrInvalidInput + } + return n, nil +} + +// PageResponse — универсальный ответ пагинации. +type PageResponse struct { + Items any `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +// NextOrNull превращает пустую строку в nil (для сериализации в null). +func NextOrNull(s string) *string { + if s == "" { + return nil + } + return &s +} diff --git a/migrations/0001_init.down.sql b/migrations/0001_init.down.sql new file mode 100644 index 00000000..99dada2b --- /dev/null +++ b/migrations/0001_init.down.sql @@ -0,0 +1,6 @@ +-- Откат миграции 0001 +DROP TABLE IF EXISTS sessions; +DROP TABLE IF EXISTS messages; +DROP TABLE IF EXISTS chat_members; +DROP TABLE IF EXISTS chats; +DROP TABLE IF EXISTS users; \ No newline at end of file diff --git a/migrations/0001_init.up.sql b/migrations/0001_init.up.sql new file mode 100644 index 00000000..9875ce62 --- /dev/null +++ b/migrations/0001_init.up.sql @@ -0,0 +1,50 @@ +-- migrations/0001_init.sql + +-- Пользователи +CREATE TABLE users ( + id UUID PRIMARY KEY, + username TEXT NOT NULL UNIQUE, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Чаты +CREATE TABLE chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Членство +CREATE TABLE chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX chat_members_user_idx ON chat_members(user_id); + +-- Сообщения +CREATE TABLE messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id), + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Главный индекс для пагинации +CREATE INDEX messages_chat_created_id_idx + ON messages (chat_id, created_at, id); + +-- Сессии (если SESSION_STORE=postgres) +CREATE TABLE sessions ( + token TEXT PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX sessions_expires_idx ON sessions(expires_at); +CREATE INDEX sessions_user_idx ON sessions(user_id); \ No newline at end of file diff --git a/migrations/0002_idempotency.down.sql b/migrations/0002_idempotency.down.sql new file mode 100644 index 00000000..1cf0d861 --- /dev/null +++ b/migrations/0002_idempotency.down.sql @@ -0,0 +1 @@ +DROP TABLE IF EXISTS idempotency_keys; diff --git a/migrations/0002_idempotency.up.sql b/migrations/0002_idempotency.up.sql new file mode 100644 index 00000000..767c2636 --- /dev/null +++ b/migrations/0002_idempotency.up.sql @@ -0,0 +1,18 @@ +-- migrations/0002_idempotency.sql + +-- Ключи идемпотентности отправки сообщения (lab3). +-- Область уникальности: пользователь + метод + путь чата + ключ. +-- Метод всегда POST, путь однозначно задаётся chat_id, поэтому храним chat_id. +-- Запись создаётся в одной транзакции с сообщением: либо есть обе, либо ни одной. +CREATE TABLE idempotency_keys ( + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + key TEXT NOT NULL, + request_hash TEXT NOT NULL, + message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, chat_id, key) +); + +-- Для периодической очистки ключей старше IDEMPOTENCY_TTL_SECONDS. +CREATE INDEX idempotency_keys_created_idx ON idempotency_keys(created_at); diff --git a/scripts/collect-evidence.sh b/scripts/collect-evidence.sh new file mode 100755 index 00000000..134fd640 --- /dev/null +++ b/scripts/collect-evidence.sh @@ -0,0 +1,67 @@ +#!/bin/sh +set -eu +# Прогоняет все проверки lab3 на запущенном Docker-стенде и сохраняет вывод в evidence/. +# Токены и секреты не печатаются (тесты держат их в памяти). +# Linux/macOS/WSL: sh scripts/collect-evidence.sh +# Windows (Git Bash): PYTHON=python STOP=scripts/win/stop-one.cmd RESTART=scripts/win/restart.cmd sh scripts/collect-evidence.sh +cd "$(dirname "$0")/.." +PY=${PYTHON:-python3} +STOP=${STOP:-scripts/stop-one.sh} +RESTART=${RESTART:-scripts/restart.sh} +BASE=${BASE_URL:-http://localhost:8080} +export PYTHONUTF8=1 +mkdir -p evidence + +step() { echo "== $*"; } + +step "состояние стенда" +{ date -u +%Y-%m-%dT%H:%M:%SZ; docker compose version; docker compose ps; } > evidence/docker_ps.txt + +step "X-Instance-Id через LB" +$PY - "$BASE" > evidence/instances.txt <<'EOF' +import sys, urllib.request, collections +seen = collections.Counter() +for _ in range(20): + with urllib.request.urlopen(sys.argv[1] + '/health/ready') as r: + seen[r.headers['X-Instance-Id']] += 1 +for k, v in sorted(seen.items()): + print(k, v) +EOF +cat evidence/instances.txt + +step "smoke" +$PY tests/smoke.py --base-url "$BASE" | tee evidence/smoke.txt + +step "конкурентная идемпотентность" +$PY tests/idempotency_concurrent.py --base-url "$BASE" --output evidence/idempotency_concurrent.json | tail -1 + +step "публичный failover (2 прогона, между ними restore)" +for n in 1 2; do + { $PY tests/resilience.py --mode failover --action-script "$STOP" --base-url "$BASE" || echo "FAILED"; \ + echo "-- контейнеры api после stop-one:"; docker compose ps -a api --format '{{.Name}} {{.ID}} {{.Status}}'; } \ + > evidence/failover_$n.txt 2>&1 + cat evidence/failover_$n.txt + sh scripts/restore.sh >> evidence/failover_$n.txt +done + +step "persistence (restart всего стенда с volumes)" +{ echo "-- до:"; docker compose ps --format '{{.Name}} {{.Status}}'; \ + $PY tests/resilience.py --mode persistence --action-script "$RESTART" --base-url "$BASE" || echo "FAILED"; \ + echo "-- после:"; docker compose ps --format '{{.Name}} {{.Status}}'; } > evidence/persistence.txt 2>&1 +cat evidence/persistence.txt + +step "серия отказов каждой реплики под нагрузкой (уровень 4)" +$PY tests/failover_series.py --base-url "$BASE" --output evidence/failover_series.json | tail -1 + +step "rolling update под нагрузкой (уровень 4)" +$PY tests/load.py --base-url "$BASE" --duration 60 --concurrency 4 --output evidence/rolling_update_load.json > /dev/null & +LOAD=$! +sleep 5 +sh scripts/rolling-update.sh > evidence/rolling_update.txt 2>&1 +wait $LOAD +cat evidence/rolling_update.txt evidence/rolling_update_load.json + +step "базовая нагрузка без отказов" +$PY tests/load.py --base-url "$BASE" --duration 30 --concurrency 4 --output evidence/load_baseline.json > /dev/null +cat evidence/load_baseline.json +docker stats --no-stream --format '{{.Name}} {{.CPUPerc}} {{.MemUsage}}' > evidence/docker_stats.txt diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh new file mode 100755 index 00000000..815654ae --- /dev/null +++ b/scripts/init-secrets.sh @@ -0,0 +1,16 @@ +#!/bin/sh +set -eu +# Создаёт локальные .env и secrets/ для учебного стенда. Повторный запуск ничего +# не перезаписывает (иначе пароль разойдётся с уже инициализированным volume). +cd "$(dirname "$0")/.." +[ -f .env ] || cp .env.example .env +mkdir -p secrets +if [ ! -f secrets/postgres_password ]; then + # 32 случайных байта в hex — без символов, требующих экранирования в URL. + pw=$(od -An -N32 -tx1 /dev/urandom | tr -d ' \n') + printf '%s' "$pw" > secrets/postgres_password + printf 'postgres://messenger:%s@postgres:5432/messenger?sslmode=disable' "$pw" > secrets/database_url +fi +[ -f secrets/cache_url ] || printf '%s' 'redis://redis:6379/0' > secrets/cache_url +chmod 600 secrets/* 2>/dev/null || true +echo "secrets ready in ./secrets (values not printed)" diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..32494e34 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,16 @@ +#!/bin/sh +set -eu +# Перезапускает API, LB и все хранилища (PostgreSQL, Redis) с сохранением volumes. +# Никаких down -v / FLUSH / повторного seed. +cd "$(dirname "$0")/.." +docker compose stop lb api +docker compose restart postgres redis + +until docker compose exec -T postgres pg_isready -U messenger -d messenger >/dev/null 2>&1; do + sleep 1 +done +until docker compose exec -T redis redis-cli ping >/dev/null 2>&1; do + sleep 1 +done + +docker compose start api lb diff --git a/scripts/restore.sh b/scripts/restore.sh new file mode 100755 index 00000000..eec5b324 --- /dev/null +++ b/scripts/restore.sh @@ -0,0 +1,17 @@ +#!/bin/sh +set -eu +# Запускает остановленные stop-one.sh API-реплики и ждёт их готовности. +cd "$(dirname "$0")/.." +docker compose start api >/dev/null +deadline=$(( $(date +%s) + 60 )) +while :; do + bad=0 + for cid in $(docker compose ps -aq api); do + st=$(docker inspect -f '{{.State.Health.Status}}' "$cid") + [ "$st" = healthy ] || bad=1 + done + [ $bad -eq 0 ] && break + [ "$(date +%s)" -lt $deadline ] || { echo "api replicas not healthy in 60s" >&2; exit 1; } + sleep 1 +done +docker compose ps api --format '{{.Name}} {{.Status}}' diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100755 index 00000000..a9351897 --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,35 @@ +#!/bin/sh +set -eu +# Поочерёдная замена API-реплик без остановки сервиса (Compose). +# Для каждой старой реплики: поднять одну новую → дождаться healthy (LB сам +# найдёт её через DNS) → остановить старую (drain) → удалить. +# Миграции выполняются ДО замены отдельным сервисом migrate и должны быть +# совместимы со старой версией (expand → contract). +cd "$(dirname "$0")/.." +docker compose build api +docker compose run --rm migrate >/dev/null + +wait_healthy() { + want=$1; deadline=$(( $(date +%s) + 90 )) + while :; do + n=0 + for cid in $(docker compose ps -q api); do + [ "$(docker inspect -f '{{.State.Health.Status}}' "$cid")" = healthy ] && n=$((n+1)) + done + [ $n -ge "$want" ] && return 0 + [ "$(date +%s)" -lt $deadline ] || { echo "new replica not healthy in 90s" >&2; return 1; } + sleep 1 + done +} + +old=$(docker compose ps -q api) +for cid in $old; do + cur=$(docker compose ps -q api | wc -l | tr -d ' ') + docker compose up -d --no-deps --no-recreate --scale api=$((cur + 1)) api + wait_healthy $((cur + 1)) + name=$(docker inspect -f '{{.Name}}' "$cid") + docker stop -t 15 "$cid" >/dev/null + docker rm "$cid" >/dev/null + echo "replaced $name" +done +docker compose ps api --format '{{.Name}} {{.Image}} {{.Status}}' diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..1fb77703 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,25 @@ +#!/bin/sh +set -eu +# Останавливает ОДНУ API-реплику, чей X-Instance-Id передан в TARGET_INSTANCE_ID, +# и оставляет её остановленной. X-Instance-Id = hostname контейнера = префикс его ID. +# БД, Redis, LB и volumes не трогаются. Восстановление: scripts/restore.sh. +: "${TARGET_INSTANCE_ID:?test provides target API instance alias}" +cd "$(dirname "$0")/.." +case "$TARGET_INSTANCE_ID" in + *[!0-9a-f]*) echo "unexpected instance id format" >&2; exit 2 ;; +esac +[ ${#TARGET_INSTANCE_ID} -ge 12 ] || { echo "instance id too short" >&2; exit 2; } +for cid in $(docker compose ps -q api); do + case "$cid" in + "$TARGET_INSTANCE_ID"*) + name=$(docker inspect -f '{{.Name}}' "$cid") + # SIGTERM → API отвечает 503 на /health/ready (DRAIN_DELAY), LB исключает её, + # затем http.Server.Shutdown дожидается текущих запросов. + docker stop -t 15 "$cid" >/dev/null + echo "stopped $name ($TARGET_INSTANCE_ID)" + exit 0 + ;; + esac +done +echo "no running api container matches $TARGET_INSTANCE_ID" >&2 +exit 1 diff --git a/scripts/track1.py b/scripts/track1.py new file mode 100644 index 00000000..9c224475 --- /dev/null +++ b/scripts/track1.py @@ -0,0 +1,316 @@ +#!/usr/bin/env python3 +"""Оркестратор экспериментов трека 1 (цена масштабирования). + +Для каждой серии/конфигурации из experiments/track1.json: + 1. поднимает отдельный compose-проект (по умолчанию mtusi2026lab3-bench, порт 18080) + с переменными конфигурации (число реплик, CPU/RAM, пул, LB, режим кэша); + 2. ждёт, пока через LB видны все N реплик; + 3. для каждого уровня нагрузки и повтора запускает bin/bench (Go), параллельно + раз в ~1 s снимает docker stats всех контейнеров и pg_stat_activity, до и + после — счётчики пула pgx каждой реплики (внутренний :9090, через docker exec); + 4. дописывает одну JSON-строку на прогон в evidence/track1/raw.jsonl. + +Анализ и графики: scripts/track1_report.py. Только stdlib + docker CLI + go. + +Примеры: + python scripts/track1.py --quick # быстрый прогон всех серий + python scripts/track1.py --series A_fixed_total # одна серия, полная методика + python scripts/track1.py --resume # продолжить после обрыва + python scripts/track1.py --cleanup # в конце удалить bench-проект с volumes +""" +import argparse +import json +import os +from pathlib import Path +import statistics +import subprocess +import sys +import threading +import time +import urllib.request + +ROOT = Path(__file__).resolve().parents[1] +BENCH = ROOT / 'bin' / ('bench.exe' if os.name == 'nt' else 'bench') + + +def sh(args, env=None, check=True, capture=True, timeout=600): + r = subprocess.run(args, cwd=ROOT, env=env, capture_output=capture, text=True, timeout=timeout) + if check and r.returncode != 0: + raise SystemExit('command failed: %s\n%s' % (' '.join(args[:6]), (r.stderr or '')[-2000:])) + return (r.stdout or '').strip() + + +class Stack: + def __init__(self, project, port): + self.project, self.port = project, port + self.base = 'http://127.0.0.1:%d' % port + + def compose(self, *args, env=None, **kw): + return sh(['docker', 'compose', '-p', self.project, *args], env=env, **kw) + + def up(self, env, build): + args = ['up', '-d', '--wait', '--remove-orphans'] + if build: + args.append('--build') + n = env['API_REPLICAS'] + self.compose(*args, '--scale', 'api=' + n, env=env, timeout=900) + + def containers(self): + out = {} + for cid in self.compose('ps', '-q').split(): + svc = sh(['docker', 'inspect', '-f', '{{index .Config.Labels "com.docker.compose.service"}}', cid]) + out[cid[:12]] = svc + return out + + def instances_via_lb(self, tries): + seen = set() + for _ in range(tries): + try: + with urllib.request.urlopen(self.base + '/health/ready', timeout=2) as r: + seen.add(r.headers.get('X-Instance-Id')) + except OSError: + pass + return seen + + def wait_balanced(self, n, timeout=90): + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + if len(self.instances_via_lb(4 * n + 4)) >= n: + return + time.sleep(1) + raise SystemExit('LB does not route to %s replicas' % n) + + def pool_stats(self, containers): + res = {} + for cid, svc in containers.items(): + if svc != 'api': + continue + out = sh(['docker', 'exec', cid, 'wget', '-qO-', 'http://127.0.0.1:9090/internal/stats'], check=False) + try: + res[cid] = json.loads(out)['pool'] + except (ValueError, KeyError): + pass + return res + + def pad_redis(self, keys): + if keys <= 0: + return + have = int(self.compose('exec', '-T', 'redis', 'redis-cli', 'EVAL', + "return #redis.call('KEYS','pad:*')", '0') or 0) + if have >= keys: + return + # Фоновый keyspace (имитация активных сессий/прочих ключей). Только синтетика. + self.compose('exec', '-T', 'redis', 'redis-cli', 'EVAL', + "for i=1,tonumber(ARGV[1]) do redis.call('SET','pad:'..i,'x','EX',604800) end return 1", + '0', str(keys)) + + +class Sampler(threading.Thread): + """docker stats + pg_stat_activity примерно раз в секунду.""" + + def __init__(self, stack, containers): + super().__init__(daemon=True) + self.stack, self.containers = stack, containers + self.samples, self.pg = [], [] + self.stop = threading.Event() + + def run(self): + ids = list(self.containers) + while not self.stop.is_set(): + t = time.monotonic() + out = sh(['docker', 'stats', '--no-stream', '--format', '{{.ID}} {{.CPUPerc}} {{.MemUsage}}', *ids], check=False) + for line in out.splitlines(): + parts = line.split() + if len(parts) < 2: + continue + try: + cpu = float(parts[1].rstrip('%')) + except ValueError: + continue + mem = parts[2] if len(parts) > 2 else '' + self.samples.append((t, parts[0][:12], cpu, mem)) + q = ("select count(*) filter (where state='active'), count(*) " + "from pg_stat_activity where datname='messenger' and pid<>pg_backend_pid()") + pg = self.stack.compose('exec', '-T', 'postgres', 'psql', '-U', 'messenger', '-d', 'messenger', + '-tAc', q, check=False) + try: + a, total = pg.split('|') + self.pg.append((t, int(a), int(total))) + except ValueError: + pass + + +def mem_mib(s): + s = s.strip() + for unit, k in (('GiB', 1024), ('MiB', 1), ('KiB', 1 / 1024), ('B', 1 / 1024 / 1024)): + if s.endswith(unit): + try: + return float(s[:-len(unit)]) * k + except ValueError: + return None + return None + + +def summarize_resources(sampler, containers, env, t_from, t_to): + limits = {'api': float(env['API_CPUS']), 'postgres': float(env['PG_CPUS']), + 'lb': float(env['LB_CPUS']), 'redis': float(env['REDIS_CPUS'])} + per = {} + for t, cid, cpu, mem in sampler.samples: + if t_from <= t <= t_to and cid in containers: + per.setdefault(cid, []).append((cpu, mem_mib(mem))) + roles = {} + for cid, vals in per.items(): + svc = containers[cid] + cpus = [v[0] for v in vals] + mems = [v[1] for v in vals if v[1] is not None] + roles.setdefault(svc, []).append({'cpu_mean': statistics.mean(cpus), 'cpu_max': max(cpus), + 'mem_max_mib': max(mems) if mems else None}) + out = {} + for svc, items in roles.items(): + lim = limits.get(svc) + mean = statistics.mean(i['cpu_mean'] for i in items) + out[svc] = { + 'containers': len(items), + 'cpu_pct_mean_per_container': round(mean, 1), + 'cpu_pct_max_per_container': round(max(i['cpu_max'] for i in items), 1), + # 100% = весь лимит контейнера; ≥85% считаем насыщением. + 'cpu_utilization_of_limit': round(mean / (lim * 100), 3) if lim else None, + 'mem_max_mib': round(max((i['mem_max_mib'] or 0) for i in items), 1), + } + pg = [x for x in sampler.pg if t_from <= x[0] <= t_to] + if pg: + out['postgres_connections'] = {'active_max': max(x[1] for x in pg), + 'active_mean': round(statistics.mean(x[1] for x in pg), 1), + 'total_max': max(x[2] for x in pg)} + return out + + +def pool_delta(before, after): + acq = empty = dur = 0 + max_conns = 0 + for cid, a in after.items(): + b = before.get(cid, {}) + acq += a['acquire_count'] - b.get('acquire_count', 0) + empty += a['empty_acquire_count'] - b.get('empty_acquire_count', 0) + dur += a['acquire_duration_ms'] - b.get('acquire_duration_ms', 0) + max_conns += a['max_conns'] + return {'acquires': acq, 'empty_acquire_ratio': round(empty / acq, 4) if acq else None, + 'avg_acquire_wait_ms': round(dur / acq, 3) if acq else None, 'pool_max_conns_total': max_conns} + + +def done_keys(path): + keys = set() + if path.exists(): + for line in path.read_text(encoding='utf-8').splitlines(): + try: + r = json.loads(line) + keys.add((r['series'], r['config'], r['concurrency'], r['repeat'])) + except (ValueError, KeyError): + pass + return keys + + +def main(): + p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + p.add_argument('--experiments', default='experiments/track1.json') + p.add_argument('--series', default='', help='comma-separated series names; default all') + p.add_argument('--output', default='evidence/track1/raw.jsonl') + p.add_argument('--quick', action='store_true', help='levels 4,16,64; 15s; 1 repeat') + p.add_argument('--resume', action='store_true') + p.add_argument('--configs', default='', help='comma-separated config labels to run; default all') + p.add_argument('--levels', default='', help='override levels, e.g. 4,16,64') + p.add_argument('--duration', default='', help='override measured duration, e.g. 15s') + p.add_argument('--warmup', default='', help='override warmup, e.g. 3s') + p.add_argument('--repeats', type=int, default=0, help='override repeats') + p.add_argument('--cleanup', action='store_true', help='docker compose down -v for the bench project at the end') + args = p.parse_args() + + exp = json.loads((ROOT / args.experiments).read_text(encoding='utf-8')) + out = ROOT / args.output + out.parent.mkdir(parents=True, exist_ok=True) + skip = done_keys(out) if args.resume else set() + wanted = {s for s in args.series.split(',') if s} + stack = Stack(exp['project'], exp['lb_port']) + + probe = subprocess.run(['docker', 'version', '--format', '{{.Server.Version}}'], capture_output=True, text=True) + if probe.returncode != 0: + raise SystemExit('Docker Engine недоступен (docker version: %s). ' + 'Запустите Docker Desktop и дождитесь "Engine running"; ' + 'на Windows нужны включённая виртуализация и WSL2.' % (probe.stderr.strip().splitlines() or ['?'])[-1]) + sh(['go', 'build', '-o', str(BENCH), './cmd/bench']) + host = {'host_cpus': os.cpu_count(), 'docker': sh(['docker', 'version', '--format', '{{.Server.Version}}'], check=False), + 'docker_cpus': sh(['docker', 'info', '--format', '{{.NCPU}}'], check=False), + 'docker_mem_bytes': sh(['docker', 'info', '--format', '{{.MemTotal}}'], check=False)} + print('host:', json.dumps(host)) + built = False + + for series in exp['series']: + if wanted and series['name'] not in wanted: + continue + load = dict(exp['load']) + load['levels'] = series.get('levels', load['levels']) + load['repeats'] = series.get('repeats', load['repeats']) + if args.quick: + load.update(levels=[4, 16, 64] if series['name'] != 'D_improvement' else [32], duration='15s', + warmup='3s', repeats=1) + if args.levels: + load['levels'] = [int(x) for x in args.levels.split(',')] + for k in ('duration', 'warmup', 'repeats'): + if getattr(args, k): + load[k] = getattr(args, k) + only = {c for c in args.configs.split(',') if c} + for cfg in series['configs']: + if only and cfg['label'] not in only: + continue + env = dict(os.environ) + env.update(exp['base_env']) + env.update({k: v for k, v in cfg.items() if k != 'label'}) + env.setdefault('API_MEMORY', '256M') + env['LB_PORT'] = str(exp['lb_port']) + env['LB_STATS_PORT'] = str(exp['lb_port'] + 324) + todo = [(lvl, rep) for lvl in load['levels'] for rep in range(load['repeats']) + if (series['name'], cfg['label'], lvl, rep) not in skip] + if not todo: + continue + print('== %s / %s' % (series['name'], cfg['label']), flush=True) + stack.up(env, build=not built) + built = True + n = int(env['API_REPLICAS']) + stack.wait_balanced(n) + stack.pad_redis(exp.get('redis_padding_keys', 0)) + containers = stack.containers() + config_env = {k: env[k] for k in ('API_REPLICAS', 'API_CPUS', 'API_MEMORY', 'PG_CPUS', 'LB_CPUS', + 'REDIS_CPUS', 'DB_POOL_MAX', 'CACHE_INVALIDATION', 'LB_BALANCE')} + for lvl, rep in todo: + before = stack.pool_stats(containers) + sampler = Sampler(stack, containers) + sampler.start() + t_start = time.monotonic() + warm = float(load['warmup'].rstrip('s')) + dur = float(load['duration'].rstrip('s')) + line = sh([str(BENCH), '-base-url', stack.base, '-concurrency', str(lvl), + '-duration', load['duration'], '-warmup', load['warmup'], + '-write-ratio', str(load['write_ratio']), '-chats', str(load['chats']), + '-label', '%s/%s' % (series['name'], cfg['label'])], timeout=dur + warm + 300) + sampler.stop.set() + sampler.join(timeout=30) + after = stack.pool_stats(containers) + bench = json.loads(line.splitlines()[-1]) + rec = {'series': series['name'], 'config': cfg['label'], 'concurrency': lvl, 'repeat': rep, + 'load': {k: load[k] for k in ('duration', 'warmup', 'write_ratio', 'chats')}, + 'env': config_env, 'host': host, 'bench': bench, + 'resources': summarize_resources(sampler, containers, env, t_start + warm, t_start + warm + dur), + 'pool': pool_delta(before, after)} + with out.open('a', encoding='utf-8') as f: + f.write(json.dumps(rec, ensure_ascii=False) + '\n') + print(' c=%-3d rep=%d ok_rps=%.1f p95=%.1fms err=%.4f' % ( + lvl, rep, bench['ok_rps'], bench['latency_ms']['p95'], bench['error_ratio']), flush=True) + + if args.cleanup: + # Удаляет ТОЛЬКО bench-проект и его синтетические volumes. + stack.compose('down', '-v') + print('raw results:', out) + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/scripts/track1_report.py b/scripts/track1_report.py new file mode 100644 index 00000000..533dbb93 --- /dev/null +++ b/scripts/track1_report.py @@ -0,0 +1,304 @@ +#!/usr/bin/env python3 +"""Анализ трека 1: evidence/track1/raw.jsonl → summary.csv, summary.md, report.html. + +Правила анализа (фиксированы заранее, чтобы не подгонять выводы под данные): + * агрегат по повторам — медиана; разброс — min..max; + * точка насыщения конфигурации — первый уровень параллелизма, на котором + медианный ok_rps вырос меньше чем на 10% относительно предыдущего уровня; + * узкое место — роль (api/postgres/redis/lb) с наибольшей утилизацией CPU + от своего лимита на уровне насыщения; ≥0.85 — «насыщена»; дополнительно + признак пула: доля acquire без свободного соединения и среднее ожидание; + * улучшение «подтверждено», если на уровне хотя бы одного параллелизма ≥ уровня + насыщения baseline min(ok_rps кандидата) > max(ok_rps baseline) по всем повторам, + медиана p95 не хуже и доля ошибок не выше. +Только stdlib. +""" +import argparse +import csv +import html +import json +from pathlib import Path +import statistics + +ROOT = Path(__file__).resolve().parents[1] +ROLES = ('api', 'postgres', 'redis', 'lb') +SAT_GAIN = 0.10 +SAT_UTIL = 0.85 + + +def load(path): + rows = [] + for line in path.read_text(encoding='utf-8').splitlines(): + if line.strip(): + rows.append(json.loads(line)) + return rows + + +def med(xs): + xs = [x for x in xs if x is not None] + return statistics.median(xs) if xs else None + + +def aggregate(rows): + groups = {} + for r in rows: + groups.setdefault((r['series'], r['config'], r['concurrency']), []).append(r) + agg = {} + for key, rs in groups.items(): + b = [r['bench'] for r in rs] + a = { + 'repeats': len(rs), + 'env': rs[0]['env'], + 'ok_rps': med(x['ok_rps'] for x in b), + 'ok_rps_min': min(x['ok_rps'] for x in b), + 'ok_rps_max': max(x['ok_rps'] for x in b), + 'write_rps': med(x['ok_write_rps'] for x in b), + 'read_rps': med(x['ok_read_rps'] for x in b), + 'p50': med(x['latency_ms']['p50'] for x in b), + 'p95': med(x['latency_ms']['p95'] for x in b), + 'p99': med(x['latency_ms']['p99'] for x in b), + 'write_p95': med(x['write_ms']['p95'] for x in b), + 'error_ratio': med(x['error_ratio'] for x in b), + 'empty_acquire_ratio': med(r['pool'].get('empty_acquire_ratio') for r in rs), + 'acquire_wait_ms': med(r['pool'].get('avg_acquire_wait_ms') for r in rs), + 'pg_active_max': med(r['resources'].get('postgres_connections', {}).get('active_max') for r in rs), + } + for role in ROLES: + a['util_' + role] = med(r['resources'].get(role, {}).get('cpu_utilization_of_limit') for r in rs) + agg[key] = a + return agg + + +def series_order(rows): + seen, order = set(), [] + for r in rows: + k = (r['series'], r['config']) + if k not in seen: + seen.add(k) + order.append(k) + return order + + +def configs_of(order, series): + return [c for s, c in order if s == series] + + +def levels_of(agg, series, config): + return sorted(l for s, c, l in agg if s == series and c == config) + + +def saturation(agg, series, config): + lv = levels_of(agg, series, config) + peak_l = max(lv, key=lambda l: agg[(series, config, l)]['ok_rps']) + knee = lv[-1] + for prev, cur in zip(lv, lv[1:]): + if agg[(series, config, cur)]['ok_rps'] < agg[(series, config, prev)]['ok_rps'] * (1 + SAT_GAIN): + knee = cur + break + a = agg[(series, config, knee)] + utils = {r: a['util_' + r] for r in ROLES if a['util_' + r] is not None} + bottleneck = max(utils, key=utils.get) if utils else None + return {'peak_level': peak_l, 'peak_rps': agg[(series, config, peak_l)]['ok_rps'], 'knee_level': knee, + 'bottleneck': bottleneck, 'bottleneck_util': utils.get(bottleneck), + 'saturated': bool(bottleneck and utils[bottleneck] >= SAT_UTIL), 'utils': utils, + 'pool_empty_ratio': a['empty_acquire_ratio'], 'pool_wait_ms': a['acquire_wait_ms']} + + +def improvement(rows, agg, series, baseline, candidate, from_level): + res = [] + for l in levels_of(agg, series, baseline): + if l < from_level or (series, candidate, l) not in agg: + continue + b = [r['bench'] for r in rows if (r['series'], r['config'], r['concurrency']) == (series, baseline, l)] + c = [r['bench'] for r in rows if (r['series'], r['config'], r['concurrency']) == (series, candidate, l)] + ab, ac = agg[(series, baseline, l)], agg[(series, candidate, l)] + confirmed = (min(x['ok_rps'] for x in c) > max(x['ok_rps'] for x in b) + and ac['p95'] <= ab['p95'] and ac['error_ratio'] <= ab['error_ratio']) + res.append({'level': l, 'rps_delta_pct': 100 * (ac['ok_rps'] / ab['ok_rps'] - 1) if ab['ok_rps'] else None, + 'p95_delta_pct': 100 * (ac['p95'] / ab['p95'] - 1) if ab['p95'] else None, + 'repeats': (len(b), len(c)), 'confirmed': confirmed}) + return res + + +def fmt(x, nd=1): + return '—' if x is None else ('%.*f' % (nd, x)) + + +# ---------- SVG ---------- +COLORS = ['--series-1', '--series-2', '--series-3', '--series-4'] +DASH = ['', '6 3', '2 3', '8 3 2 3'] + + +def line_chart(title, xlabels, series, ylabel): + """series: [(name, [y or None per x])]. Категориальная ось X (уровни параллелизма).""" + W, H, L, R, T, B = 640, 300, 56, 120, 16, 40 + pw, ph = W - L - R, H - T - B + ys = [y for _, vals in series for y in vals if y is not None] + ymax = max(ys) * 1.1 if ys else 1 + step = 10 ** max(0, len(str(int(ymax))) - 1) + for m in (1, 2, 5, 10): + if ymax / (step * m) <= 6: + step *= m + break + xs = [L + (pw * i / (len(xlabels) - 1) if len(xlabels) > 1 else pw / 2) for i in range(len(xlabels))] + yv = lambda v: T + ph - ph * v / ymax + o = ['' % (W, H, html.escape(title))] + v = 0 + while v <= ymax: + o.append('' % (L, L + pw, yv(v), yv(v))) + o.append('%g' % (L - 6, yv(v), v)) + v += step + o.append('' % (L, L + pw, T + ph, T + ph)) + for x, lab in zip(xs, xlabels): + o.append('%s' % (x, T + ph + 16, lab)) + o.append('параллелизм (closed-loop воркеры)' % (L + pw / 2, H - 4)) + o.append('%s' % (L, T - 4 if T > 12 else 10, html.escape(ylabel))) + for i, (name, vals) in enumerate(series): + col, dash = COLORS[i % 4], DASH[i % 4] + pts = [(x, yv(y), y, lab) for x, y, lab in zip(xs, vals, xlabels) if y is not None] + if not pts: + continue + d = ' '.join(('M' if j == 0 else 'L') + '%.1f %.1f' % (p[0], p[1]) for j, p in enumerate(pts)) + o.append('' % (d, col, dash)) + for x, y, val, lab in pts: + tip = '%s · c=%s · %s' % (name, lab, fmt(val)) + o.append('' % (x, y, col, html.escape(tip))) + o.append('' % (x, y, html.escape(tip))) + lx, ly = pts[-1][0], pts[-1][1] + o.append('%s' % (lx + 8, ly + (i - 1.5) * 3, html.escape(name))) + o.append('') + legend = ''.join('%s' % (COLORS[i % 4], DASH[i % 4], html.escape(n)) + for i, (n, _) in enumerate(series)) + return '
%s
%s
%s
' % (html.escape(title), legend, ''.join(o)) + + +CSS = ''' +.viz-root{color-scheme:light;--surface-1:#fcfcfb;--page:#f9f9f7;--text-primary:#0b0b0b;--text-secondary:#52514e; +--muted:#898781;--grid:#e1e0d9;--axis:#c3c2b7;--border:rgba(11,11,11,.10); +--series-1:#2a78d6;--series-2:#eb6834;--series-3:#1baf7a;--series-4:#eda100} +@media (prefers-color-scheme:dark){:root:where(:not([data-theme="light"])) .viz-root{color-scheme:dark;--surface-1:#1a1a19; +--page:#0d0d0d;--text-primary:#f0efec;--text-secondary:#c3c2b7;--grid:#2c2c2a;--axis:#383835;--border:rgba(255,255,255,.10); +--series-1:#3987e5;--series-2:#d95926;--series-3:#199e70;--series-4:#c98500}} +:root[data-theme="dark"] .viz-root{color-scheme:dark;--surface-1:#1a1a19;--page:#0d0d0d;--text-primary:#f0efec; +--text-secondary:#c3c2b7;--grid:#2c2c2a;--axis:#383835;--border:rgba(255,255,255,.10); +--series-1:#3987e5;--series-2:#d95926;--series-3:#199e70;--series-4:#c98500} +body{margin:0;background:var(--page)} +.viz-root{font:14px/1.45 system-ui,sans-serif;color:var(--text-primary);background:var(--page);padding:16px;max-width:1100px;margin:auto} +h1{font-size:22px}h2{font-size:18px;margin-top:32px}p,li{color:var(--text-secondary)} +.charts{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(320px,100%),1fr));gap:16px} +figure{margin:0;min-width:0;background:var(--surface-1);border:1px solid var(--border);border-radius:8px;padding:12px} +figcaption{font-weight:600;margin-bottom:6px}svg{width:100%;height:auto;display:block} +.legend{display:flex;flex-wrap:wrap;gap:12px;font-size:12px;color:var(--text-secondary);margin-bottom:4px} +.key{display:inline-flex;align-items:center;gap:4px} +.grid{stroke:var(--grid);stroke-width:1}.axis{stroke:var(--axis);stroke-width:1} +.tick{fill:var(--muted);font-size:11px}.dlabel{fill:var(--text-secondary);font-size:11px} +.pt{stroke:var(--surface-1);stroke-width:2}.hit{fill:transparent;cursor:default} +table{border-collapse:collapse;width:100%;font-size:12px;background:var(--surface-1);font-variant-numeric:tabular-nums} +th,td{border-bottom:1px solid var(--grid);padding:4px 6px;text-align:right}th:first-child,td:first-child{text-align:left} +.wrap{overflow-x:auto} +#tip{position:fixed;pointer-events:none;background:var(--surface-1);color:var(--text-primary);border:1px solid var(--border); +border-radius:6px;padding:4px 8px;font-size:12px;display:none;box-shadow:0 2px 8px rgba(0,0,0,.15)} +''' +JS = ''' +const tip=document.getElementById('tip'); +document.querySelectorAll('[data-tip]').forEach(el=>{ + el.addEventListener('mousemove',e=>{tip.textContent=el.dataset.tip;tip.style.display='block'; + tip.style.left=Math.min(e.clientX+12,innerWidth-220)+'px';tip.style.top=(e.clientY+12)+'px'}); + el.addEventListener('mouseleave',()=>tip.style.display='none')}); +''' + + +def table(headers, rows): + h = ''.join('%s' % html.escape(x) for x in headers) + b = ''.join('%s' % ''.join('%s' % html.escape(str(c)) for c in r) for r in rows) + return '
%s%s
' % (h, b) + + +def main(): + p = argparse.ArgumentParser() + p.add_argument('--input', default='evidence/track1/raw.jsonl') + p.add_argument('--experiments', default='experiments/track1.json') + p.add_argument('--outdir', default='evidence/track1') + args = p.parse_args() + src = ROOT / args.input + if not src.exists() or not src.read_text(encoding='utf-8').strip(): + raise SystemExit('Нет данных: %s отсутствует или пуст. Сначала успешно выполните scripts/track1.py ' + '(его вывод должен содержать строки "c=... ok_rps=...").' % src) + rows = load(src) + exp = json.loads((ROOT / args.experiments).read_text(encoding='utf-8')) + titles = {s['name']: s for s in exp['series']} + agg = aggregate(rows) + order = series_order(rows) + outdir = ROOT / args.outdir + outdir.mkdir(parents=True, exist_ok=True) + + headers = ['series', 'config', 'c', 'repeats', 'ok_rps', 'rps_min', 'rps_max', 'write_rps', 'read_rps', 'p50_ms', + 'p95_ms', 'p99_ms', 'err', 'util_api', 'util_pg', 'util_redis', 'util_lb', 'pool_empty', 'pool_wait_ms', 'pg_active'] + csv_rows = [] + for s, c in order: + for l in levels_of(agg, s, c): + a = agg[(s, c, l)] + csv_rows.append([s, c, l, a['repeats'], fmt(a['ok_rps']), fmt(a['ok_rps_min']), fmt(a['ok_rps_max']), + fmt(a['write_rps']), fmt(a['read_rps']), fmt(a['p50'], 2), fmt(a['p95'], 2), fmt(a['p99'], 2), + fmt(a['error_ratio'], 4), fmt(a['util_api'], 2), fmt(a['util_postgres'], 2), + fmt(a['util_redis'], 2), fmt(a['util_lb'], 2), fmt(a['empty_acquire_ratio'], 3), + fmt(a['acquire_wait_ms'], 2), fmt(a['pg_active_max'], 0)]) + with (outdir / 'summary.csv').open('w', newline='', encoding='utf-8') as f: + csv.writer(f).writerows([headers] + csv_rows) + + md = ['# Трек 1 — сводка (сгенерировано scripts/track1_report.py)', '', + 'Медианы по повторам; util_* — доля CPU-лимита контейнера роли; pool_empty — доля acquire без свободного соединения.', ''] + body = ['

Трек 1 — цена масштабирования

', + '

Медианы по повторам. Наведите на точку — значение. Полные данные — таблицы под графиками и summary.csv.

'] + for name in dict.fromkeys(s for s, _ in order): + meta = titles.get(name, {'title': name, 'hypothesis': ''}) + cfgs = configs_of(order, name) + lv = sorted({l for c in cfgs for l in levels_of(agg, name, c)}) + xl = [str(l) for l in lv] + get = lambda c, k: [agg[(name, c, l)][k] if (name, c, l) in agg else None for l in lv] + body.append('

%s — %s

Гипотеза: %s

' % (name, html.escape(meta['title']), html.escape(meta['hypothesis']))) + body.append('
%s%s
' % ( + line_chart('Успешные RPS', xl, [(c, get(c, 'ok_rps')) for c in cfgs[:4]], 'ok RPS'), + line_chart('p95 задержки, мс', xl, [(c, get(c, 'p95')) for c in cfgs[:4]], 'мс'))) + sat_rows = [] + md += ['## %s — %s' % (name, meta['title']), '', '**Гипотеза:** ' + meta['hypothesis'], '', + '| config | пик RPS | c пика | c насыщения | узкое место (util) | pool empty / wait ms |', '|---|---|---|---|---|---|'] + base_peak = None + for c in cfgs: + st = saturation(agg, name, c) + base_peak = base_peak or st['peak_rps'] + bn = '%s (%s)%s' % (st['bottleneck'], fmt(st['bottleneck_util'], 2), ' — насыщена' if st['saturated'] else '') + pool = '%s / %s' % (fmt(st['pool_empty_ratio'], 3), fmt(st['pool_wait_ms'], 2)) + md.append('| %s | %s | %s | %s | %s | %s |' % (c, fmt(st['peak_rps']), st['peak_level'], st['knee_level'], bn, pool)) + sat_rows.append([c, fmt(st['peak_rps']), '%.2f×' % (st['peak_rps'] / base_peak) if base_peak else '—', + st['peak_level'], st['knee_level'], bn, pool]) + body.append(table(['config', 'пик RPS', 'к первой', 'c пика', 'c насыщения', 'узкое место', 'pool empty / wait ms'], sat_rows)) + if name.startswith('D') and cfgs: + baseline = cfgs[0] + from_level = saturation(agg, name, baseline)['knee_level'] + imp_rows = [] + md += ['', 'Сравнение с `%s` (уровни ≥ насыщения baseline):' % baseline, '', + '| кандидат | c | ΔRPS % | Δp95 % | повторы b/c | подтверждено |', '|---|---|---|---|---|---|'] + for c in cfgs[1:]: + for r in improvement(rows, agg, name, baseline, c, min(from_level, max(levels_of(agg, name, baseline)))): + row = [c, r['level'], fmt(r['rps_delta_pct']), fmt(r['p95_delta_pct']), '%d/%d' % r['repeats'], + 'да' if r['confirmed'] else 'нет'] + imp_rows.append(row) + md.append('| %s |' % ' | '.join(str(x) for x in row)) + body.append('

Кандидаты против %s

' % html.escape(baseline)) + body.append(table(['кандидат', 'c', 'ΔRPS %', 'Δp95 %', 'повторы b/c', 'подтверждено'], imp_rows)) + md.append('') + series_rows = [r for r in csv_rows if r[0] == name] + body.append('
Все точки серии%s
' % table(headers[1:], [r[1:] for r in series_rows])) + (outdir / 'summary.md').write_text('\n'.join(md) + '\n', encoding='utf-8') + page = ('' + 'Трек 1 отчёт
%s
' + '') % (CSS, ''.join(body), JS) + (outdir / 'report.html').write_text(page, encoding='utf-8') + print('written:', outdir / 'summary.csv', outdir / 'summary.md', outdir / 'report.html') + + +if __name__ == '__main__': + main() diff --git a/scripts/win/restart.cmd b/scripts/win/restart.cmd new file mode 100644 index 00000000..c633b518 --- /dev/null +++ b/scripts/win/restart.cmd @@ -0,0 +1,3 @@ +@echo off +rem Windows wrapper: Python subprocess cannot exec .sh directly (WinError 193). +"%ProgramFiles%\Git\bin\bash.exe" "%~dp0..\restart.sh" %* diff --git a/scripts/win/restore.cmd b/scripts/win/restore.cmd new file mode 100644 index 00000000..f5cf5c8a --- /dev/null +++ b/scripts/win/restore.cmd @@ -0,0 +1,3 @@ +@echo off +rem Windows wrapper: Python subprocess cannot exec .sh directly (WinError 193). +"%ProgramFiles%\Git\bin\bash.exe" "%~dp0..\restore.sh" %* diff --git a/scripts/win/stop-one.cmd b/scripts/win/stop-one.cmd new file mode 100644 index 00000000..fe8f1284 --- /dev/null +++ b/scripts/win/stop-one.cmd @@ -0,0 +1,3 @@ +@echo off +rem Windows wrapper: Python subprocess cannot exec .sh directly (WinError 193). +"%ProgramFiles%\Git\bin\bash.exe" "%~dp0..\stop-one.sh" %* diff --git a/tests/failover_series.py b/tests/failover_series.py new file mode 100644 index 00000000..dcb4752e --- /dev/null +++ b/tests/failover_series.py @@ -0,0 +1,171 @@ +#!/usr/bin/env python3 +"""Серия отказов под нагрузкой (уровень 4): поочерёдно останавливает КАЖДУЮ +API-реплику (docker stop → SIGTERM → drain), восстанавливает её и переходит +к следующей. Во время всей серии идёт closed-loop нагрузка через LB: +POST сообщения (при ошибке повтор с тем же Idempotency-Key) и GET истории. + +Измеряется на каждую реплику: RPS до/во время/после, число ошибок, время от +начала остановки до последней ошибки (recovery), время до исчезновения реплики +из ответов LB и время восстановления реплики после docker start. +В конце проверяется: все подтверждённые сообщения на месте, дублей нет. + +Скрипт сам вызывает docker CLI (это не публичный тест), запускать из корня репозитория. +""" +from concurrent.futures import ThreadPoolExecutor +import json +from pathlib import Path +import subprocess +import threading +import time +import uuid +from client import Client, Failure, arguments, check, run +from resilience import history + +ROOT = Path(__file__).resolve().parents[1] + + +def docker(*args): + return subprocess.run(['docker', *args], cwd=ROOT, check=True, capture_output=True, text=True).stdout.strip() + + +def api_containers(): + return docker('compose', 'ps', '-q', 'api').split() + + +def health(cid): + return docker('inspect', '-f', '{{.State.Health.Status}}', cid) + + +class Load: + def __init__(self, args, actor, reader, chat, concurrency): + self.args, self.actor, self.reader, self.chat = args, actor, reader, chat + self.concurrency = concurrency + self.events = [] # (t, kind, ok, instance) + self.confirmed = [] # подтверждённые Message + self.lock = threading.Lock() + self.stop = threading.Event() + + def record(self, kind, ok, instance=None): + with self.lock: + self.events.append((time.monotonic(), kind, ok, instance)) + + def worker(self, n): + c = Client(self.args.base_url, self.args.ca_file, timeout=3) + path = '/api/v1/chats/' + self.chat['id'] + '/messages?limit=20' + key, text, i = None, None, 0 + while not self.stop.is_set(): + if key is None: + key = uuid.uuid4().hex + text = 'series-%d-%d-%s' % (n, i, key) + i += 1 + try: + r = c.message(self.actor, self.chat, text, key=key) + self.record('write', True, r['headers'].get('X-Instance-Id')) + with self.lock: + self.confirmed.append(r['json']) + key = None + except Failure: + self.record('write', False) # неопределённый результат: тот же ключ + try: + r = c.call('GET', path, actor=self.reader, schema='MessagePage') + self.record('read', True, r['headers'].get('X-Instance-Id')) + except Failure: + self.record('read', False) + + def __enter__(self): + self.pool = ThreadPoolExecutor(max_workers=self.concurrency) + self.futures = [self.pool.submit(self.worker, n) for n in range(self.concurrency)] + return self + + def __exit__(self, *exc): + self.stop.set() + for f in self.futures: + f.result() + self.pool.shutdown() + + def window(self, a, b): + with self.lock: + ev = [e for e in self.events if a <= e[0] < b] + ok = sum(1 for e in ev if e[2]) + return {'seconds': round(b - a, 2), 'ok': ok, 'errors': len(ev) - ok, + 'ok_rps': round(ok / (b - a), 1) if b > a else None} + + +def main(): + def configure(p): + p.add_argument('--concurrency', type=int, default=4) + p.add_argument('--warmup', type=float, default=5) + p.add_argument('--observe', type=float, default=15) + p.add_argument('--output', default=None) + args = arguments('Stop each API replica in turn under load; collect RPS/errors/recovery', configure) + c = Client(args.base_url, args.ca_file) + alice, bob, _, chat = c.bootstrap() + replicas = api_containers() + check(len(replicas) >= 2, 'need at least 2 api containers') + results = [] + with Load(args, alice, bob, chat, args.concurrency) as load: + time.sleep(args.warmup) + for cid in replicas: + target = cid[:12] + before_start = time.monotonic() - args.warmup + t0 = time.monotonic() + docker('stop', '-t', '15', cid) + stop_seconds = time.monotonic() - t0 + time.sleep(max(0.0, args.observe - stop_seconds)) + t_end = time.monotonic() + with load.lock: + after = [e for e in load.events if e[0] >= t0] + errs = [e[0] for e in after if not e[2]] + served = [e[0] for e in after if e[2] and e[3] == target] + row = { + 'target_instance': target, + 'docker_stop_seconds': round(stop_seconds, 2), + 'before': load.window(before_start, t0), + 'during_stop_and_observe': load.window(t0, t_end), + 'errors_after_stop': len(errs), + 'recovery_seconds': round(max(errs) - t0, 2) if errs else 0.0, + 'target_last_served_after_stop_seconds': round(max(served) - t0, 2) if served else None, + 'other_instances_after': sorted({e[3] for e in after if e[2] and e[3] != target}), + } + # Восстановление реплики и её возврат в балансировку. + r0 = time.monotonic() + docker('start', cid) + while health(cid) != 'healthy': + check(time.monotonic() - r0 < 60, 'replica did not become healthy') + time.sleep(0.5) + healthy_at = time.monotonic() - r0 + while True: + with load.lock: + seen = any(e[0] > r0 and e[2] and e[3] == target for e in load.events) + if seen: + break + check(time.monotonic() - r0 < 60, 'replica not seen behind LB after restore') + time.sleep(0.2) + row['restore_healthy_seconds'] = round(healthy_at, 2) + row['restore_serving_via_lb_seconds'] = round(time.monotonic() - r0, 2) + results.append(row) + print(json.dumps(row, ensure_ascii=False)) + time.sleep(3) + total = load.window(load.events[0][0], time.monotonic()) + confirmed = list(load.confirmed) + + messages = history(c, bob, chat) + ids = [m['id'] for m in messages] + texts = [m['text'] for m in messages] + check(len(ids) == len(set(ids)), 'duplicated message IDs') + check(len(texts) == len(set(texts)), 'retry with same key created a duplicate') + by_id = {m['id']: m for m in messages} + lost = [m for m in confirmed if by_id.get(m['id']) != m] + check(not lost, '%d confirmed messages lost/changed' % len(lost)) + summary = {'concurrency': args.concurrency, 'replicas': len(replicas), 'total': total, + 'confirmed_writes': len(confirmed), 'stored_messages': len(messages), + 'duplicates': 0, 'lost_confirmed': 0, 'per_replica': results} + text = json.dumps(summary, ensure_ascii=False, indent=2) + if args.output: + Path(args.output).write_text(text + '\n', encoding='utf-8') + print(text) + print('PASS: every replica stopped and restored under load; no lost or duplicated messages.') + + +if __name__ == '__main__': + run(main) diff --git a/tests/idempotency_concurrent.py b/tests/idempotency_concurrent.py new file mode 100644 index 00000000..90d71d2c --- /dev/null +++ b/tests/idempotency_concurrent.py @@ -0,0 +1,89 @@ +#!/usr/bin/env python3 +"""Конкурентный повтор POST сообщения с одним Idempotency-Key через LB (lab3). + +Каждый раунд: N потоков (каждый со своим соединением) по барьеру одновременно +отправляют одинаковый body с одинаковым ключом. Ожидаем: все ответы 201 с одним +и тем же Message, запросы обслужены ≥2 репликами, в истории ровно одно сообщение. +Затем тот же ключ с другим body — 409; тот же ключ в другом чате — новое сообщение. +""" +from concurrent.futures import ThreadPoolExecutor +import json +import threading +import uuid +from client import Client, Failure, arguments, check, run +from resilience import history + + +def main(): + def configure(p): + p.add_argument('--rounds', type=int, default=10) + p.add_argument('--parallel', type=int, default=16) + p.add_argument('--output', default=None) + args = arguments('Concurrent Idempotency-Key replay across replicas', configure) + c = Client(args.base_url, args.ca_file) + alice, bob, eve, chat = c.bootstrap() + other = c.call('POST', '/api/v1/chats', 201, actor=alice, + body={'title': 'Второй чат', 'member_ids': [alice['id'], bob['id']]}, schema='Chat')['json'] + + rounds = [] + all_instances = set() + for r in range(args.rounds): + key = 'conc-' + uuid.uuid4().hex + text = 'Конкурентный повтор %d %s' % (r, key) + barrier = threading.Barrier(args.parallel) + + def worker(_): + local = Client(args.base_url, args.ca_file, timeout=10) + barrier.wait() + try: + resp = local.message(alice, chat, text, key=key) + return resp['status'], resp['json'], resp['headers'].get('X-Instance-Id') + except Failure as exc: + return 'fail', str(exc), None + + with ThreadPoolExecutor(max_workers=args.parallel) as pool: + results = list(pool.map(worker, range(args.parallel))) + statuses = [s for s, _, _ in results] + check(all(s == 201 for s in statuses), 'round %d: not all 201: %s' % (r, statuses)) + bodies = {json.dumps(b, sort_keys=True) for _, b, _ in results} + check(len(bodies) == 1, 'round %d: replays returned different messages' % r) + instances = {i for _, _, i in results} + all_instances |= instances + stored = [m for m in history(c, bob, chat) if m['text'] == text] + check(len(stored) == 1, 'round %d: %d messages stored for one key' % (r, len(stored))) + # Другой body с тем же ключом — 409, не новое сообщение. + c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 409, actor=alice, + body={'text': text + ' (изменён)'}, headers={'Idempotency-Key': key}) + rounds.append({'round': r, 'requests': args.parallel, 'status_201': statuses.count(201), + 'distinct_messages': len(bodies), 'stored': len(stored), 'instances': len(instances)}) + + # Ключ уникален в пределах чата: тот же ключ в другом чате создаёт своё сообщение. + key = 'scope-' + uuid.uuid4().hex + a = c.message(alice, chat, 'scope', key=key)['json'] + b = c.message(alice, other, 'scope', key=key)['json'] + check(a['id'] != b['id'], 'key leaked across chats') + # Другой пользователь с тем же ключом — тоже независим. + d = c.message(bob, chat, 'scope', key=key)['json'] + check(d['id'] != a['id'], 'key leaked across users') + # Без ключа и с неверным ключом — 400. + path = '/api/v1/chats/' + chat['id'] + '/messages' + c.call('POST', path, 400, actor=alice, body={'text': 'x'}) + c.call('POST', path, 400, actor=alice, body={'text': 'x'}, headers={'Idempotency-Key': 'bad key!'}) + c.call('POST', path, 400, actor=alice, body={'text': 'x'}, headers={'Idempotency-Key': 'k' * 129}) + # Повтор проверяет доступ: посторонний с тем же ключом получает 404. + c.call('POST', path, 404, actor=eve, body={'text': 'scope'}, headers={'Idempotency-Key': key}) + + check(len(all_instances) >= 2, 'concurrent requests were served by fewer than 2 replicas') + summary = {'rounds': args.rounds, 'parallel_per_round': args.parallel, + 'distinct_instances_seen': len(all_instances), + 'duplicates_found': sum(x['stored'] - 1 for x in rounds), 'per_round': rounds} + text = json.dumps(summary, ensure_ascii=False, indent=2) + if args.output: + with open(args.output, 'w', encoding='utf-8') as f: + f.write(text + '\n') + print(text) + print('PASS: concurrent Idempotency-Key replay produced exactly one message per key.') + + +if __name__ == '__main__': + run(main) diff --git a/tests/negative.py b/tests/negative.py new file mode 100644 index 00000000..5cb20283 --- /dev/null +++ b/tests/negative.py @@ -0,0 +1,58 @@ +import base64 +import json +import sys +import urllib.request +import urllib.error + +BASE = (sys.argv[sys.argv.index("--base-url") + 1] if "--base-url" in sys.argv else "http://localhost:8080").rstrip("/") +PASSWORD = "Example-only-not-a-real-secret-123" + +def post(path, body, headers=None): + req = urllib.request.Request(BASE + path, method="POST", + data=json.dumps(body).encode(), + headers={"Content-Type": "application/json", **(headers or {})}) + try: + with urllib.request.urlopen(req) as r: + return r.status, json.loads(r.read()) + except urllib.error.HTTPError as e: + return e.code, json.loads(e.read()) + +def get(path, headers=None): + req = urllib.request.Request(BASE + path, headers=headers or {}) + try: + with urllib.request.urlopen(req) as r: + return r.status, json.loads(r.read()) + except urllib.error.HTTPError as e: + return e.code, json.loads(e.read()) + +def main(): + failures = [] + + # 1. Неверный JSON → 400 + status, _ = post("/api/v1/users", "not-json") + if status != 400: + failures.append(f"invalid JSON: expected 400, got {status}") + + # 2. Невалидный username → 400 + status, _ = post("/api/v1/users", {"username": "AB", "display_name": "Test", "password": PASSWORD}) + if status != 400: + failures.append(f"invalid username: expected 400, got {status}") + + # 3. Отсутствие Bearer на /users/me → 401 + status, _ = get("/api/v1/users/me") + if status != 401: + failures.append(f"no auth: expected 401, got {status}") + + # 4. X-User-Id не даёт доступ → 401 + status, _ = get("/api/v1/users/me", {"X-User-Id": "00000000-0000-0000-0000-000000000000"}) + if status != 401: + failures.append(f"X-User-Id bypass: expected 401, got {status}") + + if failures: + for f in failures: + print(f"FAIL: {f}") + sys.exit(1) + print("PASS: negative checks") + +if __name__ == "__main__": + main() \ No newline at end of file -- 2.54.0 From fe4b4cf556d6042f505c428560039754037f2717 Mon Sep 17 00:00:00 2001 From: CharaWein Date: Fri, 23 Oct 2026 17:29:54 +0300 Subject: [PATCH 2/8] =?UTF-8?q?ci:=20=D0=BF=D1=83=D0=B1=D0=BB=D0=B8=D0=BA?= =?UTF-8?q?=D0=BE=D0=B2=D0=B0=D1=82=D1=8C=20=D1=80=D0=B5=D0=B7=D1=83=D0=BB?= =?UTF-8?q?=D1=8C=D1=82=D0=B0=D1=82=D1=8B=20=D0=B2=20=D0=B2=D0=B5=D1=82?= =?UTF-8?q?=D0=BA=D1=83=20lab3-results?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- .github/workflows/lab3-stand.yml | 35 ++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/.github/workflows/lab3-stand.yml b/.github/workflows/lab3-stand.yml index ae002123..016007ba 100644 --- a/.github/workflows/lab3-stand.yml +++ b/.github/workflows/lab3-stand.yml @@ -11,6 +11,11 @@ on: permissions: contents: read +# Новый push отменяет незавершённый прогон той же ветки. +concurrency: + group: lab3-stand-${{ github.ref }} + cancel-in-progress: true + env: PYTHONUTF8: "1" @@ -89,3 +94,33 @@ jobs: with: name: track1-${{ matrix.series }} path: evidence/track1/ + + # api.github.com недоступен из сети разработчика, а github.com (git) — доступен, + # поэтому все артефакты дополнительно публикуются в ветку lab3-results. + publish: + name: Публикация результатов в ветку lab3-results + needs: [levels-3-4, track1] + if: always() + runs-on: ubuntu-24.04 + permissions: + contents: write + steps: + - uses: actions/checkout@v4 + - uses: actions/download-artifact@v4 + with: + path: collected + - name: Commit в lab3-results + run: | + git config user.name "github-actions[bot]" + git config user.email "41898282+github-actions[bot]@users.noreply.github.com" + git checkout -q --orphan lab3-results + git rm -rf -q . + { echo "source_commit=${{ github.sha }}" + echo "run=${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}" + echo "levels_3_4=${{ needs.levels-3-4.result }}" + echo "track1=${{ needs.track1.result }}"; } > collected/RUN.txt + cp -r collected/. . + rm -rf collected + git add -A + git commit -q -m "results for ${{ github.sha }}" + git push -f origin lab3-results -- 2.54.0 From 0a3718134b60f0ab1ed4be74f771746e99072d87 Mon Sep 17 00:00:00 2001 From: CharaWein Date: Fri, 23 Oct 2026 17:47:27 +0300 Subject: [PATCH 3/8] =?UTF-8?q?lab3:=20=D0=B8=D1=81=D0=BF=D1=80=D0=B0?= =?UTF-8?q?=D0=B2=D0=B8=D1=82=D1=8C=20rolling=20update,=20=D0=B4=D0=B0?= =?UTF-8?q?=D0=BD=D0=BD=D1=8B=D0=B5=20=D1=82=D1=80=D0=B5=D0=BA=D0=B0=201?= =?UTF-8?q?=20(=D0=BF=D1=80=D0=BE=D0=B3=D0=BE=D0=BD=201),=20=D1=81=D0=B5?= =?UTF-8?q?=D1=80=D0=B8=D0=B8=20C=20=D0=B8=20E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- .github/workflows/lab3-stand.yml | 13 +- Makefile | 4 +- REPORT.md | 6 +- evidence/track1/RUNS.txt | 1 + evidence/track1/raw.jsonl | 78 ++++++++++ evidence/track1/runner_A_fixed_total.txt | 6 + evidence/track1/runner_B_scale_out.txt | 6 + evidence/track1/runner_D_improvement.txt | 6 + experiments/track1.json | 146 ++++++++++++++++-- scripts/collect-evidence.sh | 13 +- scripts/rolling-update.sh | 8 +- {tests => student-tests}/failover_series.py | 3 + .../idempotency_concurrent.py | 3 + {tests => student-tests}/negative.py | 0 14 files changed, 257 insertions(+), 36 deletions(-) create mode 100644 evidence/track1/RUNS.txt create mode 100644 evidence/track1/raw.jsonl create mode 100644 evidence/track1/runner_A_fixed_total.txt create mode 100644 evidence/track1/runner_B_scale_out.txt create mode 100644 evidence/track1/runner_D_improvement.txt rename {tests => student-tests}/failover_series.py (98%) rename {tests => student-tests}/idempotency_concurrent.py (97%) rename {tests => student-tests}/negative.py (100%) diff --git a/.github/workflows/lab3-stand.yml b/.github/workflows/lab3-stand.yml index 016007ba..1398dc82 100644 --- a/.github/workflows/lab3-stand.yml +++ b/.github/workflows/lab3-stand.yml @@ -58,16 +58,15 @@ jobs: strategy: fail-fast: false matrix: + # Серии A, B, D уже измерены прогоном 39970452644 (данные в evidence/track1); + # второй прогон добавляет C (причинность узкого места) и E (рост реплик после улучшения). include: - - series: A_fixed_total + - series: C_shared_resources + configs: "" + levels: "16,64" + - series: E_scale_out_after_fix configs: "" levels: "4,16,64" - - series: B_scale_out - configs: "1x0.50,2x0.50,4x0.50" - levels: "4,16,64" - - series: D_improvement - configs: "" - levels: "32,64" steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v5 diff --git a/Makefile b/Makefile index af273256..9f086d55 100644 --- a/Makefile +++ b/Makefile @@ -38,10 +38,10 @@ down: docker compose --env-file .env stop test-idempotency: - $(PYTHON) tests/idempotency_concurrent.py --base-url "$(BASE_URL)" $(TLS_ARGS) + $(PYTHON) student-tests/idempotency_concurrent.py --base-url "$(BASE_URL)" $(TLS_ARGS) test-failover-series: - $(PYTHON) tests/failover_series.py --base-url "$(BASE_URL)" $(TLS_ARGS) --output evidence/failover_series.json + $(PYTHON) student-tests/failover_series.py --base-url "$(BASE_URL)" $(TLS_ARGS) --output evidence/failover_series.json # --- Трек 5.1: цена масштабирования (отдельный compose-проект на :18080) --- track1: diff --git a/REPORT.md b/REPORT.md index a1a19131..1e90a576 100644 --- a/REPORT.md +++ b/REPORT.md @@ -105,9 +105,9 @@ Docker Desktop на машине разработки не запускает д | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл | | --- | --- | --- | --- | | Публичный smoke | tests/smoke.py | PASS: lab3 public API scenario | evidence/local_native_check.txt | -| Негативные проверки lab2 | tests/negative.py | PASS | evidence/local_native_check.txt | +| Негативные проверки lab2 | student-tests/negative.py | PASS | evidence/local_native_check.txt | | Отказ реплики, ≥2 реплик до отказа | tests/resilience.py --mode failover | PASS, observed 2, 21 успешных записей, 7 ошибок переходного периода, первая запись после hook за 3.7 s, дублей нет | evidence/local_native_check.txt | -| Конкурентный повтор одного ключа через разные реплики | tests/idempotency_concurrent.py (10 раундов × 16 параллельно) | PASS: 160/160 → 201 с одинаковым Message, 1 сообщение на ключ, 2 реплики, 409 на другой body, ключ изолирован по чату/пользователю, посторонний — 404 | evidence/idempotency_concurrent_native.json | +| Конкурентный повтор одного ключа через разные реплики | student-tests/idempotency_concurrent.py (10 раундов × 16 параллельно) | PASS: 160/160 → 201 с одинаковым Message, 1 сообщение на ключ, 2 реплики, 409 на другой body, ключ изолирован по чату/пользователю, посторонний — 404 | evidence/idempotency_concurrent_native.json | | compose.yaml корректен | docker compose --env-file .env config --quiet | OK; 2 реплики, лимиты, опубликован только lb | — | ### На Docker-стенде (заполнить после `sh scripts/collect-evidence.sh`) @@ -125,7 +125,7 @@ Docker Desktop на машине разработки не запускает д ## Эксперименты и отказы -Методика (уровень 4), `tests/failover_series.py`: closed-loop нагрузка 4 потока через LB (POST сообщения с повтором того же ключа после неопределённого ответа + GET истории), прогрев 5 s; для каждой реплики по очереди `docker stop -t 15` → наблюдение 15 s → `docker start` → ожидание healthy и появления в ответах LB → 3 s паузы. Метрики: успешные RPS до/во время, число ошибок, время от начала остановки до последней ошибки, время, когда остановленная реплика последний раз ответила, время восстановления. В конце — полная история: нет дублей текста и ID, все подтверждённые сообщения на месте. +Методика (уровень 4), `student-tests/failover_series.py`: closed-loop нагрузка 4 потока через LB (POST сообщения с повтором того же ключа после неопределённого ответа + GET истории), прогрев 5 s; для каждой реплики по очереди `docker stop -t 15` → наблюдение 15 s → `docker start` → ожидание healthy и появления в ответах LB → 3 s паузы. Метрики: успешные RPS до/во время, число ошибок, время от начала остановки до последней ошибки, время, когда остановленная реплика последний раз ответила, время восстановления. В конце — полная история: нет дублей текста и ID, все подтверждённые сообщения на месте. Rolling update (`scripts/rolling-update.sh`): build → migrate → для каждой старой реплики `up --scale api=N+1 --no-recreate` → ждать healthy → `docker stop` старой (drain) → `rm`. Во время замены 60 s нагрузки `tests/load.py`. diff --git a/evidence/track1/RUNS.txt b/evidence/track1/RUNS.txt new file mode 100644 index 00000000..0aab0cef --- /dev/null +++ b/evidence/track1/RUNS.txt @@ -0,0 +1 @@ +run1=https://github.com/CharaWein/2026_lab3/actions/runs/39970452644 commit=fe4b4cf series=A_fixed_total,B_scale_out,D_improvement diff --git a/evidence/track1/raw.jsonl b/evidence/track1/raw.jsonl new file mode 100644 index 00000000..38afefa0 --- /dev/null +++ b/evidence/track1/raw.jsonl @@ -0,0 +1,78 @@ +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"f8de8806f2dd": 3387}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 90.902, "p50": 19.135, "p95": 44.841, "p99": 62.505}, "mode": "closed", "ok": 3387, "ok_read_rps": 113.6, "ok_rps": 225.8, "ok_write_rps": 112.2, "rate": 0, "read_ms": {"max": 61.817, "p50": 3.579, "p95": 9.395, "p99": 23.593}, "requests": 3387, "timestamp": "2026-10-23T14:34:46Z", "warmup_s": 3, "write_ms": {"max": 90.902, "p50": 26.188, "p95": 50.127, "p99": 71.697}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 69.8, "cpu_pct_max_per_container": 71.8, "cpu_utilization_of_limit": 0.698, "mem_max_mib": 138.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.3, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.086, "mem_max_mib": 12.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.5, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.185, "mem_max_mib": 44.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 51.7, "cpu_pct_max_per_container": 52.2, "cpu_utilization_of_limit": 1.034, "mem_max_mib": 11.4}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 4}}, "pool": {"acquires": 11359, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"f8de8806f2dd": 3350}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 110.935, "p50": 19.103, "p95": 45.319, "p99": 56.937}, "mode": "closed", "ok": 3350, "ok_read_rps": 111.53333333333333, "ok_rps": 223.33333333333334, "ok_write_rps": 111.8, "rate": 0, "read_ms": {"max": 50.498, "p50": 3.589, "p95": 10.153, "p99": 21.457}, "requests": 3350, "timestamp": "2026-10-23T14:35:07Z", "warmup_s": 3, "write_ms": {"max": 110.935, "p50": 26.323, "p95": 49.772, "p99": 62.736}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 67.7, "cpu_pct_max_per_container": 74.4, "cpu_utilization_of_limit": 0.677, "mem_max_mib": 232.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.1, "cpu_pct_max_per_container": 4.2, "cpu_utilization_of_limit": 0.081, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.4, "cpu_pct_max_per_container": 31.1, "cpu_utilization_of_limit": 0.194, "mem_max_mib": 41.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.8, "cpu_pct_max_per_container": 53.6, "cpu_utilization_of_limit": 1.017, "mem_max_mib": 10.1}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 4}}, "pool": {"acquires": 11235, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"f8de8806f2dd": 3366}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 89.676, "p50": 18.466, "p95": 44.731, "p99": 57.88}, "mode": "closed", "ok": 3366, "ok_read_rps": 112.86666666666666, "ok_rps": 224.4, "ok_write_rps": 111.53333333333333, "rate": 0, "read_ms": {"max": 30.142, "p50": 3.693, "p95": 9.804, "p99": 21.259}, "requests": 3366, "timestamp": "2026-10-23T14:35:27Z", "warmup_s": 3, "write_ms": {"max": 89.676, "p50": 27.023, "p95": 48.796, "p99": 63.561}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 70.5, "cpu_pct_max_per_container": 75.3, "cpu_utilization_of_limit": 0.705, "mem_max_mib": 225.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.3, "cpu_pct_max_per_container": 4.6, "cpu_utilization_of_limit": 0.086, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.7, "cpu_pct_max_per_container": 22.8, "cpu_utilization_of_limit": 0.187, "mem_max_mib": 43.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 52.4, "cpu_pct_max_per_container": 53.2, "cpu_utilization_of_limit": 1.048, "mem_max_mib": 10.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 4}}, "pool": {"acquires": 11485, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"f8de8806f2dd": 3960}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 238.183, "p50": 35.66, "p95": 137.791, "p99": 185.231}, "mode": "closed", "ok": 3960, "ok_read_rps": 133.06666666666666, "ok_rps": 264, "ok_write_rps": 130.93333333333334, "rate": 0, "read_ms": {"max": 50.074, "p50": 8.756, "p95": 26.449, "p99": 35.059}, "requests": 3960, "timestamp": "2026-10-23T14:35:47Z", "warmup_s": 3, "write_ms": {"max": 238.183, "p50": 105.132, "p95": 160.221, "p99": 197.558}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 68.1, "cpu_pct_max_per_container": 71.3, "cpu_utilization_of_limit": 0.681, "mem_max_mib": 212.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 12.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.3, "cpu_pct_max_per_container": 33.3, "cpu_utilization_of_limit": 0.233, "mem_max_mib": 71.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.5, "cpu_pct_max_per_container": 51.6, "cpu_utilization_of_limit": 1.01, "mem_max_mib": 10.8}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 16}}, "pool": {"acquires": 13544, "empty_acquire_ratio": 0.0009, "avg_acquire_wait_ms": 0.076, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"f8de8806f2dd": 3872}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 282.946, "p50": 40.225, "p95": 143.652, "p99": 190.661}, "mode": "closed", "ok": 3872, "ok_read_rps": 129.93333333333334, "ok_rps": 258.1333333333333, "ok_write_rps": 128.2, "rate": 0, "read_ms": {"max": 57.401, "p50": 8.555, "p95": 26.294, "p99": 38.087}, "requests": 3872, "timestamp": "2026-10-23T14:36:08Z", "warmup_s": 3, "write_ms": {"max": 282.946, "p50": 106.437, "p95": 163.839, "p99": 200.339}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 67.0, "cpu_pct_max_per_container": 70.9, "cpu_utilization_of_limit": 0.67, "mem_max_mib": 47.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 12.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.2, "cpu_pct_max_per_container": 24.1, "cpu_utilization_of_limit": 0.192, "mem_max_mib": 74.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.6, "cpu_pct_max_per_container": 51.3, "cpu_utilization_of_limit": 1.012, "mem_max_mib": 10.6}, "postgres_connections": {"active_max": 3, "active_mean": 0.4, "total_max": 16}}, "pool": {"acquires": 13281, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"f8de8806f2dd": 3825}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 286.228, "p50": 65.57, "p95": 142.008, "p99": 204.591}, "mode": "closed", "ok": 3825, "ok_read_rps": 127.13333333333334, "ok_rps": 255, "ok_write_rps": 127.86666666666666, "rate": 0, "read_ms": {"max": 80.433, "p50": 8.564, "p95": 26.239, "p99": 38.17}, "requests": 3825, "timestamp": "2026-10-23T14:36:28Z", "warmup_s": 3, "write_ms": {"max": 286.228, "p50": 107.359, "p95": 174.376, "p99": 215.965}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 66.6, "cpu_pct_max_per_container": 70.3, "cpu_utilization_of_limit": 0.666, "mem_max_mib": 50.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 12.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.8, "cpu_pct_max_per_container": 20.6, "cpu_utilization_of_limit": 0.188, "mem_max_mib": 76.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.4, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 1.009, "mem_max_mib": 10.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 17}}, "pool": {"acquires": 13234, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"f8de8806f2dd": 3552}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 824.981, "p50": 77.486, "p95": 620.438, "p99": 801.109}, "mode": "closed", "ok": 3552, "ok_read_rps": 121.06666666666666, "ok_rps": 236.8, "ok_write_rps": 115.73333333333333, "rate": 0, "read_ms": {"max": 109.975, "p50": 28.889, "p95": 59.314, "p99": 84.668}, "requests": 3552, "timestamp": "2026-10-23T14:36:48Z", "warmup_s": 3, "write_ms": {"max": 824.981, "p50": 503.84, "p95": 725.127, "p99": 810.433}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 68.3, "cpu_pct_max_per_container": 74.8, "cpu_utilization_of_limit": 0.683, "mem_max_mib": 75.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 13.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 22.1, "cpu_utilization_of_limit": 0.196, "mem_max_mib": 86.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 51.4, "cpu_utilization_of_limit": 1.003, "mem_max_mib": 17.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 21}}, "pool": {"acquires": 12695, "empty_acquire_ratio": 0.0031, "avg_acquire_wait_ms": 0.023, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"f8de8806f2dd": 3704}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 708.237, "p50": 64.109, "p95": 579.192, "p99": 635.977}, "mode": "closed", "ok": 3704, "ok_read_rps": 126.66666666666667, "ok_rps": 246.93333333333334, "ok_write_rps": 120.26666666666667, "rate": 0, "read_ms": {"max": 99.028, "p50": 29.212, "p95": 58.1, "p99": 72.711}, "requests": 3704, "timestamp": "2026-10-23T14:37:11Z", "warmup_s": 3, "write_ms": {"max": 708.237, "p50": 479.247, "p95": 597.369, "p99": 657.478}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 69.9, "cpu_pct_max_per_container": 73.5, "cpu_utilization_of_limit": 0.699, "mem_max_mib": 91.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 13.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.6, "cpu_pct_max_per_container": 22.1, "cpu_utilization_of_limit": 0.186, "mem_max_mib": 88.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.8, "cpu_pct_max_per_container": 51.8, "cpu_utilization_of_limit": 0.995, "mem_max_mib": 15.7}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 20}}, "pool": {"acquires": 13098, "empty_acquire_ratio": 0.0173, "avg_acquire_wait_ms": 0.24, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"f8de8806f2dd": 3765}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 682.65, "p50": 408.674, "p95": 556.841, "p99": 601.413}, "mode": "closed", "ok": 3765, "ok_read_rps": 122.66666666666667, "ok_rps": 251, "ok_write_rps": 128.33333333333334, "rate": 0, "read_ms": {"max": 121.922, "p50": 26.204, "p95": 54.884, "p99": 78.306}, "requests": 3765, "timestamp": "2026-10-23T14:37:31Z", "warmup_s": 3, "write_ms": {"max": 682.65, "p50": 454.085, "p95": 581.695, "p99": 612.152}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 69.1, "cpu_pct_max_per_container": 71.8, "cpu_utilization_of_limit": 0.691, "mem_max_mib": 86.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 13.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.4, "cpu_pct_max_per_container": 21.5, "cpu_utilization_of_limit": 0.184, "mem_max_mib": 90.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 1.002, "mem_max_mib": 11.0}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 20}}, "pool": {"acquires": 13230, "empty_acquire_ratio": 0.0032, "avg_acquire_wait_ms": 0.005, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"55952f12e9d6": 1541, "bc2fb8a1f16f": 1541}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 104.855, "p50": 17.027, "p95": 46.682, "p99": 60.616}, "mode": "closed", "ok": 3082, "ok_read_rps": 104.4, "ok_rps": 205.46666666666667, "ok_write_rps": 101.06666666666666, "rate": 0, "read_ms": {"max": 49.898, "p50": 4.228, "p95": 10.723, "p99": 21.517}, "requests": 3082, "timestamp": "2026-10-23T14:38:04Z", "warmup_s": 3, "write_ms": {"max": 104.855, "p50": 31.062, "p95": 53.031, "p99": 68.991}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 41.4, "cpu_pct_max_per_container": 43.6, "cpu_utilization_of_limit": 0.828, "mem_max_mib": 138.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.3, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.086, "mem_max_mib": 13.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 16.0, "cpu_pct_max_per_container": 18.9, "cpu_utilization_of_limit": 0.16, "mem_max_mib": 60.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 52.4, "cpu_pct_max_per_container": 53.6, "cpu_utilization_of_limit": 1.047, "mem_max_mib": 11.5}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 7}}, "pool": {"acquires": 10483, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"55952f12e9d6": 1431, "bc2fb8a1f16f": 1431}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 117.045, "p50": 19.339, "p95": 52.224, "p99": 72.672}, "mode": "closed", "ok": 2862, "ok_read_rps": 96.13333333333334, "ok_rps": 190.8, "ok_write_rps": 94.66666666666667, "rate": 0, "read_ms": {"max": 35.426, "p50": 4.472, "p95": 11.54, "p99": 21.255}, "requests": 2862, "timestamp": "2026-10-23T14:38:25Z", "warmup_s": 3, "write_ms": {"max": 117.045, "p50": 32.009, "p95": 59.452, "p99": 81.361}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 40.0, "cpu_pct_max_per_container": 41.9, "cpu_utilization_of_limit": 0.8, "mem_max_mib": 253.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.3, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.086, "mem_max_mib": 13.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 15.5, "cpu_pct_max_per_container": 17.9, "cpu_utilization_of_limit": 0.155, "mem_max_mib": 62.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 52.5, "cpu_pct_max_per_container": 53.3, "cpu_utilization_of_limit": 1.049, "mem_max_mib": 11.5}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 7}}, "pool": {"acquires": 9969, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"55952f12e9d6": 1485, "bc2fb8a1f16f": 1488}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 115.32, "p50": 17.002, "p95": 48.936, "p99": 63.157}, "mode": "closed", "ok": 2973, "ok_read_rps": 101.13333333333334, "ok_rps": 198.2, "ok_write_rps": 97.06666666666666, "rate": 0, "read_ms": {"max": 34.692, "p50": 4.341, "p95": 11.648, "p99": 22.437}, "requests": 2973, "timestamp": "2026-10-23T14:38:47Z", "warmup_s": 3, "write_ms": {"max": 115.32, "p50": 31.795, "p95": 55.236, "p99": 73.573}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 40.5, "cpu_pct_max_per_container": 43.5, "cpu_utilization_of_limit": 0.809, "mem_max_mib": 249.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.2, "cpu_pct_max_per_container": 4.3, "cpu_utilization_of_limit": 0.083, "mem_max_mib": 13.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 16.6, "cpu_pct_max_per_container": 22.4, "cpu_utilization_of_limit": 0.166, "mem_max_mib": 70.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 51.3, "cpu_pct_max_per_container": 52.5, "cpu_utilization_of_limit": 1.027, "mem_max_mib": 11.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 7}}, "pool": {"acquires": 10219, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"55952f12e9d6": 1749, "bc2fb8a1f16f": 1756}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 305.326, "p50": 65.673, "p95": 163.477, "p99": 205.612}, "mode": "closed", "ok": 3505, "ok_read_rps": 114.4, "ok_rps": 233.66666666666666, "ok_write_rps": 119.26666666666667, "rate": 0, "read_ms": {"max": 60.325, "p50": 9.902, "p95": 25.905, "p99": 38.109}, "requests": 3505, "timestamp": "2026-10-23T14:39:10Z", "warmup_s": 3, "write_ms": {"max": 305.326, "p50": 116.917, "p95": 186.679, "p99": 221.034}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 39.3, "cpu_pct_max_per_container": 42.0, "cpu_utilization_of_limit": 0.785, "mem_max_mib": 239.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.092, "mem_max_mib": 13.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.7, "cpu_pct_max_per_container": 20.8, "cpu_utilization_of_limit": 0.187, "mem_max_mib": 85.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 0.992, "mem_max_mib": 12.1}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 16}}, "pool": {"acquires": 12044, "empty_acquire_ratio": 0.0007, "avg_acquire_wait_ms": 0.055, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"55952f12e9d6": 1825, "bc2fb8a1f16f": 1818}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 295.648, "p50": 36.609, "p95": 165.702, "p99": 209.901}, "mode": "closed", "ok": 3643, "ok_read_rps": 122.8, "ok_rps": 242.86666666666667, "ok_write_rps": 120.06666666666666, "rate": 0, "read_ms": {"max": 73.804, "p50": 10.227, "p95": 27.584, "p99": 40.35}, "requests": 3643, "timestamp": "2026-10-23T14:39:32Z", "warmup_s": 3, "write_ms": {"max": 295.648, "p50": 118.087, "p95": 186.135, "p99": 243.123}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 40.4, "cpu_pct_max_per_container": 44.0, "cpu_utilization_of_limit": 0.807, "mem_max_mib": 244.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 13.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 21.9, "cpu_utilization_of_limit": 0.196, "mem_max_mib": 89.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 52.0, "cpu_utilization_of_limit": 1.002, "mem_max_mib": 15.3}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 17}}, "pool": {"acquires": 12609, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.006, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"55952f12e9d6": 1740, "bc2fb8a1f16f": 1726}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 292.691, "p50": 34.523, "p95": 173.545, "p99": 208.167}, "mode": "closed", "ok": 3466, "ok_read_rps": 116.4, "ok_rps": 231.06666666666666, "ok_write_rps": 114.66666666666667, "rate": 0, "read_ms": {"max": 61.91, "p50": 10.237, "p95": 24.134, "p99": 34.456}, "requests": 3466, "timestamp": "2026-10-23T14:39:55Z", "warmup_s": 3, "write_ms": {"max": 292.691, "p50": 124.195, "p95": 186.81, "p99": 223.225}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.8, "cpu_pct_max_per_container": 41.4, "cpu_utilization_of_limit": 0.776, "mem_max_mib": 245.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.092, "mem_max_mib": 13.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 25.2, "cpu_pct_max_per_container": 57.1, "cpu_utilization_of_limit": 0.252, "mem_max_mib": 103.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.5, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 0.99, "mem_max_mib": 12.1}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 18}}, "pool": {"acquires": 12136, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"55952f12e9d6": 1785, "bc2fb8a1f16f": 1845}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 906.142, "p50": 214.198, "p95": 663.016, "p99": 795.112}, "mode": "closed", "ok": 3630, "ok_read_rps": 119.46666666666667, "ok_rps": 242, "ok_write_rps": 122.53333333333333, "rate": 0, "read_ms": {"max": 118.028, "p50": 32.559, "p95": 65.012, "p99": 84.919}, "requests": 3630, "timestamp": "2026-10-23T14:40:17Z", "warmup_s": 3, "write_ms": {"max": 906.142, "p50": 494.588, "p95": 698.38, "p99": 840.589}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 40.2, "cpu_pct_max_per_container": 45.1, "cpu_utilization_of_limit": 0.805, "mem_max_mib": 256.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.5, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.091, "mem_max_mib": 14.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.0, "cpu_pct_max_per_container": 21.8, "cpu_utilization_of_limit": 0.2, "mem_max_mib": 143.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 3, "active_mean": 0.4, "total_max": 40}}, "pool": {"acquires": 12456, "empty_acquire_ratio": 0.0133, "avg_acquire_wait_ms": 0.834, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"55952f12e9d6": 1925, "bc2fb8a1f16f": 1895}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 1028.971, "p50": 89.255, "p95": 677.589, "p99": 857.045}, "mode": "closed", "ok": 3820, "ok_read_rps": 128, "ok_rps": 254.66666666666666, "ok_write_rps": 126.66666666666667, "rate": 0, "read_ms": {"max": 148.874, "p50": 30.857, "p95": 64.555, "p99": 90.075}, "requests": 3820, "timestamp": "2026-10-23T14:40:38Z", "warmup_s": 3, "write_ms": {"max": 1028.971, "p50": 452.462, "p95": 739.574, "p99": 968.304}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 41.9, "cpu_pct_max_per_container": 46.6, "cpu_utilization_of_limit": 0.838, "mem_max_mib": 91.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.095, "mem_max_mib": 14.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.7, "cpu_pct_max_per_container": 21.4, "cpu_utilization_of_limit": 0.197, "mem_max_mib": 146.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 1.005, "mem_max_mib": 12.7}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 40}}, "pool": {"acquires": 13091, "empty_acquire_ratio": 0.0073, "avg_acquire_wait_ms": 0.062, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"55952f12e9d6": 1909, "bc2fb8a1f16f": 1863}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 995.74, "p50": 74.529, "p95": 749.523, "p99": 865.429}, "mode": "closed", "ok": 3772, "ok_read_rps": 129.53333333333333, "ok_rps": 251.46666666666667, "ok_write_rps": 121.93333333333334, "rate": 0, "read_ms": {"max": 160.508, "p50": 32.023, "p95": 66.728, "p99": 96.937}, "requests": 3772, "timestamp": "2026-10-23T14:41:01Z", "warmup_s": 3, "write_ms": {"max": 995.74, "p50": 487.711, "p95": 809.22, "p99": 930.779}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 40.5, "cpu_pct_max_per_container": 47.5, "cpu_utilization_of_limit": 0.81, "mem_max_mib": 85.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.094, "mem_max_mib": 14.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.4, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 0.244, "mem_max_mib": 150.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.3, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 0.986, "mem_max_mib": 12.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 40}}, "pool": {"acquires": 12697, "empty_acquire_ratio": 0.0264, "avg_acquire_wait_ms": 0.191, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"20403b5e7dd2": 723, "5878b4f59f86": 727, "90ce2af85ed5": 723, "fde392dcbd85": 722}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 195.366, "p50": 15.446, "p95": 52.356, "p99": 70.153}, "mode": "closed", "ok": 2895, "ok_read_rps": 98.86666666666666, "ok_rps": 193, "ok_write_rps": 94.13333333333334, "rate": 0, "read_ms": {"max": 75.479, "p50": 4.46, "p95": 14.633, "p99": 37.531}, "requests": 2895, "timestamp": "2026-10-23T14:41:37Z", "warmup_s": 3, "write_ms": {"max": 195.366, "p50": 32.751, "p95": 60.164, "p99": 85.359}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.6, "cpu_pct_max_per_container": 25.7, "cpu_utilization_of_limit": 0.866, "mem_max_mib": 142.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 3.6, "cpu_pct_max_per_container": 4.4, "cpu_utilization_of_limit": 0.073, "mem_max_mib": 13.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 16.6, "cpu_pct_max_per_container": 18.8, "cpu_utilization_of_limit": 0.166, "mem_max_mib": 79.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.0, "cpu_pct_max_per_container": 54.0, "cpu_utilization_of_limit": 0.941, "mem_max_mib": 12.2}, "postgres_connections": {"active_max": 2, "active_mean": 0.4, "total_max": 10}}, "pool": {"acquires": 9725, "empty_acquire_ratio": 0.0003, "avg_acquire_wait_ms": 0.005, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"20403b5e7dd2": 680, "5878b4f59f86": 681, "90ce2af85ed5": 681, "fde392dcbd85": 681}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 197.787, "p50": 15.857, "p95": 57.705, "p99": 79.758}, "mode": "closed", "ok": 2723, "ok_read_rps": 93.2, "ok_rps": 181.53333333333333, "ok_write_rps": 88.33333333333333, "rate": 0, "read_ms": {"max": 159.63, "p50": 4.552, "p95": 15.528, "p99": 32.862}, "requests": 2723, "timestamp": "2026-10-23T14:42:03Z", "warmup_s": 3, "write_ms": {"max": 197.787, "p50": 34.533, "p95": 65.642, "p99": 103.13}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.1, "cpu_pct_max_per_container": 25.8, "cpu_utilization_of_limit": 0.843, "mem_max_mib": 191.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 3.7, "cpu_pct_max_per_container": 4.4, "cpu_utilization_of_limit": 0.074, "mem_max_mib": 13.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 17.5, "cpu_pct_max_per_container": 22.9, "cpu_utilization_of_limit": 0.175, "mem_max_mib": 85.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.4, "cpu_pct_max_per_container": 53.5, "cpu_utilization_of_limit": 0.948, "mem_max_mib": 18.4}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 12}}, "pool": {"acquires": 9334, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.006, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"20403b5e7dd2": 682, "5878b4f59f86": 682, "90ce2af85ed5": 681, "fde392dcbd85": 682}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 181.372, "p50": 15.743, "p95": 55.209, "p99": 87.204}, "mode": "closed", "ok": 2727, "ok_read_rps": 93.13333333333334, "ok_rps": 181.8, "ok_write_rps": 88.66666666666667, "rate": 0, "read_ms": {"max": 87.204, "p50": 4.663, "p95": 14.057, "p99": 31.628}, "requests": 2727, "timestamp": "2026-10-23T14:42:29Z", "warmup_s": 3, "write_ms": {"max": 181.372, "p50": 33.947, "p95": 64.674, "p99": 125.83}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.8, "cpu_pct_max_per_container": 25.7, "cpu_utilization_of_limit": 0.832, "mem_max_mib": 186.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 3.6, "cpu_pct_max_per_container": 4.4, "cpu_utilization_of_limit": 0.072, "mem_max_mib": 13.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 14.5, "cpu_pct_max_per_container": 17.6, "cpu_utilization_of_limit": 0.145, "mem_max_mib": 87.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 44.6, "cpu_pct_max_per_container": 53.2, "cpu_utilization_of_limit": 0.892, "mem_max_mib": 15.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 12}}, "pool": {"acquires": 9332, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"20403b5e7dd2": 823, "5878b4f59f86": 836, "90ce2af85ed5": 829, "fde392dcbd85": 827}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 545.69, "p50": 26.873, "p95": 187.322, "p99": 269.959}, "mode": "closed", "ok": 3315, "ok_read_rps": 114.73333333333333, "ok_rps": 221, "ok_write_rps": 106.26666666666667, "rate": 0, "read_ms": {"max": 166.994, "p50": 10.398, "p95": 25.718, "p99": 47.049}, "requests": 3315, "timestamp": "2026-10-23T14:42:55Z", "warmup_s": 3, "write_ms": {"max": 545.69, "p50": 127.019, "p95": 219.897, "p99": 319.138}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.6, "cpu_pct_max_per_container": 24.9, "cpu_utilization_of_limit": 0.865, "mem_max_mib": 187.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.1, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.082, "mem_max_mib": 13.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.4, "cpu_pct_max_per_container": 21.7, "cpu_utilization_of_limit": 0.194, "mem_max_mib": 102.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 44.1, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 0.882, "mem_max_mib": 16.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 18}}, "pool": {"acquires": 11371, "empty_acquire_ratio": 0.0004, "avg_acquire_wait_ms": 0.027, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"20403b5e7dd2": 804, "5878b4f59f86": 802, "90ce2af85ed5": 806, "fde392dcbd85": 805}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 459.041, "p50": 46.07, "p95": 182.871, "p99": 326.246}, "mode": "closed", "ok": 3217, "ok_read_rps": 107.33333333333333, "ok_rps": 214.46666666666667, "ok_write_rps": 107.13333333333334, "rate": 0, "read_ms": {"max": 351.241, "p50": 10.035, "p95": 24.989, "p99": 46.448}, "requests": 3217, "timestamp": "2026-10-23T14:43:20Z", "warmup_s": 3, "write_ms": {"max": 459.041, "p50": 126.771, "p95": 209.064, "p99": 368.333}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.6, "cpu_pct_max_per_container": 25.3, "cpu_utilization_of_limit": 0.863, "mem_max_mib": 191.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.3, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.086, "mem_max_mib": 13.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 17.8, "cpu_pct_max_per_container": 19.4, "cpu_utilization_of_limit": 0.178, "mem_max_mib": 111.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 45.4, "cpu_pct_max_per_container": 51.6, "cpu_utilization_of_limit": 0.908, "mem_max_mib": 12.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.2, "total_max": 21}}, "pool": {"acquires": 11195, "empty_acquire_ratio": 0.0003, "avg_acquire_wait_ms": 0.014, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"20403b5e7dd2": 811, "5878b4f59f86": 806, "90ce2af85ed5": 802, "fde392dcbd85": 809}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 539.227, "p50": 41.803, "p95": 176.699, "p99": 348.648}, "mode": "closed", "ok": 3228, "ok_read_rps": 108.93333333333334, "ok_rps": 215.2, "ok_write_rps": 106.26666666666667, "rate": 0, "read_ms": {"max": 108.001, "p50": 10.354, "p95": 27.231, "p99": 50.291}, "requests": 3228, "timestamp": "2026-10-23T14:43:46Z", "warmup_s": 3, "write_ms": {"max": 539.227, "p50": 127.54, "p95": 226.683, "p99": 409.658}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.2, "cpu_pct_max_per_container": 25.3, "cpu_utilization_of_limit": 0.85, "mem_max_mib": 191.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.2, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.084, "mem_max_mib": 13.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 16.2, "cpu_pct_max_per_container": 19.2, "cpu_utilization_of_limit": 0.162, "mem_max_mib": 112.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 43.5, "cpu_pct_max_per_container": 51.4, "cpu_utilization_of_limit": 0.869, "mem_max_mib": 12.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.2, "total_max": 22}}, "pool": {"acquires": 11154, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.004, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"20403b5e7dd2": 903, "5878b4f59f86": 909, "90ce2af85ed5": 906, "fde392dcbd85": 896}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 3183.8, "p50": 311.463, "p95": 681.539, "p99": 832.174}, "mode": "closed", "ok": 3614, "ok_read_rps": 120.13333333333334, "ok_rps": 240.93333333333334, "ok_write_rps": 120.8, "rate": 0, "read_ms": {"max": 174.328, "p50": 28.137, "p95": 53.913, "p99": 100.624}, "requests": 3614, "timestamp": "2026-10-23T14:44:12Z", "warmup_s": 3, "write_ms": {"max": 3183.8, "p50": 468.303, "p95": 777.492, "p99": 912.512}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.6, "cpu_pct_max_per_container": 25.0, "cpu_utilization_of_limit": 0.822, "mem_max_mib": 187.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.4, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.087, "mem_max_mib": 13.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.8, "cpu_pct_max_per_container": 20.8, "cpu_utilization_of_limit": 0.198, "mem_max_mib": 228.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 41.4, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 0.827, "mem_max_mib": 13.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.2, "total_max": 72}}, "pool": {"acquires": 11975, "empty_acquire_ratio": 0.0047, "avg_acquire_wait_ms": 3.711, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"20403b5e7dd2": 865, "5878b4f59f86": 867, "90ce2af85ed5": 863, "fde392dcbd85": 868}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 957.273, "p50": 247.465, "p95": 657.692, "p99": 819.554}, "mode": "closed", "ok": 3463, "ok_read_rps": 115.2, "ok_rps": 230.86666666666667, "ok_write_rps": 115.66666666666667, "rate": 0, "read_ms": {"max": 210.36, "p50": 28.888, "p95": 62.524, "p99": 125.528}, "requests": 3463, "timestamp": "2026-10-23T14:44:53Z", "warmup_s": 3, "write_ms": {"max": 957.273, "p50": 493.995, "p95": 775.254, "p99": 841.666}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 7.6, "cpu_pct_max_per_container": 26.1, "cpu_utilization_of_limit": 0.304, "mem_max_mib": 192.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 0.3, "cpu_pct_max_per_container": 0.4, "cpu_utilization_of_limit": 0.006, "mem_max_mib": 13.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 1.6, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.016, "mem_max_mib": 230.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 1.6, "cpu_pct_max_per_container": 4.3, "cpu_utilization_of_limit": 0.032, "mem_max_mib": 13.2}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 72}}, "pool": {"acquires": 12301, "empty_acquire_ratio": 0.0004, "avg_acquire_wait_ms": 0.085, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8328302592"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"20403b5e7dd2": 850, "5878b4f59f86": 853, "90ce2af85ed5": 858, "fde392dcbd85": 858}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 956.796, "p50": 336.771, "p95": 681.084, "p99": 810.123}, "mode": "closed", "ok": 3419, "ok_read_rps": 112.46666666666667, "ok_rps": 227.93333333333334, "ok_write_rps": 115.46666666666667, "rate": 0, "read_ms": {"max": 208.312, "p50": 28.386, "p95": 61.974, "p99": 93.855}, "requests": 3419, "timestamp": "2026-10-23T14:45:27Z", "warmup_s": 3, "write_ms": {"max": 956.796, "p50": 494.582, "p95": 759.99, "p99": 854.555}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 10.6, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.422, "mem_max_mib": 192.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 1.1, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.022, "mem_max_mib": 13.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 21.1, "cpu_utilization_of_limit": 0.046, "mem_max_mib": 248.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 9.3, "cpu_pct_max_per_container": 50.0, "cpu_utilization_of_limit": 0.187, "mem_max_mib": 13.2}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 78}}, "pool": {"acquires": 12000, "empty_acquire_ratio": 0.0003, "avg_acquire_wait_ms": 0.038, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"001c6459141a": 3918}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 114.664, "p50": 13.522, "p95": 52.794, "p99": 59.218}, "mode": "closed", "ok": 3918, "ok_read_rps": 131.33333333333334, "ok_rps": 261.2, "ok_write_rps": 129.86666666666667, "rate": 0, "read_ms": {"max": 47.713, "p50": 2.448, "p95": 9.983, "p99": 38.884}, "requests": 3918, "timestamp": "2026-10-23T14:34:18Z", "warmup_s": 3, "write_ms": {"max": 114.664, "p50": 17.424, "p95": 55.212, "p99": 64.492}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 49.5, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 0.989, "mem_max_mib": 138.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 3.3, "cpu_pct_max_per_container": 3.5, "cpu_utilization_of_limit": 0.066, "mem_max_mib": 8.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 14.1, "cpu_pct_max_per_container": 16.5, "cpu_utilization_of_limit": 0.141, "mem_max_mib": 38.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 39.3, "cpu_pct_max_per_container": 41.1, "cpu_utilization_of_limit": 0.787, "mem_max_mib": 11.4}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 4}}, "pool": {"acquires": 13321, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"001c6459141a": 3411}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 308.403, "p50": 13.693, "p95": 53.401, "p99": 132.421}, "mode": "closed", "ok": 3411, "ok_read_rps": 112.86666666666666, "ok_rps": 227.4, "ok_write_rps": 114.53333333333333, "rate": 0, "read_ms": {"max": 85.419, "p50": 2.588, "p95": 7.287, "p99": 37.08}, "requests": 3411, "timestamp": "2026-10-23T14:34:41Z", "warmup_s": 3, "write_ms": {"max": 308.403, "p50": 18.045, "p95": 61.201, "p99": 222.467}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 46.1, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 0.922, "mem_max_mib": 235.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 3.1, "cpu_pct_max_per_container": 3.7, "cpu_utilization_of_limit": 0.061, "mem_max_mib": 8.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 13.2, "cpu_pct_max_per_container": 16.7, "cpu_utilization_of_limit": 0.132, "mem_max_mib": 43.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 36.3, "cpu_pct_max_per_container": 41.2, "cpu_utilization_of_limit": 0.725, "mem_max_mib": 10.1}, "postgres_connections": {"active_max": 4, "active_mean": 1, "total_max": 5}}, "pool": {"acquires": 11942, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"001c6459141a": 3879}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 179.476, "p50": 13.653, "p95": 52.413, "p99": 61.483}, "mode": "closed", "ok": 3879, "ok_read_rps": 128.2, "ok_rps": 258.6, "ok_write_rps": 130.4, "rate": 0, "read_ms": {"max": 43.423, "p50": 2.533, "p95": 9.354, "p99": 37.992}, "requests": 3879, "timestamp": "2026-10-23T14:35:03Z", "warmup_s": 3, "write_ms": {"max": 179.476, "p50": 17.413, "p95": 54.985, "p99": 66.978}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 49.9, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.999, "mem_max_mib": 241.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 3.3, "cpu_pct_max_per_container": 3.5, "cpu_utilization_of_limit": 0.066, "mem_max_mib": 8.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 14.0, "cpu_pct_max_per_container": 16.8, "cpu_utilization_of_limit": 0.14, "mem_max_mib": 46.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 39.2, "cpu_pct_max_per_container": 41.3, "cpu_utilization_of_limit": 0.784, "mem_max_mib": 10.1}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 5}}, "pool": {"acquires": 13174, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"001c6459141a": 4430}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 246.68, "p50": 47.849, "p95": 120.454, "p99": 159.961}, "mode": "closed", "ok": 4430, "ok_read_rps": 148, "ok_rps": 295.3333333333333, "ok_write_rps": 147.33333333333334, "rate": 0, "read_ms": {"max": 80.148, "p50": 5.895, "p95": 40.166, "p99": 48.433}, "requests": 4430, "timestamp": "2026-10-23T14:35:25Z", "warmup_s": 3, "write_ms": {"max": 246.68, "p50": 97.339, "p95": 141.491, "p99": 172.448}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 1.002, "mem_max_mib": 222.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.0, "cpu_pct_max_per_container": 4.3, "cpu_utilization_of_limit": 0.079, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 15.3, "cpu_pct_max_per_container": 19.3, "cpu_utilization_of_limit": 0.153, "mem_max_mib": 75.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 39.3, "cpu_pct_max_per_container": 41.9, "cpu_utilization_of_limit": 0.787, "mem_max_mib": 10.5}, "postgres_connections": {"active_max": 17, "active_mean": 2.4, "total_max": 18}}, "pool": {"acquires": 15020, "empty_acquire_ratio": 0.0008, "avg_acquire_wait_ms": 0.064, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"001c6459141a": 4504}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 197.171, "p50": 48.741, "p95": 113.349, "p99": 142.571}, "mode": "closed", "ok": 4504, "ok_read_rps": 148.4, "ok_rps": 300.26666666666665, "ok_write_rps": 151.86666666666667, "rate": 0, "read_ms": {"max": 64.72, "p50": 5.809, "p95": 42.931, "p99": 49.485}, "requests": 4504, "timestamp": "2026-10-23T14:35:47Z", "warmup_s": 3, "write_ms": {"max": 197.171, "p50": 96.315, "p95": 125.614, "p99": 148.26}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 0.999, "mem_max_mib": 60.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 3.8, "cpu_pct_max_per_container": 4.2, "cpu_utilization_of_limit": 0.075, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 13.5, "cpu_pct_max_per_container": 16.0, "cpu_utilization_of_limit": 0.135, "mem_max_mib": 77.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 39.5, "cpu_pct_max_per_container": 41.0, "cpu_utilization_of_limit": 0.791, "mem_max_mib": 10.7}, "postgres_connections": {"active_max": 5, "active_mean": 1.4, "total_max": 17}}, "pool": {"acquires": 15370, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"001c6459141a": 4399}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 195.29, "p50": 49.928, "p95": 118.685, "p99": 151.751}, "mode": "closed", "ok": 4399, "ok_read_rps": 145.13333333333333, "ok_rps": 293.26666666666665, "ok_write_rps": 148.13333333333333, "rate": 0, "read_ms": {"max": 58.993, "p50": 5.855, "p95": 41.171, "p99": 47.869}, "requests": 4399, "timestamp": "2026-10-23T14:36:09Z", "warmup_s": 3, "write_ms": {"max": 195.29, "p50": 97.314, "p95": 138.213, "p99": 163.065}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 49.8, "cpu_pct_max_per_container": 50.0, "cpu_utilization_of_limit": 0.995, "mem_max_mib": 59.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 3.9, "cpu_pct_max_per_container": 4.0, "cpu_utilization_of_limit": 0.077, "mem_max_mib": 8.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 14.0, "cpu_pct_max_per_container": 16.5, "cpu_utilization_of_limit": 0.14, "mem_max_mib": 79.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 40.1, "cpu_pct_max_per_container": 41.0, "cpu_utilization_of_limit": 0.801, "mem_max_mib": 11.0}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 17}}, "pool": {"acquires": 15188, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"001c6459141a": 4218}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 531.129, "p50": 359.772, "p95": 464.869, "p99": 486.801}, "mode": "closed", "ok": 4218, "ok_read_rps": 136.26666666666668, "ok_rps": 281.2, "ok_write_rps": 144.93333333333334, "rate": 0, "read_ms": {"max": 82.185, "p50": 18, "p95": 58.757, "p99": 65.194}, "requests": 4218, "timestamp": "2026-10-23T14:36:32Z", "warmup_s": 3, "write_ms": {"max": 531.129, "p50": 409.441, "p95": 476.712, "p99": 493.077}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 1.003, "mem_max_mib": 61.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 3.7, "cpu_pct_max_per_container": 4.1, "cpu_utilization_of_limit": 0.074, "mem_max_mib": 9.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 13.6, "cpu_pct_max_per_container": 16.6, "cpu_utilization_of_limit": 0.136, "mem_max_mib": 87.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 39.3, "cpu_pct_max_per_container": 42.9, "cpu_utilization_of_limit": 0.786, "mem_max_mib": 11.0}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 20}}, "pool": {"acquires": 14857, "empty_acquire_ratio": 0.0114, "avg_acquire_wait_ms": 0.075, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"001c6459141a": 4286}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 580.69, "p50": 341.541, "p95": 473.846, "p99": 519.228}, "mode": "closed", "ok": 4286, "ok_read_rps": 142.06666666666666, "ok_rps": 285.73333333333335, "ok_write_rps": 143.66666666666666, "rate": 0, "read_ms": {"max": 117.574, "p50": 18.312, "p95": 61.107, "p99": 68.816}, "requests": 4286, "timestamp": "2026-10-23T14:36:54Z", "warmup_s": 3, "write_ms": {"max": 580.69, "p50": 406.98, "p95": 488.949, "p99": 535.696}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 1.0, "mem_max_mib": 60.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 3.7, "cpu_pct_max_per_container": 4.1, "cpu_utilization_of_limit": 0.074, "mem_max_mib": 9.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 12.4, "cpu_pct_max_per_container": 15.2, "cpu_utilization_of_limit": 0.124, "mem_max_mib": 89.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 38.6, "cpu_pct_max_per_container": 40.4, "cpu_utilization_of_limit": 0.771, "mem_max_mib": 11.2}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 20}}, "pool": {"acquires": 15064, "empty_acquire_ratio": 0.0121, "avg_acquire_wait_ms": 0.028, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"001c6459141a": 4281}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 592.847, "p50": 89.774, "p95": 476.506, "p99": 509.366}, "mode": "closed", "ok": 4281, "ok_read_rps": 142.73333333333332, "ok_rps": 285.4, "ok_write_rps": 142.66666666666666, "rate": 0, "read_ms": {"max": 89.774, "p50": 18.707, "p95": 60.261, "p99": 69.746}, "requests": 4281, "timestamp": "2026-10-23T14:37:16Z", "warmup_s": 3, "write_ms": {"max": 592.847, "p50": 410.075, "p95": 490.546, "p99": 518.618}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 1.003, "mem_max_mib": 61.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 3.9, "cpu_pct_max_per_container": 4.4, "cpu_utilization_of_limit": 0.077, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 13.0, "cpu_pct_max_per_container": 15.8, "cpu_utilization_of_limit": 0.13, "mem_max_mib": 91.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 38.8, "cpu_pct_max_per_container": 40.8, "cpu_utilization_of_limit": 0.776, "mem_max_mib": 10.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 20}}, "pool": {"acquires": 14979, "empty_acquire_ratio": 0.0023, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 2370, "cd48d42532fc": 2371}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 73.235, "p50": 11.443, "p95": 33.582, "p99": 42.05}, "mode": "closed", "ok": 4741, "ok_read_rps": 162.66666666666666, "ok_rps": 316.06666666666666, "ok_write_rps": 153.4, "rate": 0, "read_ms": {"max": 49.127, "p50": 2.69, "p95": 6.717, "p99": 17.01}, "requests": 4741, "timestamp": "2026-10-23T14:37:48Z", "warmup_s": 3, "write_ms": {"max": 73.235, "p50": 19.389, "p95": 37.273, "p99": 47.131}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.3, "cpu_pct_max_per_container": 39.4, "cpu_utilization_of_limit": 0.767, "mem_max_mib": 138.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.2, "cpu_pct_max_per_container": 4.5, "cpu_utilization_of_limit": 0.085, "mem_max_mib": 9.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 14.9, "cpu_pct_max_per_container": 16.7, "cpu_utilization_of_limit": 0.149, "mem_max_mib": 63.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.7, "cpu_pct_max_per_container": 52.2, "cpu_utilization_of_limit": 1.014, "mem_max_mib": 11.7}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 7}}, "pool": {"acquires": 15886, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 2345, "cd48d42532fc": 2345}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 83.208, "p50": 12.577, "p95": 33.888, "p99": 41.905}, "mode": "closed", "ok": 4690, "ok_read_rps": 159.13333333333333, "ok_rps": 312.6666666666667, "ok_write_rps": 153.53333333333333, "rate": 0, "read_ms": {"max": 35.372, "p50": 2.715, "p95": 6.411, "p99": 20.697}, "requests": 4690, "timestamp": "2026-10-23T14:38:09Z", "warmup_s": 3, "write_ms": {"max": 83.208, "p50": 19.34, "p95": 37.748, "p99": 46.219}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.9, "cpu_pct_max_per_container": 40.1, "cpu_utilization_of_limit": 0.779, "mem_max_mib": 242.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.2, "cpu_pct_max_per_container": 4.4, "cpu_utilization_of_limit": 0.084, "mem_max_mib": 9.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 14.8, "cpu_pct_max_per_container": 16.1, "cpu_utilization_of_limit": 0.148, "mem_max_mib": 64.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 51.1, "cpu_pct_max_per_container": 52.2, "cpu_utilization_of_limit": 1.022, "mem_max_mib": 11.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 7}}, "pool": {"acquires": 15717, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 2284, "cd48d42532fc": 2283}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 112.953, "p50": 13.624, "p95": 33.813, "p99": 41.912}, "mode": "closed", "ok": 4567, "ok_read_rps": 150.2, "ok_rps": 304.46666666666664, "ok_write_rps": 154.26666666666668, "rate": 0, "read_ms": {"max": 41.912, "p50": 2.718, "p95": 6.749, "p99": 19.025}, "requests": 4567, "timestamp": "2026-10-23T14:38:29Z", "warmup_s": 3, "write_ms": {"max": 112.953, "p50": 19.384, "p95": 37.516, "p99": 49.564}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.4, "cpu_pct_max_per_container": 39.7, "cpu_utilization_of_limit": 0.767, "mem_max_mib": 240.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 3.9, "cpu_pct_max_per_container": 4.2, "cpu_utilization_of_limit": 0.078, "mem_max_mib": 9.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.5, "cpu_pct_max_per_container": 41.0, "cpu_utilization_of_limit": 0.185, "mem_max_mib": 66.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.5, "cpu_pct_max_per_container": 51.4, "cpu_utilization_of_limit": 1.009, "mem_max_mib": 11.5}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 7}}, "pool": {"acquires": 15467, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 2706, "cd48d42532fc": 2701}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 228.815, "p50": 24.924, "p95": 109.309, "p99": 139.739}, "mode": "closed", "ok": 5407, "ok_read_rps": 184.6, "ok_rps": 360.46666666666664, "ok_write_rps": 175.86666666666667, "rate": 0, "read_ms": {"max": 83.242, "p50": 6.628, "p95": 21.578, "p99": 31.247}, "requests": 5407, "timestamp": "2026-10-23T14:38:49Z", "warmup_s": 3, "write_ms": {"max": 228.815, "p50": 81.283, "p95": 119.822, "p99": 162.361}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 37.0, "cpu_pct_max_per_container": 40.5, "cpu_utilization_of_limit": 0.74, "mem_max_mib": 234.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.093, "mem_max_mib": 9.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.0, "cpu_pct_max_per_container": 19.1, "cpu_utilization_of_limit": 0.18, "mem_max_mib": 89.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 1.003, "mem_max_mib": 12.4}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 16}}, "pool": {"acquires": 18333, "empty_acquire_ratio": 0.0005, "avg_acquire_wait_ms": 0.015, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 2647, "cd48d42532fc": 2646}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 188.414, "p50": 27.74, "p95": 111.063, "p99": 138.03}, "mode": "closed", "ok": 5293, "ok_read_rps": 177.93333333333334, "ok_rps": 352.8666666666667, "ok_write_rps": 174.93333333333334, "rate": 0, "read_ms": {"max": 42.505, "p50": 6.699, "p95": 19.891, "p99": 30.272}, "requests": 5293, "timestamp": "2026-10-23T14:39:09Z", "warmup_s": 3, "write_ms": {"max": 188.414, "p50": 82.411, "p95": 122.014, "p99": 151.652}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 37.2, "cpu_pct_max_per_container": 38.7, "cpu_utilization_of_limit": 0.744, "mem_max_mib": 230.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.093, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.1, "cpu_pct_max_per_container": 19.2, "cpu_utilization_of_limit": 0.181, "mem_max_mib": 96.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.3, "cpu_pct_max_per_container": 51.4, "cpu_utilization_of_limit": 1.005, "mem_max_mib": 12.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 18}}, "pool": {"acquires": 17871, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 2675, "cd48d42532fc": 2668}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 194.73, "p50": 23.119, "p95": 108.582, "p99": 133.771}, "mode": "closed", "ok": 5343, "ok_read_rps": 183.26666666666668, "ok_rps": 356.2, "ok_write_rps": 172.93333333333334, "rate": 0, "read_ms": {"max": 56.582, "p50": 6.812, "p95": 20.59, "p99": 29.359}, "requests": 5343, "timestamp": "2026-10-23T14:39:30Z", "warmup_s": 3, "write_ms": {"max": 194.73, "p50": 83.425, "p95": 118.859, "p99": 148.672}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 37.3, "cpu_pct_max_per_container": 39.2, "cpu_utilization_of_limit": 0.747, "mem_max_mib": 240.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.094, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.0, "cpu_pct_max_per_container": 42.4, "cpu_utilization_of_limit": 0.22, "mem_max_mib": 99.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.9, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 0.997, "mem_max_mib": 12.3}, "postgres_connections": {"active_max": 2, "active_mean": 0.7, "total_max": 19}}, "pool": {"acquires": 18138, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 2771, "cd48d42532fc": 2759}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 567.256, "p50": 56.616, "p95": 442.847, "p99": 505.666}, "mode": "closed", "ok": 5530, "ok_read_rps": 186.53333333333333, "ok_rps": 368.6666666666667, "ok_write_rps": 182.13333333333333, "rate": 0, "read_ms": {"max": 99.284, "p50": 21.816, "p95": 45.334, "p99": 58.466}, "requests": 5530, "timestamp": "2026-10-23T14:39:50Z", "warmup_s": 3, "write_ms": {"max": 567.256, "p50": 326.697, "p95": 478.442, "p99": 520.102}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.3, "cpu_pct_max_per_container": 43.2, "cpu_utilization_of_limit": 0.766, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.092, "mem_max_mib": 10.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.8, "cpu_pct_max_per_container": 22.3, "cpu_utilization_of_limit": 0.188, "mem_max_mib": 151.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 12.8}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 40}}, "pool": {"acquires": 18636, "empty_acquire_ratio": 0.0076, "avg_acquire_wait_ms": 0.261, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 2811, "cd48d42532fc": 2794}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 615.284, "p50": 56.084, "p95": 459.999, "p99": 511.749}, "mode": "closed", "ok": 5605, "ok_read_rps": 190.46666666666667, "ok_rps": 373.6666666666667, "ok_write_rps": 183.2, "rate": 0, "read_ms": {"max": 81.006, "p50": 22.016, "p95": 48.627, "p99": 61.336}, "requests": 5605, "timestamp": "2026-10-23T14:40:15Z", "warmup_s": 3, "write_ms": {"max": 615.284, "p50": 323.333, "p95": 485.04, "p99": 529.424}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 34.5, "cpu_pct_max_per_container": 44.5, "cpu_utilization_of_limit": 0.691, "mem_max_mib": 254.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.1, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.082, "mem_max_mib": 10.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 16.5, "cpu_pct_max_per_container": 19.9, "cpu_utilization_of_limit": 0.165, "mem_max_mib": 154.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 43.0, "cpu_pct_max_per_container": 51.6, "cpu_utilization_of_limit": 0.861, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 40}}, "pool": {"acquires": 19149, "empty_acquire_ratio": 0.0087, "avg_acquire_wait_ms": 0.039, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 2800, "cd48d42532fc": 2782}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 703.434, "p50": 56.621, "p95": 473.676, "p99": 561.617}, "mode": "closed", "ok": 5582, "ok_read_rps": 191.13333333333333, "ok_rps": 372.1333333333333, "ok_write_rps": 181, "rate": 0, "read_ms": {"max": 113.556, "p50": 22.654, "p95": 51.205, "p99": 69.548}, "requests": 5582, "timestamp": "2026-10-23T14:40:37Z", "warmup_s": 3, "write_ms": {"max": 703.434, "p50": 327.838, "p95": 502.679, "p99": 654.651}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.3, "cpu_pct_max_per_container": 41.0, "cpu_utilization_of_limit": 0.765, "mem_max_mib": 40.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 21.5, "cpu_utilization_of_limit": 0.196, "mem_max_mib": 159.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 1.003, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 40}}, "pool": {"acquires": 19109, "empty_acquire_ratio": 0.0097, "avg_acquire_wait_ms": 0.119, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 1092, "5c70ffea9eee": 1092, "cd48d42532fc": 1094, "de9c579d8a0c": 1094}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 121.981, "p50": 11.582, "p95": 32.159, "p99": 43.739}, "mode": "closed", "ok": 4372, "ok_read_rps": 148.46666666666667, "ok_rps": 291.46666666666664, "ok_write_rps": 143, "rate": 0, "read_ms": {"max": 34.712, "p50": 3.032, "p95": 7.371, "p99": 14.348}, "requests": 4372, "timestamp": "2026-10-23T14:41:04Z", "warmup_s": 3, "write_ms": {"max": 121.981, "p50": 21.957, "p95": 36.549, "p99": 50.438}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.8, "cpu_pct_max_per_container": 24.0, "cpu_utilization_of_limit": 0.436, "mem_max_mib": 137.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.1, "cpu_pct_max_per_container": 4.2, "cpu_utilization_of_limit": 0.082, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 15.8, "cpu_pct_max_per_container": 18.4, "cpu_utilization_of_limit": 0.158, "mem_max_mib": 171.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.3, "cpu_utilization_of_limit": 1.0, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 45}}, "pool": {"acquires": 14774, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 1086, "5c70ffea9eee": 1086, "cd48d42532fc": 1085, "de9c579d8a0c": 1086}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 73.47, "p50": 13.242, "p95": 33.045, "p99": 43.853}, "mode": "closed", "ok": 4343, "ok_read_rps": 144.86666666666667, "ok_rps": 289.53333333333336, "ok_write_rps": 144.66666666666666, "rate": 0, "read_ms": {"max": 38.529, "p50": 3.081, "p95": 7.457, "p99": 14.336}, "requests": 4343, "timestamp": "2026-10-23T14:41:24Z", "warmup_s": 3, "write_ms": {"max": 73.47, "p50": 21.781, "p95": 37.56, "p99": 49.301}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.0, "cpu_pct_max_per_container": 25.8, "cpu_utilization_of_limit": 0.44, "mem_max_mib": 225.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.2, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.084, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.6, "cpu_pct_max_per_container": 44.0, "cpu_utilization_of_limit": 0.206, "mem_max_mib": 188.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.8, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 0.995, "mem_max_mib": 19.0}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 45}}, "pool": {"acquires": 14891, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 1097, "5c70ffea9eee": 1096, "cd48d42532fc": 1096, "de9c579d8a0c": 1095}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 81.448, "p50": 12.109, "p95": 32.346, "p99": 42.702}, "mode": "closed", "ok": 4384, "ok_read_rps": 147.53333333333333, "ok_rps": 292.26666666666665, "ok_write_rps": 144.73333333333332, "rate": 0, "read_ms": {"max": 23.455, "p50": 3.049, "p95": 6.875, "p99": 14.373}, "requests": 4384, "timestamp": "2026-10-23T14:41:45Z", "warmup_s": 3, "write_ms": {"max": 81.448, "p50": 21.99, "p95": 36.64, "p99": 47.802}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 24.7, "cpu_utilization_of_limit": 0.445, "mem_max_mib": 227.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.2, "cpu_pct_max_per_container": 4.5, "cpu_utilization_of_limit": 0.083, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 16.5, "cpu_pct_max_per_container": 18.5, "cpu_utilization_of_limit": 0.165, "mem_max_mib": 175.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.8, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 1.015, "mem_max_mib": 18.7}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 45}}, "pool": {"acquires": 14890, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 1218, "5c70ffea9eee": 1222, "cd48d42532fc": 1222, "de9c579d8a0c": 1223}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 194.489, "p50": 52.653, "p95": 114.106, "p99": 140.182}, "mode": "closed", "ok": 4885, "ok_read_rps": 160.73333333333332, "ok_rps": 325.6666666666667, "ok_write_rps": 164.93333333333334, "rate": 0, "read_ms": {"max": 54.732, "p50": 6.751, "p95": 16.822, "p99": 25.64}, "requests": 4885, "timestamp": "2026-10-23T14:42:05Z", "warmup_s": 3, "write_ms": {"max": 194.489, "p50": 86.554, "p95": 124.32, "p99": 149.619}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.9, "cpu_pct_max_per_container": 25.2, "cpu_utilization_of_limit": 0.438, "mem_max_mib": 229.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.4, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.089, "mem_max_mib": 9.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.0, "cpu_pct_max_per_container": 20.0, "cpu_utilization_of_limit": 0.18, "mem_max_mib": 182.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.7, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 0.995, "mem_max_mib": 19.1}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 47}}, "pool": {"acquires": 16936, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.007, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 1236, "5c70ffea9eee": 1240, "cd48d42532fc": 1234, "de9c579d8a0c": 1239}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 202.013, "p50": 20.491, "p95": 117.963, "p99": 142.834}, "mode": "closed", "ok": 4949, "ok_read_rps": 169.33333333333334, "ok_rps": 329.93333333333334, "ok_write_rps": 160.6, "rate": 0, "read_ms": {"max": 103.153, "p50": 6.884, "p95": 17.265, "p99": 26.088}, "requests": 4949, "timestamp": "2026-10-23T14:42:26Z", "warmup_s": 3, "write_ms": {"max": 202.013, "p50": 87.423, "p95": 129.629, "p99": 152.991}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.0, "cpu_pct_max_per_container": 26.4, "cpu_utilization_of_limit": 0.439, "mem_max_mib": 231.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.091, "mem_max_mib": 9.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.9, "cpu_pct_max_per_container": 33.6, "cpu_utilization_of_limit": 0.219, "mem_max_mib": 196.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.1, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 0.981, "mem_max_mib": 18.6}, "postgres_connections": {"active_max": 2, "active_mean": 0.4, "total_max": 52}}, "pool": {"acquires": 17007, "empty_acquire_ratio": 0.0003, "avg_acquire_wait_ms": 0.013, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 1237, "5c70ffea9eee": 1239, "cd48d42532fc": 1236, "de9c579d8a0c": 1236}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 187.038, "p50": 34.247, "p95": 114.185, "p99": 134.503}, "mode": "closed", "ok": 4948, "ok_read_rps": 164.86666666666667, "ok_rps": 329.8666666666667, "ok_write_rps": 165, "rate": 0, "read_ms": {"max": 37.162, "p50": 6.965, "p95": 16.502, "p99": 25.77}, "requests": 4948, "timestamp": "2026-10-23T14:42:47Z", "warmup_s": 3, "write_ms": {"max": 187.038, "p50": 85.71, "p95": 125.278, "p99": 139.851}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.1, "cpu_pct_max_per_container": 25.4, "cpu_utilization_of_limit": 0.442, "mem_max_mib": 229.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.5, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.089, "mem_max_mib": 9.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.2, "cpu_pct_max_per_container": 19.9, "cpu_utilization_of_limit": 0.182, "mem_max_mib": 198.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 1.0, "mem_max_mib": 19.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 52}}, "pool": {"acquires": 16964, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 1353, "5c70ffea9eee": 1342, "cd48d42532fc": 1352, "de9c579d8a0c": 1347}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 508.536, "p50": 55.616, "p95": 403.363, "p99": 451.244}, "mode": "closed", "ok": 5394, "ok_read_rps": 181.33333333333334, "ok_rps": 359.6, "ok_write_rps": 178.26666666666668, "rate": 0, "read_ms": {"max": 109.514, "p50": 19.143, "p95": 36.117, "p99": 54.562}, "requests": 5394, "timestamp": "2026-10-23T14:43:06Z", "warmup_s": 3, "write_ms": {"max": 508.536, "p50": 333.356, "p95": 423.272, "p99": 466.402}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.4, "cpu_pct_max_per_container": 25.5, "cpu_utilization_of_limit": 0.429, "mem_max_mib": 238.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.8, "cpu_pct_max_per_container": 21.9, "cpu_utilization_of_limit": 0.198, "mem_max_mib": 265.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.7, "cpu_pct_max_per_container": 49.8, "cpu_utilization_of_limit": 0.974, "mem_max_mib": 14.2}, "postgres_connections": {"active_max": 10, "active_mean": 1.6, "total_max": 80}}, "pool": {"acquires": 18559, "empty_acquire_ratio": 0.0019, "avg_acquire_wait_ms": 0.371, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 1296, "5c70ffea9eee": 1304, "cd48d42532fc": 1296, "de9c579d8a0c": 1299}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 508.324, "p50": 259.877, "p95": 399.519, "p99": 466.457}, "mode": "closed", "ok": 5195, "ok_read_rps": 169.4, "ok_rps": 346.3333333333333, "ok_write_rps": 176.93333333333334, "rate": 0, "read_ms": {"max": 89.738, "p50": 19.343, "p95": 37.504, "p99": 50.751}, "requests": 5195, "timestamp": "2026-10-23T14:43:29Z", "warmup_s": 3, "write_ms": {"max": 508.324, "p50": 334.261, "p95": 418.514, "p99": 481.621}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 26.5, "cpu_utilization_of_limit": 0.427, "mem_max_mib": 143.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 10.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.7, "cpu_pct_max_per_container": 25.7, "cpu_utilization_of_limit": 0.207, "mem_max_mib": 270.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.7, "cpu_pct_max_per_container": 51.3, "cpu_utilization_of_limit": 0.973, "mem_max_mib": 13.8}, "postgres_connections": {"active_max": 3, "active_mean": 0.7, "total_max": 81}}, "pool": {"acquires": 18226, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4ce9274b9aae": 1336, "5c70ffea9eee": 1337, "cd48d42532fc": 1343, "de9c579d8a0c": 1334}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 616.677, "p50": 62.225, "p95": 397.118, "p99": 461.762}, "mode": "closed", "ok": 5350, "ok_read_rps": 179.66666666666666, "ok_rps": 356.6666666666667, "ok_write_rps": 177, "rate": 0, "read_ms": {"max": 89.574, "p50": 20.466, "p95": 44.001, "p99": 60.537}, "requests": 5350, "timestamp": "2026-10-23T14:43:51Z", "warmup_s": 3, "write_ms": {"max": 616.677, "p50": 329.293, "p95": 424.137, "p99": 492.729}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 24.1, "cpu_utilization_of_limit": 0.425, "mem_max_mib": 60.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.092, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.2, "cpu_pct_max_per_container": 22.3, "cpu_utilization_of_limit": 0.202, "mem_max_mib": 274.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.3, "cpu_pct_max_per_container": 49.6, "cpu_utilization_of_limit": 0.965, "mem_max_mib": 14.1}, "postgres_connections": {"active_max": 4, "active_mean": 0.6, "total_max": 80}}, "pool": {"acquires": 18321, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "baseline_scan", "concurrency": 32, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"074a8b7940e4": 809, "9ceebc37add9": 807, "a83821c5b3de": 816, "ef97c1526227": 808}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 480.444, "p50": 55.6, "p95": 343.19, "p99": 393.898}, "mode": "closed", "ok": 3240, "ok_read_rps": 108.8, "ok_rps": 216, "ok_write_rps": 107.2, "rate": 0, "read_ms": {"max": 79.168, "p50": 17.641, "p95": 38.355, "p99": 53.482}, "requests": 3240, "timestamp": "2026-10-23T14:34:25Z", "warmup_s": 3, "write_ms": {"max": 480.444, "p50": 270.406, "p95": 372.161, "p99": 415.014}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.3, "cpu_pct_max_per_container": 22.6, "cpu_utilization_of_limit": 0.366, "mem_max_mib": 143.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.5, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.09, "mem_max_mib": 11.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.6, "cpu_pct_max_per_container": 21.5, "cpu_utilization_of_limit": 0.186, "mem_max_mib": 120.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 11.7}, "postgres_connections": {"active_max": 2, "active_mean": 0.7, "total_max": 43}}, "pool": {"acquires": 10963, "empty_acquire_ratio": 0.0028, "avg_acquire_wait_ms": 0.885, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "baseline_scan", "concurrency": 32, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"074a8b7940e4": 805, "9ceebc37add9": 801, "a83821c5b3de": 801, "ef97c1526227": 803}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 499.833, "p50": 50.046, "p95": 346.308, "p99": 403.28}, "mode": "closed", "ok": 3210, "ok_read_rps": 109, "ok_rps": 214, "ok_write_rps": 105, "rate": 0, "read_ms": {"max": 79.913, "p50": 18.522, "p95": 40.961, "p99": 55.63}, "requests": 3210, "timestamp": "2026-10-23T14:34:47Z", "warmup_s": 3, "write_ms": {"max": 499.833, "p50": 274.686, "p95": 375.723, "p99": 429.871}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.8, "cpu_pct_max_per_container": 22.3, "cpu_utilization_of_limit": 0.377, "mem_max_mib": 209.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.093, "mem_max_mib": 10.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.2, "cpu_pct_max_per_container": 27.4, "cpu_utilization_of_limit": 0.202, "mem_max_mib": 127.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.4, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 11.7}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 43}}, "pool": {"acquires": 11277, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "baseline_scan", "concurrency": 32, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"074a8b7940e4": 800, "9ceebc37add9": 793, "a83821c5b3de": 796, "ef97c1526227": 805}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 447.455, "p50": 49.138, "p95": 346.988, "p99": 399.773}, "mode": "closed", "ok": 3194, "ok_read_rps": 107.4, "ok_rps": 212.93333333333334, "ok_write_rps": 105.53333333333333, "rate": 0, "read_ms": {"max": 63.882, "p50": 17.581, "p95": 37.358, "p99": 48.591}, "requests": 3194, "timestamp": "2026-10-23T14:35:09Z", "warmup_s": 3, "write_ms": {"max": 447.455, "p50": 276.924, "p95": 378.216, "p99": 414.435}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.8, "cpu_pct_max_per_container": 22.8, "cpu_utilization_of_limit": 0.376, "mem_max_mib": 207.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.092, "mem_max_mib": 11.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.1, "cpu_pct_max_per_container": 22.9, "cpu_utilization_of_limit": 0.191, "mem_max_mib": 133.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 0.999, "mem_max_mib": 11.8}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 44}}, "pool": {"acquires": 11034, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.016, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "baseline_scan", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"074a8b7940e4": 866, "9ceebc37add9": 869, "a83821c5b3de": 864, "ef97c1526227": 864}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 754.606, "p50": 401.915, "p95": 609.329, "p99": 701.168}, "mode": "closed", "ok": 3463, "ok_read_rps": 112.86666666666666, "ok_rps": 230.86666666666667, "ok_write_rps": 118, "rate": 0, "read_ms": {"max": 113.323, "p50": 29.67, "p95": 62.856, "p99": 89.429}, "requests": 3463, "timestamp": "2026-10-23T14:35:31Z", "warmup_s": 3, "write_ms": {"max": 754.606, "p50": 496.038, "p95": 643.582, "p99": 727.024}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.2, "cpu_pct_max_per_container": 24.7, "cpu_utilization_of_limit": 0.403, "mem_max_mib": 213.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 11.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.4, "cpu_pct_max_per_container": 22.5, "cpu_utilization_of_limit": 0.204, "mem_max_mib": 168.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.0, "cpu_pct_max_per_container": 49.9, "cpu_utilization_of_limit": 0.98, "mem_max_mib": 12.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 59}}, "pool": {"acquires": 12136, "empty_acquire_ratio": 0.0012, "avg_acquire_wait_ms": 0.331, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "baseline_scan", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"074a8b7940e4": 809, "9ceebc37add9": 807, "a83821c5b3de": 804, "ef97c1526227": 800}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 861.119, "p50": 421.281, "p95": 658.306, "p99": 749.117}, "mode": "closed", "ok": 3220, "ok_read_rps": 105.2, "ok_rps": 214.66666666666666, "ok_write_rps": 109.46666666666667, "rate": 0, "read_ms": {"max": 110.492, "p50": 33.069, "p95": 61.721, "p99": 85.171}, "requests": 3220, "timestamp": "2026-10-23T14:35:53Z", "warmup_s": 3, "write_ms": {"max": 861.119, "p50": 534.242, "p95": 697.435, "p99": 786.041}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.391, "mem_max_mib": 156.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.093, "mem_max_mib": 12.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 17.9, "cpu_pct_max_per_container": 19.8, "cpu_utilization_of_limit": 0.179, "mem_max_mib": 182.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.4, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 0.988, "mem_max_mib": 12.5}, "postgres_connections": {"active_max": 1, "active_mean": 0.6, "total_max": 64}}, "pool": {"acquires": 11643, "empty_acquire_ratio": 0.0004, "avg_acquire_wait_ms": 0.122, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "baseline_scan", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"074a8b7940e4": 836, "9ceebc37add9": 828, "a83821c5b3de": 835, "ef97c1526227": 829}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 852.776, "p50": 95.855, "p95": 620.879, "p99": 740.317}, "mode": "closed", "ok": 3328, "ok_read_rps": 111.06666666666666, "ok_rps": 221.86666666666667, "ok_write_rps": 110.8, "rate": 0, "read_ms": {"max": 100.877, "p50": 30.605, "p95": 54.722, "p99": 75.267}, "requests": 3328, "timestamp": "2026-10-23T14:36:14Z", "warmup_s": 3, "write_ms": {"max": 852.776, "p50": 533.211, "p95": 669.904, "p99": 796.461}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.5, "cpu_pct_max_per_container": 22.2, "cpu_utilization_of_limit": 0.39, "mem_max_mib": 61.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 12.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.0, "cpu_pct_max_per_container": 20.8, "cpu_utilization_of_limit": 0.18, "mem_max_mib": 185.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 50.4, "cpu_utilization_of_limit": 0.992, "mem_max_mib": 12.5}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 64}}, "pool": {"acquires": 11946, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "cache_version", "concurrency": 32, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"18f4659cfb1f": 2122, "445b1fc8eebe": 2126, "65033444049d": 2123, "e05fce47f6df": 2125}, "label": "D_improvement/cache_version", "latency_ms": {"max": 652.443, "p50": 49.186, "p95": 120.907, "p99": 155.456}, "mode": "closed", "ok": 8496, "ok_read_rps": 279.8666666666667, "ok_rps": 566.4, "ok_write_rps": 286.53333333333336, "rate": 0, "read_ms": {"max": 617.775, "p50": 25.431, "p95": 57.574, "p99": 81.867}, "requests": 8496, "timestamp": "2026-10-23T14:36:48Z", "warmup_s": 3, "write_ms": {"max": 652.443, "p50": 81.663, "p95": 134.812, "p99": 169.436}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.1, "cpu_pct_max_per_container": 21.7, "cpu_utilization_of_limit": 0.381, "mem_max_mib": 138.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 10.1, "cpu_pct_max_per_container": 10.8, "cpu_utilization_of_limit": 0.201, "mem_max_mib": 11.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 58.1, "cpu_pct_max_per_container": 59.5, "cpu_utilization_of_limit": 0.581, "mem_max_mib": 167.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 11.1, "cpu_pct_max_per_container": 12.0, "cpu_utilization_of_limit": 0.221, "mem_max_mib": 30.5}, "postgres_connections": {"active_max": 24, "active_mean": 12.2, "total_max": 54}}, "pool": {"acquires": 28204, "empty_acquire_ratio": 0.0016, "avg_acquire_wait_ms": 0.277, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "cache_version", "concurrency": 32, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"18f4659cfb1f": 2044, "445b1fc8eebe": 2034, "65033444049d": 2041, "e05fce47f6df": 2036}, "label": "D_improvement/cache_version", "latency_ms": {"max": 894.722, "p50": 45.401, "p95": 154.957, "p99": 230.866}, "mode": "closed", "ok": 8155, "ok_read_rps": 276.73333333333335, "ok_rps": 543.6666666666666, "ok_write_rps": 266.93333333333334, "rate": 0, "read_ms": {"max": 536.296, "p50": 31.693, "p95": 96.418, "p99": 155.218}, "requests": 8155, "timestamp": "2026-10-23T14:37:09Z", "warmup_s": 3, "write_ms": {"max": 894.722, "p50": 68.24, "p95": 181.405, "p99": 251.414}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.9, "cpu_pct_max_per_container": 21.5, "cpu_utilization_of_limit": 0.379, "mem_max_mib": 254.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.9, "cpu_pct_max_per_container": 9.7, "cpu_utilization_of_limit": 0.179, "mem_max_mib": 12.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 54.4, "cpu_pct_max_per_container": 56.7, "cpu_utilization_of_limit": 0.544, "mem_max_mib": 210.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 12.7, "cpu_pct_max_per_container": 16.1, "cpu_utilization_of_limit": 0.253, "mem_max_mib": 47.2}, "postgres_connections": {"active_max": 26, "active_mean": 12.2, "total_max": 72}}, "pool": {"acquires": 28009, "empty_acquire_ratio": 0.0013, "avg_acquire_wait_ms": 0.108, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "cache_version", "concurrency": 32, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"18f4659cfb1f": 2025, "445b1fc8eebe": 2028, "65033444049d": 2022, "e05fce47f6df": 2027}, "label": "D_improvement/cache_version", "latency_ms": {"max": 410.017, "p50": 48.6, "p95": 129.574, "p99": 174.329}, "mode": "closed", "ok": 8102, "ok_read_rps": 272.6, "ok_rps": 540.1333333333333, "ok_write_rps": 267.53333333333336, "rate": 0, "read_ms": {"max": 227.829, "p50": 27.995, "p95": 66.599, "p99": 104.898}, "requests": 8102, "timestamp": "2026-10-23T14:37:34Z", "warmup_s": 3, "write_ms": {"max": 410.017, "p50": 84.933, "p95": 145.261, "p99": 211.966}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.8, "cpu_pct_max_per_container": 19.8, "cpu_utilization_of_limit": 0.375, "mem_max_mib": 140.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.8, "cpu_pct_max_per_container": 10.1, "cpu_utilization_of_limit": 0.195, "mem_max_mib": 12.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 59.6, "cpu_pct_max_per_container": 69.2, "cpu_utilization_of_limit": 0.596, "mem_max_mib": 228.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 12.1, "cpu_pct_max_per_container": 15.7, "cpu_utilization_of_limit": 0.241, "mem_max_mib": 55.3}, "postgres_connections": {"active_max": 18, "active_mean": 15.8, "total_max": 73}}, "pool": {"acquires": 28141, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "cache_version", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"18f4659cfb1f": 2056, "445b1fc8eebe": 2052, "65033444049d": 2052, "e05fce47f6df": 2054}, "label": "D_improvement/cache_version", "latency_ms": {"max": 630.796, "p50": 94.966, "p95": 264.475, "p99": 351.213}, "mode": "closed", "ok": 8214, "ok_read_rps": 272.06666666666666, "ok_rps": 547.6, "ok_write_rps": 275.53333333333336, "rate": 0, "read_ms": {"max": 224.025, "p50": 48.243, "p95": 108.95, "p99": 149.107}, "requests": 8214, "timestamp": "2026-10-23T14:37:56Z", "warmup_s": 3, "write_ms": {"max": 630.796, "p50": 173.409, "p95": 304.748, "p99": 405.099}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.3, "cpu_pct_max_per_container": 21.9, "cpu_utilization_of_limit": 0.387, "mem_max_mib": 31.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.6, "cpu_pct_max_per_container": 9.6, "cpu_utilization_of_limit": 0.191, "mem_max_mib": 12.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 57.5, "cpu_pct_max_per_container": 58.3, "cpu_utilization_of_limit": 0.575, "mem_max_mib": 245.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 11.8, "cpu_pct_max_per_container": 14.4, "cpu_utilization_of_limit": 0.235, "mem_max_mib": 49.3}, "postgres_connections": {"active_max": 43, "active_mean": 25, "total_max": 80}}, "pool": {"acquires": 28544, "empty_acquire_ratio": 0.0244, "avg_acquire_wait_ms": 0.111, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "cache_version", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"18f4659cfb1f": 2154, "445b1fc8eebe": 2149, "65033444049d": 2153, "e05fce47f6df": 2149}, "label": "D_improvement/cache_version", "latency_ms": {"max": 574.628, "p50": 91.166, "p95": 248.804, "p99": 318.312}, "mode": "closed", "ok": 8605, "ok_read_rps": 291.93333333333334, "ok_rps": 573.6666666666666, "ok_write_rps": 281.73333333333335, "rate": 0, "read_ms": {"max": 232.714, "p50": 49.582, "p95": 109.933, "p99": 150.37}, "requests": 8605, "timestamp": "2026-10-23T14:38:19Z", "warmup_s": 3, "write_ms": {"max": 574.628, "p50": 170.938, "p95": 276.767, "p99": 341.407}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 21.9, "cpu_utilization_of_limit": 0.393, "mem_max_mib": 54.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.6, "cpu_pct_max_per_container": 9.8, "cpu_utilization_of_limit": 0.192, "mem_max_mib": 12.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 56.6, "cpu_pct_max_per_container": 57.3, "cpu_utilization_of_limit": 0.566, "mem_max_mib": 246.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 10.5, "cpu_pct_max_per_container": 10.9, "cpu_utilization_of_limit": 0.209, "mem_max_mib": 49.9}, "postgres_connections": {"active_max": 53, "active_mean": 36.7, "total_max": 80}}, "pool": {"acquires": 29723, "empty_acquire_ratio": 0.0238, "avg_acquire_wait_ms": 0.115, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "cache_version", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"18f4659cfb1f": 2054, "445b1fc8eebe": 2054, "65033444049d": 2062, "e05fce47f6df": 2067}, "label": "D_improvement/cache_version", "latency_ms": {"max": 697.508, "p50": 90.901, "p95": 278.274, "p99": 389.059}, "mode": "closed", "ok": 8237, "ok_read_rps": 273.8, "ok_rps": 549.1333333333333, "ok_write_rps": 275.3333333333333, "rate": 0, "read_ms": {"max": 223.762, "p50": 49.092, "p95": 105.505, "p99": 139.635}, "requests": 8237, "timestamp": "2026-10-23T14:38:41Z", "warmup_s": 3, "write_ms": {"max": 697.508, "p50": 174.888, "p95": 324.789, "p99": 444.588}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.2, "cpu_pct_max_per_container": 21.8, "cpu_utilization_of_limit": 0.384, "mem_max_mib": 65.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.8, "cpu_pct_max_per_container": 10.4, "cpu_utilization_of_limit": 0.196, "mem_max_mib": 12.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 59.4, "cpu_pct_max_per_container": 61.2, "cpu_utilization_of_limit": 0.594, "mem_max_mib": 247.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 16.8, "cpu_pct_max_per_container": 28.6, "cpu_utilization_of_limit": 0.337, "mem_max_mib": 47.2}, "postgres_connections": {"active_max": 42, "active_mean": 33.7, "total_max": 80}}, "pool": {"acquires": 28637, "empty_acquire_ratio": 0.0169, "avg_acquire_wait_ms": 0.044, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "pool_8", "concurrency": 32, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "8", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"254d652c0891": 703, "375fdcd49b24": 698, "99c68cf78d0e": 706, "c9f6a260771a": 702}, "label": "D_improvement/pool_8", "latency_ms": {"max": 528.775, "p50": 222.504, "p95": 384.721, "p99": 448.136}, "mode": "closed", "ok": 2809, "ok_read_rps": 92.2, "ok_rps": 187.26666666666668, "ok_write_rps": 95.06666666666666, "rate": 0, "read_ms": {"max": 74.655, "p50": 17.375, "p95": 40.726, "p99": 55.806}, "requests": 2809, "timestamp": "2026-10-23T14:39:17Z", "warmup_s": 3, "write_ms": {"max": 528.775, "p50": 310.382, "p95": 415.503, "p99": 481.766}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.3, "cpu_pct_max_per_container": 20.4, "cpu_utilization_of_limit": 0.346, "mem_max_mib": 137.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.0, "cpu_pct_max_per_container": 4.4, "cpu_utilization_of_limit": 0.08, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 16.3, "cpu_pct_max_per_container": 18.4, "cpu_utilization_of_limit": 0.163, "mem_max_mib": 129.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.005, "mem_max_mib": 38.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 32}}, "pool": {"acquires": 9711, "empty_acquire_ratio": 0.008, "avg_acquire_wait_ms": 0.766, "pool_max_conns_total": 32}} +{"series": "D_improvement", "config": "pool_8", "concurrency": 32, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "8", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"254d652c0891": 781, "375fdcd49b24": 779, "99c68cf78d0e": 779, "c9f6a260771a": 784}, "label": "D_improvement/pool_8", "latency_ms": {"max": 449.753, "p50": 196.995, "p95": 346.583, "p99": 407.86}, "mode": "closed", "ok": 3123, "ok_read_rps": 103.46666666666667, "ok_rps": 208.2, "ok_write_rps": 104.73333333333333, "rate": 0, "read_ms": {"max": 68.827, "p50": 17.481, "p95": 36.752, "p99": 50.337}, "requests": 3123, "timestamp": "2026-10-23T14:39:38Z", "warmup_s": 3, "write_ms": {"max": 449.753, "p50": 280.93, "p95": 376.599, "p99": 414.061}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.6, "cpu_pct_max_per_container": 22.1, "cpu_utilization_of_limit": 0.373, "mem_max_mib": 195.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.3, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.085, "mem_max_mib": 12.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.4, "cpu_pct_max_per_container": 22.1, "cpu_utilization_of_limit": 0.184, "mem_max_mib": 139.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.6, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 1.012, "mem_max_mib": 24.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 33}}, "pool": {"acquires": 10881, "empty_acquire_ratio": 0.0008, "avg_acquire_wait_ms": 0.006, "pool_max_conns_total": 32}} +{"series": "D_improvement", "config": "pool_8", "concurrency": 32, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "8", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"254d652c0891": 853, "375fdcd49b24": 852, "99c68cf78d0e": 853, "c9f6a260771a": 855}, "label": "D_improvement/pool_8", "latency_ms": {"max": 397.383, "p50": 190.081, "p95": 313.681, "p99": 354.943}, "mode": "closed", "ok": 3413, "ok_read_rps": 109.73333333333333, "ok_rps": 227.53333333333333, "ok_write_rps": 117.8, "rate": 0, "read_ms": {"max": 72.886, "p50": 15.755, "p95": 33.166, "p99": 45.413}, "requests": 3413, "timestamp": "2026-10-23T14:39:59Z", "warmup_s": 3, "write_ms": {"max": 397.383, "p50": 251.22, "p95": 330.646, "p99": 362.483}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.0, "cpu_pct_max_per_container": 23.2, "cpu_utilization_of_limit": 0.399, "mem_max_mib": 204.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.3, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.087, "mem_max_mib": 12.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.0, "cpu_pct_max_per_container": 21.1, "cpu_utilization_of_limit": 0.18, "mem_max_mib": 137.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.7, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.994, "mem_max_mib": 16.0}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 32}}, "pool": {"acquires": 11912, "empty_acquire_ratio": 0.0013, "avg_acquire_wait_ms": 0.005, "pool_max_conns_total": 32}} +{"series": "D_improvement", "config": "pool_8", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "8", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"254d652c0891": 855, "375fdcd49b24": 860, "99c68cf78d0e": 865, "c9f6a260771a": 856}, "label": "D_improvement/pool_8", "latency_ms": {"max": 794.803, "p50": 409.97, "p95": 617.678, "p99": 699.87}, "mode": "closed", "ok": 3436, "ok_read_rps": 112.6, "ok_rps": 229.06666666666666, "ok_write_rps": 116.46666666666667, "rate": 0, "read_ms": {"max": 101.742, "p50": 29.152, "p95": 51.265, "p99": 70.683}, "requests": 3436, "timestamp": "2026-10-23T14:40:21Z", "warmup_s": 3, "write_ms": {"max": 794.803, "p50": 510.791, "p95": 663.626, "p99": 718.042}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.8, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.395, "mem_max_mib": 209.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.095, "mem_max_mib": 12.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.9, "cpu_pct_max_per_container": 22.9, "cpu_utilization_of_limit": 0.199, "mem_max_mib": 139.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.2, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 0.984, "mem_max_mib": 21.3}, "postgres_connections": {"active_max": 2, "active_mean": 0.3, "total_max": 32}}, "pool": {"acquires": 11851, "empty_acquire_ratio": 0.0162, "avg_acquire_wait_ms": 0.171, "pool_max_conns_total": 32}} +{"series": "D_improvement", "config": "pool_8", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "8", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"254d652c0891": 874, "375fdcd49b24": 875, "99c68cf78d0e": 874, "c9f6a260771a": 883}, "label": "D_improvement/pool_8", "latency_ms": {"max": 767.738, "p50": 387.346, "p95": 598.39, "p99": 690.442}, "mode": "closed", "ok": 3506, "ok_read_rps": 116.4, "ok_rps": 233.73333333333332, "ok_write_rps": 117.33333333333333, "rate": 0, "read_ms": {"max": 118.424, "p50": 28.223, "p95": 56.801, "p99": 75.236}, "requests": 3506, "timestamp": "2026-10-23T14:40:43Z", "warmup_s": 3, "write_ms": {"max": 767.738, "p50": 492.3, "p95": 640.598, "p99": 715.268}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.9, "cpu_pct_max_per_container": 22.7, "cpu_utilization_of_limit": 0.398, "mem_max_mib": 216.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.095, "mem_max_mib": 12.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.2, "cpu_pct_max_per_container": 23.5, "cpu_utilization_of_limit": 0.202, "mem_max_mib": 140.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.0, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 0.98, "mem_max_mib": 15.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 32}}, "pool": {"acquires": 12380, "empty_acquire_ratio": 0.0205, "avg_acquire_wait_ms": 0.518, "pool_max_conns_total": 32}} +{"series": "D_improvement", "config": "pool_8", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "8", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"254d652c0891": 887, "375fdcd49b24": 895, "99c68cf78d0e": 890, "c9f6a260771a": 888}, "label": "D_improvement/pool_8", "latency_ms": {"max": 784.371, "p50": 57.348, "p95": 637.73, "p99": 718.639}, "mode": "closed", "ok": 3560, "ok_read_rps": 124, "ok_rps": 237.33333333333334, "ok_write_rps": 113.33333333333333, "rate": 0, "read_ms": {"max": 105.715, "p50": 28.98, "p95": 55.955, "p99": 79.897}, "requests": 3560, "timestamp": "2026-10-23T14:41:06Z", "warmup_s": 3, "write_ms": {"max": 784.371, "p50": 515.255, "p95": 682.78, "p99": 738.544}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.3, "cpu_pct_max_per_container": 21.5, "cpu_utilization_of_limit": 0.386, "mem_max_mib": 213.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.9, "cpu_utilization_of_limit": 0.098, "mem_max_mib": 12.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 23.6, "cpu_utilization_of_limit": 0.196, "mem_max_mib": 142.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 0.992, "mem_max_mib": 15.1}, "postgres_connections": {"active_max": 2, "active_mean": 0.5, "total_max": 32}}, "pool": {"acquires": 12596, "empty_acquire_ratio": 0.0103, "avg_acquire_wait_ms": 0.06, "pool_max_conns_total": 32}} +{"series": "D_improvement", "config": "leastconn", "concurrency": 32, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"6da49288d253": 917, "7ac067adaf65": 817, "d3722c53e810": 862, "ded1e0e9c432": 878}, "label": "D_improvement/leastconn", "latency_ms": {"max": 526.067, "p50": 189.501, "p95": 316.911, "p99": 388.237}, "mode": "closed", "ok": 3474, "ok_read_rps": 114.66666666666667, "ok_rps": 231.6, "ok_write_rps": 116.93333333333334, "rate": 0, "read_ms": {"max": 201.366, "p50": 15.779, "p95": 34.595, "p99": 48.889}, "requests": 3474, "timestamp": "2026-10-23T14:41:39Z", "warmup_s": 3, "write_ms": {"max": 526.067, "p50": 244.791, "p95": 347.53, "p99": 419.131}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 23.9, "cpu_utilization_of_limit": 0.393, "mem_max_mib": 144.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.5, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.091, "mem_max_mib": 8.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.5, "cpu_pct_max_per_container": 25.4, "cpu_utilization_of_limit": 0.195, "mem_max_mib": 141.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.9, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 0.998, "mem_max_mib": 14.7}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 33}}, "pool": {"acquires": 11891, "empty_acquire_ratio": 0.002, "avg_acquire_wait_ms": 0.558, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "leastconn", "concurrency": 32, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"6da49288d253": 895, "7ac067adaf65": 868, "d3722c53e810": 896, "ded1e0e9c432": 832}, "label": "D_improvement/leastconn", "latency_ms": {"max": 523.489, "p50": 46.445, "p95": 327.957, "p99": 412.418}, "mode": "closed", "ok": 3491, "ok_read_rps": 117.73333333333333, "ok_rps": 232.73333333333332, "ok_write_rps": 115, "rate": 0, "read_ms": {"max": 156.234, "p50": 16.589, "p95": 35.502, "p99": 47.571}, "requests": 3491, "timestamp": "2026-10-23T14:42:01Z", "warmup_s": 3, "write_ms": {"max": 523.489, "p50": 244.15, "p95": 368.726, "p99": 432.816}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.3, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.406, "mem_max_mib": 211.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.5, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.091, "mem_max_mib": 9.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.1, "cpu_pct_max_per_container": 23.0, "cpu_utilization_of_limit": 0.191, "mem_max_mib": 146.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.7, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 0.994, "mem_max_mib": 14.4}, "postgres_connections": {"active_max": 1, "active_mean": 0.6, "total_max": 33}}, "pool": {"acquires": 12119, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "leastconn", "concurrency": 32, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"6da49288d253": 858, "7ac067adaf65": 839, "d3722c53e810": 797, "ded1e0e9c432": 840}, "label": "D_improvement/leastconn", "latency_ms": {"max": 526.461, "p50": 190.628, "p95": 321.386, "p99": 412.187}, "mode": "closed", "ok": 3334, "ok_read_rps": 109.73333333333333, "ok_rps": 222.26666666666668, "ok_write_rps": 112.53333333333333, "rate": 0, "read_ms": {"max": 77.124, "p50": 16.746, "p95": 35.654, "p99": 50.13}, "requests": 3334, "timestamp": "2026-10-23T14:42:22Z", "warmup_s": 3, "write_ms": {"max": 526.461, "p50": 254.888, "p95": 354.179, "p99": 440.618}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 22.2, "cpu_utilization_of_limit": 0.393, "mem_max_mib": 209.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.4, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.088, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.9, "cpu_pct_max_per_container": 22.9, "cpu_utilization_of_limit": 0.189, "mem_max_mib": 148.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.4, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 0.989, "mem_max_mib": 14.5}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 33}}, "pool": {"acquires": 11942, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "leastconn", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"6da49288d253": 869, "7ac067adaf65": 824, "d3722c53e810": 826, "ded1e0e9c432": 833}, "label": "D_improvement/leastconn", "latency_ms": {"max": 799.42, "p50": 418.691, "p95": 616.116, "p99": 745.163}, "mode": "closed", "ok": 3352, "ok_read_rps": 108.86666666666666, "ok_rps": 223.46666666666667, "ok_write_rps": 114.6, "rate": 0, "read_ms": {"max": 95.196, "p50": 29.791, "p95": 52.519, "p99": 67.112}, "requests": 3352, "timestamp": "2026-10-23T14:42:44Z", "warmup_s": 3, "write_ms": {"max": 799.42, "p50": 513.092, "p95": 648.06, "p99": 767.753}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.2, "cpu_pct_max_per_container": 21.0, "cpu_utilization_of_limit": 0.383, "mem_max_mib": 210.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.4, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.088, "mem_max_mib": 9.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 23.4, "cpu_utilization_of_limit": 0.196, "mem_max_mib": 222.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.9, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 0.999, "mem_max_mib": 15.2}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 65}}, "pool": {"acquires": 11718, "empty_acquire_ratio": 0.0027, "avg_acquire_wait_ms": 1.677, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "leastconn", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"6da49288d253": 815, "7ac067adaf65": 797, "d3722c53e810": 750, "ded1e0e9c432": 815}, "label": "D_improvement/leastconn", "latency_ms": {"max": 953.834, "p50": 428.862, "p95": 671.277, "p99": 863.492}, "mode": "closed", "ok": 3177, "ok_read_rps": 104.33333333333333, "ok_rps": 211.8, "ok_write_rps": 107.46666666666667, "rate": 0, "read_ms": {"max": 101.445, "p50": 32.01, "p95": 60.8, "p99": 82.726}, "requests": 3177, "timestamp": "2026-10-23T14:43:06Z", "warmup_s": 3, "write_ms": {"max": 953.834, "p50": 541.934, "p95": 731.866, "p99": 887.26}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.8, "cpu_pct_max_per_container": 21.5, "cpu_utilization_of_limit": 0.375, "mem_max_mib": 65.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.4, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.089, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.2, "cpu_pct_max_per_container": 22.2, "cpu_utilization_of_limit": 0.192, "mem_max_mib": 226.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.7, "cpu_pct_max_per_container": 50.3, "cpu_utilization_of_limit": 0.993, "mem_max_mib": 21.8}, "postgres_connections": {"active_max": 2, "active_mean": 0.4, "total_max": 65}}, "pool": {"acquires": 11171, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "leastconn", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"6da49288d253": 930, "7ac067adaf65": 942, "d3722c53e810": 939, "ded1e0e9c432": 986}, "label": "D_improvement/leastconn", "latency_ms": {"max": 727.596, "p50": 376.223, "p95": 573.296, "p99": 642.229}, "mode": "closed", "ok": 3797, "ok_read_rps": 125.4, "ok_rps": 253.13333333333333, "ok_write_rps": 127.73333333333333, "rate": 0, "read_ms": {"max": 95.122, "p50": 26.395, "p95": 48.755, "p99": 66.78}, "requests": 3797, "timestamp": "2026-10-23T14:43:27Z", "warmup_s": 3, "write_ms": {"max": 727.596, "p50": 454.803, "p95": 604.676, "p99": 665.068}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.7, "cpu_pct_max_per_container": 22.9, "cpu_utilization_of_limit": 0.415, "mem_max_mib": 59.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.095, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.1, "cpu_pct_max_per_container": 24.6, "cpu_utilization_of_limit": 0.211, "mem_max_mib": 231.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.7, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 0.995, "mem_max_mib": 21.2}, "postgres_connections": {"active_max": 2, "active_mean": 0.8, "total_max": 66}}, "pool": {"acquires": 13027, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.022, "pool_max_conns_total": 80}} diff --git a/evidence/track1/runner_A_fixed_total.txt b/evidence/track1/runner_A_fixed_total.txt new file mode 100644 index 00000000..b2b33ea9 --- /dev/null +++ b/evidence/track1/runner_A_fixed_total.txt @@ -0,0 +1,6 @@ +2 + total used free shared buff/cache available +Mem: 7942 1432 2076 102 4850 6509 +Swap: 3071 26 3045 +CPU(s): 2 +Model name: AMD EPYC 7763 64-Core Processor diff --git a/evidence/track1/runner_B_scale_out.txt b/evidence/track1/runner_B_scale_out.txt new file mode 100644 index 00000000..59d618d7 --- /dev/null +++ b/evidence/track1/runner_B_scale_out.txt @@ -0,0 +1,6 @@ +2 + total used free shared buff/cache available +Mem: 7938 1543 1893 116 4932 6394 +Swap: 3071 18 3053 +CPU(s): 2 +Model name: AMD EPYC 9V74 80-Core Processor diff --git a/evidence/track1/runner_D_improvement.txt b/evidence/track1/runner_D_improvement.txt new file mode 100644 index 00000000..8322ab8e --- /dev/null +++ b/evidence/track1/runner_D_improvement.txt @@ -0,0 +1,6 @@ +2 + total used free shared buff/cache available +Mem: 7938 1552 1943 108 4866 6386 +Swap: 3071 6 3065 +CPU(s): 2 +Model name: AMD EPYC 9V74 80-Core Processor diff --git a/experiments/track1.json b/experiments/track1.json index 7ac811db..fc78565a 100644 --- a/experiments/track1.json +++ b/experiments/track1.json @@ -15,7 +15,14 @@ }, "redis_padding_keys": 10000, "load": { - "levels": [1, 4, 8, 16, 32, 64], + "levels": [ + 1, + 4, + 8, + 16, + 32, + 64 + ], "duration": "30s", "warmup": "5s", "write_ratio": 0.5, @@ -28,9 +35,24 @@ "title": "Фиксированный суммарный бюджет API: 1.0 CPU / 768M", "hypothesis": "При фиксированном суммарном CPU рост числа реплик не увеличивает пиковый RPS (тот же бюджет) и немного ухудшает p95 из-за накладных расходов на процесс и пул соединений; выигрыш реплик — только отказоустойчивость.", "configs": [ - {"label": "1x1.00", "API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M"}, - {"label": "2x0.50", "API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M"}, - {"label": "4x0.25", "API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M"} + { + "label": "1x1.00", + "API_REPLICAS": "1", + "API_CPUS": "1.00", + "API_MEMORY": "768M" + }, + { + "label": "2x0.50", + "API_REPLICAS": "2", + "API_CPUS": "0.50", + "API_MEMORY": "384M" + }, + { + "label": "4x0.25", + "API_REPLICAS": "4", + "API_CPUS": "0.25", + "API_MEMORY": "192M" + } ] }, { @@ -38,10 +60,30 @@ "title": "Рост ресурсов: реплики по 0.5 CPU, БД 1.0 CPU, LB 0.5 CPU", "hypothesis": "Пиковый RPS растёт почти линейно, пока узкое место — CPU API; затем рост останавливается на общей зависимости (PostgreSQL, Redis или LB), чья утилизация CPU приближается к лимиту.", "configs": [ - {"label": "1x0.50", "API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M"}, - {"label": "2x0.50", "API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M"}, - {"label": "4x0.50", "API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M"}, - {"label": "8x0.50", "API_REPLICAS": "8", "API_CPUS": "0.50", "API_MEMORY": "256M"} + { + "label": "1x0.50", + "API_REPLICAS": "1", + "API_CPUS": "0.50", + "API_MEMORY": "256M" + }, + { + "label": "2x0.50", + "API_REPLICAS": "2", + "API_CPUS": "0.50", + "API_MEMORY": "256M" + }, + { + "label": "4x0.50", + "API_REPLICAS": "4", + "API_CPUS": "0.50", + "API_MEMORY": "256M" + }, + { + "label": "8x0.50", + "API_REPLICAS": "8", + "API_CPUS": "0.50", + "API_MEMORY": "256M" + } ] }, { @@ -49,23 +91,93 @@ "title": "4×0.5 CPU API, меняем ресурсы общих зависимостей", "hypothesis": "Если насыщение B вызвано общей зависимостью, увеличение её CPU поднимает пиковый RPS, а увеличение CPU других зависимостей — нет.", "configs": [ - {"label": "pg1_lb0.5_redis0.5", "API_REPLICAS": "4", "API_CPUS": "0.50"}, - {"label": "pg2", "API_REPLICAS": "4", "API_CPUS": "0.50", "PG_CPUS": "2.00"}, - {"label": "lb1", "API_REPLICAS": "4", "API_CPUS": "0.50", "LB_CPUS": "1.00"}, - {"label": "redis1", "API_REPLICAS": "4", "API_CPUS": "0.50", "REDIS_CPUS": "1.00"} + { + "label": "pg1_lb0.5_redis0.5", + "API_REPLICAS": "4", + "API_CPUS": "0.50" + }, + { + "label": "pg2", + "API_REPLICAS": "4", + "API_CPUS": "0.50", + "PG_CPUS": "2.00" + }, + { + "label": "lb1", + "API_REPLICAS": "4", + "API_CPUS": "0.50", + "LB_CPUS": "1.00" + }, + { + "label": "redis1", + "API_REPLICAS": "4", + "API_CPUS": "0.50", + "REDIS_CPUS": "1.00" + } ] }, { "name": "D_improvement", "title": "Кандидаты улучшения на 4×0.5 CPU", "hypothesis": "Инвалидация кэша истории через SCAN (lab2) делает O(keyspace/100) запросов к Redis на каждую запись; ключ с версией чата (CACHE_INVALIDATION=version) делает 1 INCR и поднимает RPS записи при большом keyspace. Альтернативы: меньший пул на реплику, leastconn.", - "levels": [16, 32, 64], + "levels": [ + 16, + 32, + 64 + ], "repeats": 5, "configs": [ - {"label": "baseline_scan", "API_REPLICAS": "4", "API_CPUS": "0.50"}, - {"label": "cache_version", "API_REPLICAS": "4", "API_CPUS": "0.50", "CACHE_INVALIDATION": "version"}, - {"label": "pool_8", "API_REPLICAS": "4", "API_CPUS": "0.50", "DB_POOL_MAX": "8"}, - {"label": "leastconn", "API_REPLICAS": "4", "API_CPUS": "0.50", "LB_BALANCE": "leastconn"} + { + "label": "baseline_scan", + "API_REPLICAS": "4", + "API_CPUS": "0.50" + }, + { + "label": "cache_version", + "API_REPLICAS": "4", + "API_CPUS": "0.50", + "CACHE_INVALIDATION": "version" + }, + { + "label": "pool_8", + "API_REPLICAS": "4", + "API_CPUS": "0.50", + "DB_POOL_MAX": "8" + }, + { + "label": "leastconn", + "API_REPLICAS": "4", + "API_CPUS": "0.50", + "LB_BALANCE": "leastconn" + } + ] + }, + { + "name": "E_scale_out_after_fix", + "title": "Рост реплик после улучшения (CACHE_INVALIDATION=version), реплики по 0.5 CPU", + "hypothesis": "После снятия упора в Redis рост реплик снова увеличивает RPS, пока не насытится следующая общая зависимость (ожидаем PostgreSQL) или CPU хоста.", + "configs": [ + { + "label": "1x0.50", + "API_REPLICAS": "1", + "API_CPUS": "0.50", + "API_MEMORY": "256M", + "CACHE_INVALIDATION": "version" + }, + { + "label": "2x0.50", + "API_REPLICAS": "2", + "API_CPUS": "0.50", + "API_MEMORY": "256M", + "CACHE_INVALIDATION": "version" + }, + { + "label": "4x0.50", + "API_REPLICAS": "4", + "API_CPUS": "0.50", + "API_MEMORY": "256M", + "CACHE_INVALIDATION": "version" + } ] } ] diff --git a/scripts/collect-evidence.sh b/scripts/collect-evidence.sh index 134fd640..76008673 100755 --- a/scripts/collect-evidence.sh +++ b/scripts/collect-evidence.sh @@ -33,7 +33,7 @@ step "smoke" $PY tests/smoke.py --base-url "$BASE" | tee evidence/smoke.txt step "конкурентная идемпотентность" -$PY tests/idempotency_concurrent.py --base-url "$BASE" --output evidence/idempotency_concurrent.json | tail -1 +$PY student-tests/idempotency_concurrent.py --base-url "$BASE" --output evidence/idempotency_concurrent.json | tail -1 step "публичный failover (2 прогона, между ними restore)" for n in 1 2; do @@ -51,13 +51,18 @@ step "persistence (restart всего стенда с volumes)" cat evidence/persistence.txt step "серия отказов каждой реплики под нагрузкой (уровень 4)" -$PY tests/failover_series.py --base-url "$BASE" --output evidence/failover_series.json | tail -1 +$PY student-tests/failover_series.py --base-url "$BASE" --output evidence/failover_series.json | tail -1 step "rolling update под нагрузкой (уровень 4)" -$PY tests/load.py --base-url "$BASE" --duration 60 --concurrency 4 --output evidence/rolling_update_load.json > /dev/null & +# Образ собираем ДО нагрузки, чтобы в окно нагрузки попала именно замена реплик. +docker compose build -q api +{ echo "-- до:"; docker compose ps api --format '{{.Name}} {{.ID}} {{.Status}}'; } > evidence/rolling_update.txt +$PY tests/load.py --base-url "$BASE" --duration 90 --concurrency 4 --output evidence/rolling_update_load.json > /dev/null & LOAD=$! sleep 5 -sh scripts/rolling-update.sh > evidence/rolling_update.txt 2>&1 +start=$(date +%s) +sh scripts/rolling-update.sh >> evidence/rolling_update.txt 2>&1 +echo "-- замена заняла $(( $(date +%s) - start )) s (внутри 90 s нагрузки)" >> evidence/rolling_update.txt wait $LOAD cat evidence/rolling_update.txt evidence/rolling_update_load.json diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh index a9351897..08ada322 100755 --- a/scripts/rolling-update.sh +++ b/scripts/rolling-update.sh @@ -13,8 +13,10 @@ wait_healthy() { want=$1; deadline=$(( $(date +%s) + 90 )) while :; do n=0 - for cid in $(docker compose ps -q api); do - [ "$(docker inspect -f '{{.State.Health.Status}}' "$cid")" = healthy ] && n=$((n+1)) + # Своё имя переменной: в sh у функций общая область видимости, и `cid` + # перезаписал бы переменную внешнего цикла (тогда удалялась бы новая реплика). + for c in $(docker compose ps -q api); do + [ "$(docker inspect -f '{{.State.Health.Status}}' "$c")" = healthy ] && n=$((n+1)) done [ $n -ge "$want" ] && return 0 [ "$(date +%s)" -lt $deadline ] || { echo "new replica not healthy in 90s" >&2; return 1; } @@ -32,4 +34,4 @@ for cid in $old; do docker rm "$cid" >/dev/null echo "replaced $name" done -docker compose ps api --format '{{.Name}} {{.Image}} {{.Status}}' +docker compose ps api --format '{{.Name}} {{.ID}} {{.Image}} {{.Status}}' diff --git a/tests/failover_series.py b/student-tests/failover_series.py similarity index 98% rename from tests/failover_series.py rename to student-tests/failover_series.py index dcb4752e..6d68d601 100644 --- a/tests/failover_series.py +++ b/student-tests/failover_series.py @@ -18,6 +18,9 @@ import subprocess import threading import time import uuid +import sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) # публичный client.py from client import Client, Failure, arguments, check, run from resilience import history diff --git a/tests/idempotency_concurrent.py b/student-tests/idempotency_concurrent.py similarity index 97% rename from tests/idempotency_concurrent.py rename to student-tests/idempotency_concurrent.py index 90d71d2c..9d3dea8b 100644 --- a/tests/idempotency_concurrent.py +++ b/student-tests/idempotency_concurrent.py @@ -10,6 +10,9 @@ from concurrent.futures import ThreadPoolExecutor import json import threading import uuid +import sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) # публичный client.py from client import Client, Failure, arguments, check, run from resilience import history diff --git a/tests/negative.py b/student-tests/negative.py similarity index 100% rename from tests/negative.py rename to student-tests/negative.py -- 2.54.0 From 7366f430caa29e80f96bf8da280663182f34c37f Mon Sep 17 00:00:00 2001 From: CharaWein Date: Fri, 23 Oct 2026 18:06:45 +0300 Subject: [PATCH 4/8] =?UTF-8?q?lab3:=20=D1=80=D0=B5=D0=B7=D1=83=D0=BB?= =?UTF-8?q?=D1=8C=D1=82=D0=B0=D1=82=D1=8B=20Docker-=D1=81=D1=82=D0=B5?= =?UTF-8?q?=D0=BD=D0=B4=D0=B0=20=D0=B8=20=D1=82=D1=80=D0=B5=D0=BA=D0=B0=20?= =?UTF-8?q?1,=20=D0=BE=D1=82=D1=87=D1=91=D1=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - доказательства уровней 3–4 (прогон 2 на GitHub runner) - трек 1: 129 прогонов серий A–E, анализ, графики, подтверждённое улучшение - Dockerfile: базовые образы закреплены по digest - собственные тесты перенесены в student-tests/ Co-Authored-By: Claude Opus 5.5 --- Dockerfile | 4 +- REPORT.md | 184 +++++++++++------- evidence/docker_ps.txt | 8 + evidence/docker_ps_final.txt | 7 + evidence/docker_stats.txt | 5 + evidence/failover_1.txt | 8 + evidence/failover_2.txt | 8 + evidence/failover_series.json | 64 ++++++ evidence/idempotency_concurrent.json | 88 +++++++++ evidence/instances.txt | 2 + evidence/load_baseline.json | 17 ++ evidence/persistence.txt | 14 ++ evidence/rolling_update.txt | 89 +++++++++ evidence/rolling_update_load.json | 17 ++ evidence/runner.txt | 6 + evidence/smoke.txt | 1 + evidence/track1/RUNS.txt | 1 + evidence/track1/raw.jsonl | 51 +++++ evidence/track1/report.html | 33 ++++ evidence/track1/runner_C_shared_resources.txt | 7 + .../track1/runner_E_scale_out_after_fix.txt | 6 + evidence/track1/summary.csv | 44 +++++ evidence/track1/summary.md | 64 ++++++ scripts/track1_report.py | 46 ++++- 24 files changed, 699 insertions(+), 75 deletions(-) create mode 100644 evidence/docker_ps.txt create mode 100644 evidence/docker_ps_final.txt create mode 100644 evidence/docker_stats.txt create mode 100644 evidence/failover_1.txt create mode 100644 evidence/failover_2.txt create mode 100644 evidence/failover_series.json create mode 100644 evidence/idempotency_concurrent.json create mode 100644 evidence/instances.txt create mode 100644 evidence/load_baseline.json create mode 100644 evidence/persistence.txt create mode 100644 evidence/rolling_update.txt create mode 100644 evidence/rolling_update_load.json create mode 100644 evidence/runner.txt create mode 100644 evidence/smoke.txt create mode 100644 evidence/track1/report.html create mode 100644 evidence/track1/runner_C_shared_resources.txt create mode 100644 evidence/track1/runner_E_scale_out_after_fix.txt create mode 100644 evidence/track1/summary.csv create mode 100644 evidence/track1/summary.md diff --git a/Dockerfile b/Dockerfile index 7bbb0a8c..0b741285 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,7 +1,7 @@ # ============================================================ # Stage 1: builder — компилируем статический бинарник # ============================================================ -FROM golang:1.26-alpine AS builder +FROM golang:1.26-alpine@sha256:27f2d3b83cfc5803c8078f8e730af0f7c431bf067afaec8f60a36fb763187cba AS builder WORKDIR /src @@ -25,7 +25,7 @@ RUN CGO_ENABLED=0 GOOS=linux go build \ # ============================================================ # Stage 2: runtime — минимальный образ только с бинарником # ============================================================ -FROM alpine:3.20 +FROM alpine:3.20@sha256:d9e853e87e55526f6b2917df91a2115c36dd7c696a35be12163d44e6e2a4b6bc # ca-certificates — для HTTPS в lab2+ # tzdata — для корректной работы с временными зонами diff --git a/REPORT.md b/REPORT.md index 1e90a576..8c10671b 100644 --- a/REPORT.md +++ b/REPORT.md @@ -2,21 +2,21 @@ - Автор, группа: Вейнмайер Андрей Андреевич, БВТ2303 - Целевая оценка: 5 (уровни 3, 4 и трек 1 «Цена масштабирования») -- Commit/PR: TODO после публикации +- Commit/PR: ветка `solution/bvt2303-weinmaier` в https://gitea.privcloud.tech/WeinmaierAndrew/mtusi2026lab3, PR в mtusi2026/mtusi2026lab3 - Основа: собственная lab2 — https://gitea.privcloud.tech/WeinmaierAndrew/mtusi2026lab2 - Использованные источники: - Контракт: contracts/openapi.json, contracts/README.md (раздел «Балансировка и повторная отправка») - Go: net/http (Server.Shutdown), log/slog, sync/atomic, crypto/sha256 - Библиотеки: github.com/jackc/pgx/v5, github.com/redis/go-redis/v9, golang.org/x/crypto/argon2 - Документация: HAProxy 3.0 (server-template, resolvers, http-check, retry-on), Docker Compose services/deploy, PostgreSQL INSERT … ON CONFLICT - - AI-ассистент использован для переноса кода lab2, реализации идемпотентности, конфигурации LB и скриптов; код проверен вручную и тестами. + - AI-ассистент (Claude) использован для переноса кода lab2, реализации идемпотентности, конфигурации LB, скриптов, генератора нагрузки и анализа. Все результаты ниже — реальные прогоны, ссылки на них приведены. ## Запуск из чистого clone ### Версии | Компонент | Образ / версия | | --- | --- | -| API builder / runtime | golang:1.26-alpine / alpine:3.20 (multi-stage, бинарник static, USER 1001) | +| API builder / runtime | golang:1.26-alpine / alpine:3.20, закреплены по digest в Dockerfile (multi-stage, static, USER 1001) | | LB | haproxy:3.0.5-alpine | | БД | postgres:16.4-alpine | | Сессии + кэш | redis:7.4.1-alpine (AOF, appendfsync everysec) | @@ -96,105 +96,157 @@ migrate (one-shot) ──► postgres — до старта api **Соответствие .env.example:** APP_HOST/APP_PORT/APP_ENV/SESSION_TTL_SECONDS/IDEMPOTENCY_TTL_SECONDS — как есть; DATABASE_URL_FILE и CACHE_URL_FILE — docker secrets `/run/secrets/*`; SESSION_STORE=redis (сессии в Redis с lab2); API_REPLICAS → `deploy.replicas`; DRAIN_DELAY/SHUTDOWN_TIMEOUT — добавлены. +## Где запускался стенд + +На машине разработки Docker Desktop не запускается: в BIOS выключена аппаратная виртуализация (`VirtualizationFirmwareEnabled=False`, backend `hasNoVirtualization=true`). Поэтому все Docker-проверки выполнены на **GitHub-hosted runner** workflow [.github/workflows/lab3-stand.yml](.github/workflows/lab3-stand.yml) — тот же compose.yaml и те же скрипты, что и в инструкции выше: + +| Прогон | Что | Ссылка | +| --- | --- | --- | +| 1 (commit fe4b4cf) | уровни 3–4 (найден баг rolling update), трек 1: серии A, B, D | https://github.com/CharaWein/2026_lab3/actions/runs/39970452644 | +| 2 (commit 0a37181) | уровни 3–4 после исправления — **доказательства ниже из этого прогона**; трек 1: серии C, E | https://github.com/CharaWein/2026_lab3/actions/runs/39972671424 | + +Runner: 2 vCPU (AMD EPYC 7763 / 9V74, Intel Xeon 6973P — модель разная для разных job, записана в `evidence/track1/runner_*.txt`), 8 GB RAM, Docker 28.0.4, Compose v2.38.2 (`evidence/runner.txt`). Каждая серия трека 1 выполнялась целиком на одном runner, поэтому сравнения **внутри** серии корректны, а абсолютные RPS **между** сериями сравнивать нельзя. + +До Docker-прогона логика приложения дополнительно проверялась нативно (PostgreSQL 17, fakeredis, 2 процесса API за временным прокси) — `evidence/local_native_check.txt`, `evidence/idempotency_concurrent_native.json`. + ## Доказательства критериев -### Что уже проверено - -Docker Desktop на машине разработки не запускает движок (`backend state: hasNoVirtualization=true` — выключена аппаратная виртуализация / нет WSL2), поэтому логика приложения проверена **нативно**: PostgreSQL 17 (initdb), fakeredis (TCP) вместо Redis, 2 процесса API с разными `INSTANCE_ID` за временным round-robin прокси (заменитель HAProxy только для этой проверки). Это доказывает корректность кода, но **не** инфраструктуры Compose/HAProxy. +### Уровень 3 | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл | | --- | --- | --- | --- | -| Публичный smoke | tests/smoke.py | PASS: lab3 public API scenario | evidence/local_native_check.txt | -| Негативные проверки lab2 | student-tests/negative.py | PASS | evidence/local_native_check.txt | -| Отказ реплики, ≥2 реплик до отказа | tests/resilience.py --mode failover | PASS, observed 2, 21 успешных записей, 7 ошибок переходного периода, первая запись после hook за 3.7 s, дублей нет | evidence/local_native_check.txt | -| Конкурентный повтор одного ключа через разные реплики | student-tests/idempotency_concurrent.py (10 раундов × 16 параллельно) | PASS: 160/160 → 201 с одинаковым Message, 1 сообщение на ключ, 2 реплики, 409 на другой body, ключ изолирован по чату/пользователю, посторонний — 404 | evidence/idempotency_concurrent_native.json | -| compose.yaml корректен | docker compose --env-file .env config --quiet | OK; 2 реплики, лимиты, опубликован только lb | — | +| Стенд в compose.yaml, одна последовательность запуска | `scripts/init-secrets.sh` → `docker compose up -d --build --wait` | lb, 2×api, postgres, redis healthy; migrate отработал однократно | evidence/docker_ps.txt | +| ≥2 реплики, одна точка входа, общая БД и сессии | `docker compose ps` | опубликованы только `127.0.0.1:8080` (lb) и `:8404` (stats); api — только `8080/tcp` внутри сети | evidence/docker_ps.txt | +| Запросы одной сессии обслуживают разные реплики | 20 запросов через LB; 40 запросов `/users/me` в failover-тесте | `259a4143c86a`×10, `904a0714df9b`×10; `observed_instances_before: 2` | evidence/instances.txt, evidence/failover_1.txt | +| Публичный smoke | `make test` | `PASS: lab3 public API scenario` | evidence/smoke.txt | +| Отказ одной реплики ≤10 s | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`, 2 прогона, между ними `restore.sh` | PASS ×2; 143 и 144 успешных записи, **0** ошибок, первая запись после hook за 3.39 s и 3.36 s; остановленный контейнер `Exited (0)` | evidence/failover_1.txt, failover_2.txt | +| Повтор POST с тем же ключом без дублей (конкурентно, через разные реплики) | `make test-idempotency`: 10 раундов × 16 параллельных запросов | 160/160 → 201 с одним Message, 1 сообщение на ключ, 2 реплики, `duplicates_found: 0`; другой body — 409; ключ изолирован по чату и пользователю | evidence/idempotency_concurrent.json | +| Persistence с прежним токеном | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS; перезапущены postgres, redis, api, lb (uptime до/после в файле), volumes сохранены | evidence/persistence.txt | -### На Docker-стенде (заполнить после `sh scripts/collect-evidence.sh`) +Публичный failover-тест останавливает реплику, обслужившую первый запрос; в обоих прогонах это была `api-2`. Остановка **каждой** реплики по очереди показана в серии уровня 4 ниже. + +### Уровень 4 | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл | | --- | --- | --- | --- | -| ≥2 X-Instance-Id через LB с одной сессией | collect-evidence: instances + make test-failover | TODO | evidence/instances.txt | -| Публичный smoke | make test | TODO | evidence/smoke.txt | -| Отказ любой одной реплики ≤10 s | make test-failover ×2 + restore | TODO | evidence/failover_1.txt, failover_2.txt | -| Persistence с прежним токеном | make test-persistence ACTION_SCRIPT=scripts/restart.sh | TODO | evidence/persistence.txt | -| Идемпотентность параллельно | make test-idempotency | TODO | evidence/idempotency_concurrent.json | -| 4: поочерёдный отказ каждой реплики, RPS/ошибки/восстановление | make test-failover-series | TODO | evidence/failover_series.json | -| 4: rolling update под нагрузкой | scripts/rolling-update.sh + tests/load.py | TODO | evidence/rolling_update*.{txt,json} | -| 4: лимиты, нет портов api, нет container_name | docker compose config, docker compose ps | TODO | evidence/docker_ps.txt | +| Health/readiness, timeouts, SIGTERM согласованы; LB исключает backend | drain 3 s + HAProxy check inter 1 s × fall 2; `docker stop` | после SIGTERM реплика отвечала ещё 0.75 s / 1.46 s, затем исчезла из ответов LB; **0 ошибок**. Период проверки 1 s, максимальное время обнаружения ≈2 s | evidence/failover_series.json | +| Поочерёдная остановка каждой реплики: RPS, ошибки, восстановление | `make test-failover-series` (4 потока, POST+GET) | таблица ниже | evidence/failover_series.json | +| Параллельная идемпотентность | см. уровень 3 | 0 дублей | evidence/idempotency_concurrent.json | +| CPU/RAM-лимиты, api без портов, нет container_name | compose.yaml, `docker stats` | api 0.5 CPU/256M, lb 0.5/128M, postgres 1.0/512M, redis 0.5/256M | evidence/docker_stats.txt, evidence/docker_ps.txt | +| Rolling update под нагрузкой | `scripts/rolling-update.sh` во время 90 s `tests/load.py` | api-1, api-2 → api-3, api-4 за 27 s; **33 461 запрос, 0 ошибок**, 371 RPS, p99 27.7 ms | evidence/rolling_update.txt, rolling_update_load.json | +| Миграции однократно и совместимы | сервис `migrate` + `docker compose run --rm migrate` перед заменой | `no change`; 0002 только добавляет таблицу (expand) | evidence/rolling_update.txt | ## Эксперименты и отказы -Методика (уровень 4), `student-tests/failover_series.py`: closed-loop нагрузка 4 потока через LB (POST сообщения с повтором того же ключа после неопределённого ответа + GET истории), прогрев 5 s; для каждой реплики по очереди `docker stop -t 15` → наблюдение 15 s → `docker start` → ожидание healthy и появления в ответах LB → 3 s паузы. Метрики: успешные RPS до/во время, число ошибок, время от начала остановки до последней ошибки, время, когда остановленная реплика последний раз ответила, время восстановления. В конце — полная история: нет дублей текста и ID, все подтверждённые сообщения на месте. - -Rolling update (`scripts/rolling-update.sh`): build → migrate → для каждой старой реплики `up --scale api=N+1 --no-recreate` → ждать healthy → `docker stop` старой (drain) → `rm`. Во время замены 60 s нагрузки `tests/load.py`. - | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| kill одного процесса API (нативно) | краткие ошибки, затем запись через вторую реплику | 7 ошибок, PASS | первая запись 3.7 s; потерь/дублей нет | -| docker stop реплики 1 под нагрузкой | 0–единицы ошибок благодаря drain | TODO | TODO | -| docker stop реплики 2 под нагрузкой | то же | TODO | TODO | -| rolling update | 0 ошибок | TODO | TODO | -| restart всего стенда | сессия и данные сохранены | TODO | TODO | +| `docker stop` реплики `259a4143c86a` под нагрузкой | 0–единицы ошибок благодаря drain | 347.8 RPS до → 361.9 RPS в окне 15 s, **0 ошибок**; stop занял 3.57 s | ошибок нет; после `docker start` healthy и в LB через 6.25 s; потерь нет | +| `docker stop` реплики `904a0714df9b` | то же | 345.8 → 357.9 RPS, **0 ошибок**; stop 4.12 s | ошибок нет; возврат через 6.81 s; потерь нет | +| Итог серии | нет потерь и дублей | 9 388 подтверждённых записей, 9 389 в истории (+1 — сообщение до серии), дублей 0, потерь 0 | — | +| Rolling update | 0 ошибок | 0 из 33 461 | замена 27 s | +| Restart всего стенда | данные и сессия сохранены | PASS с прежним токеном | ≈12 s до healthy | +| Прогон 1: rolling update | 0 ошибок | **найден баг**: `wait_healthy` перезаписывал `cid` внешнего цикла, удалялась новая реплика; сборка (72 s) не попадала в окно нагрузки | исправлено в 0a37181, проверено прогоном 2 | ## Трек 5.1: цена масштабирования ### Вопрос и гипотезы -Помогает ли добавление API-реплик, где точка насыщения стенда и почему рост реплик перестаёт помогать? Гипотезы записаны **до** измерений в [experiments/track1.json](experiments/track1.json): +Помогает ли добавление API-реплик, где точка насыщения и почему рост реплик перестаёт помогать? Гипотезы A–D записаны **до** измерений в [experiments/track1.json](experiments/track1.json). Серия E и её гипотеза добавлены **после** прогона 1, чтобы проверить, куда смещается насыщение после улучшения. | Серия | Что меняем | Гипотеза | | --- | --- | --- | -| A_fixed_total | 1×1.0 / 2×0.5 / 4×0.25 CPU API (сумма 1.0 CPU, 768M) | пиковый RPS не растёт (тот же бюджет), p95 немного хуже из-за накладных расходов процессов и пулов; выигрыш реплик — только отказоустойчивость | -| B_scale_out | 1/2/4/8 реплик по 0.5 CPU, БД 1.0, LB 0.5, Redis 0.5 | рост почти линейный, пока узкое место — CPU API; затем остановка на общей зависимости | -| C_shared_resources | 4×0.5 API; PG 1→2 CPU, LB 0.5→1, Redis 0.5→1 | RPS поднимает только рост ресурса той зависимости, которая насыщена в B | -| D_improvement | 4×0.5 API: baseline vs 3 кандидата | инвалидация кэша через SCAN (наследие lab2) делает O(keyspace/100) запросов к Redis на каждую запись; ключ с версией чата (`CACHE_INVALIDATION=version`, 1 INCR) поднимает RPS. Альтернативы: `DB_POOL_MAX=8`, `LB_BALANCE=leastconn` | +| A_fixed_total | 1×1.0 / 2×0.5 / 4×0.25 CPU API (сумма 1.0 CPU) | RPS не растёт, p95 чуть хуже; реплики дают только отказоустойчивость | +| B_scale_out | 1/2/4 реплики по 0.5 CPU | рост, пока узкое место — CPU API, затем упор в общую зависимость | +| C_shared_resources | 4×0.5 API; PG 1→2, LB 0.5→1, Redis 0.5→1 CPU | RPS поднимает только ресурс насыщенной зависимости | +| D_improvement | 4×0.5 API: baseline и 3 кандидата | SCAN-инвалидация кэша (наследие lab2) — O(keyspace/100) запросов к Redis на запись; `CACHE_INVALIDATION=version` (1 INCR) поднимет RPS | +| E_scale_out_after_fix | 1/2/4 × 0.5 CPU с `version` | после снятия упора в Redis реплики снова помогают до следующей общей зависимости | -### Методика (повторяемая) +### Методика -- Отдельный compose-проект `mtusi2026lab3-bench` (порт 18080, свои volumes) — рабочие данные стенда не трогаются. Конфигурация задаётся только переменными окружения compose (`API_REPLICAS`, `API_CPUS`, `API_MEMORY`, `PG_CPUS`, `LB_CPUS`, `REDIS_CPUS`, `DB_POOL_MAX`, `CACHE_INVALIDATION`, `LB_BALANCE`); образ API один и тот же. -- Нагрузка — [cmd/bench](cmd/bench/main.go) (Go, closed-loop): 50% POST сообщения с уникальным Idempotency-Key, 50% GET истории `limit=50`; 8 чатов × 2 участника; без повторов; таймаут 5 s. Уровни параллелизма 1/4/8/16/32/64, прогрев 5 s, измерение 30 s, 3 повтора (серия D: 16/32/64, 5 повторов). Поддерживается и open-loop (`-rate`) с отсчётом задержки от запланированного момента (поправка на coordinated omission). -- Фоновый keyspace Redis — 10 000 синтетических ключей `pad:*` (≈ активные сессии и прочие данные). Это параметр профиля: от него зависит цена SCAN. -- Во время каждого прогона ~1 раз в секунду: `docker stats` всех контейнеров (CPU нормируется на лимит роли) и `pg_stat_activity` (активные соединения); до/после — счётчики пула pgx каждой реплики (внутренний порт 9090, не публикуется и не проксируется LB, читается через `docker exec`). -- Правила анализа фиксированы в [scripts/track1_report.py](scripts/track1_report.py): медиана по повторам; насыщение — первый уровень, где RPS вырос < 10%; узкое место — роль с максимальной утилизацией CPU от лимита (≥ 0.85 — насыщена) + доля ожиданий пула; улучшение **подтверждено**, только если на уровнях ≥ точки насыщения min(RPS кандидата) > max(RPS baseline) по всем повторам, p95 не хуже и ошибок не больше. +- Отдельный compose-проект `mtusi2026lab3-bench` (порт 18080). Конфигурация задаётся только переменными окружения (`API_REPLICAS`, `API_CPUS`, `API_MEMORY`, `PG_CPUS`, `LB_CPUS`, `REDIS_CPUS`, `DB_POOL_MAX`, `CACHE_INVALIDATION`, `LB_BALANCE`), образ один. +- База: PostgreSQL 1.0 CPU / 512M, `max_connections=200`; Redis 0.5 CPU; LB 0.5 CPU; пул 20 на реплику; `CACHE_INVALIDATION=scan` (поведение lab2); фоновый keyspace Redis — 10 000 ключей `pad:*` (≈ активные сессии). +- Нагрузка [cmd/bench](cmd/bench/main.go): closed-loop, 50% POST сообщения (уникальный Idempotency-Key) / 50% GET истории `limit=50`, 8 чатов × 2 участника, без повторов, таймаут 5 s. +- **Фактический объём** (сокращён из-за времени работы runner): уровни параллелизма 4/16/64 (C: 16/64, D: 32/64), прогрев 3 s, измерение 15 s, **3 повтора** каждой точки — всего 129 прогонов. Полная методика (6 уровней, 30 s, 3–5 повторов) запускается `make track1`. +- Во время прогона раз в 1–2 s снимаются `docker stats` (CPU нормирован на лимит роли) и `pg_stat_activity`; до и после — счётчики пула pgx (внутренний порт 9090, не публикуется). +- Правила анализа в [scripts/track1_report.py](scripts/track1_report.py): медиана повторов; насыщение — первый уровень с ростом RPS < 10%; узкое место — роль с максимальной утилизацией лимита (≥ 0.85 — насыщена); улучшение подтверждено, если min(RPS кандидата) > max(RPS baseline) по всем повторам, p95 не хуже, ошибок не больше. Метрика «CPU хоста» (сумма util × лимит × число контейнеров по ролям) добавлена после прогона 2. +- Сырые данные: [evidence/track1/raw.jsonl](evidence/track1/raw.jsonl) (одна строка — один прогон, без токенов). Сводка: [summary.md](evidence/track1/summary.md), [summary.csv](evidence/track1/summary.csv). Графики RPS и p95 по каждой серии: [report.html](evidence/track1/report.html). -Запуск (Docker-стенд должен работать; основной стенд лучше остановить, чтобы не делить CPU): +Ошибок (`error_ratio`) не было ни в одном из 129 прогонов. -```sh -make track1-quick PYTHON=python # ~15 мин, 1 повтор — проверка, что всё работает -make track1 PYTHON=python # полная методика (~2–3 ч), продолжает после обрыва (--resume) -# Результаты: evidence/track1/raw.jsonl (сырые данные), summary.csv, summary.md, report.html (графики) -python scripts/track1.py --cleanup --series none # удалить bench-проект и его volumes -``` +### Результаты (медианы 3 повторов) -Перед прогоном зафиксировать в этом разделе: CPU/RAM хоста и лимиты Docker Desktop (скрипт пишет их в каждую строку raw.jsonl), версии образов. +**A — фиксированный бюджет API 1.0 CPU** -### Проверка инструментов (без Docker) +| config | RPS c=4 / 16 / 64 | p95 c=16, ms | util Redis | util API | +| --- | --- | --- | --- | --- | +| 1×1.00 | 224 / **258** / 247 | 142 | 1.00 | 0.67 | +| 2×0.50 | 198 / 234 / **252** | 166 | 0.99 | 0.79 | +| 4×0.25 | 182 / 215 / **231** | 183 | 0.88 | 0.86 | -Нативно (PostgreSQL 17, fakeredis, 2 процесса API в режимах `scan` и `version`, round-robin прокси) проверено: smoke и конкурентная идемпотентность проходят в обоих режимах кэша; `bin/bench` выдаёт корректную смесь (≈50/50) и распределение по репликам; `/internal/stats` отдаёт счётчики пула; `track1_report.py` строит таблицы, графики и вердикт по синтетическому файлу (не сохранён в evidence — это не результат). **Реальных измерений трека пока нет.** +Гипотеза подтверждена частично: RPS не растёт (258 → 252 → 231), p95 растёт (142 → 166 → 183 ms при c=16). Но причина не в API: Redis упирается в свой лимит уже при одной реплике. -### Результаты +**B — рост числа реплик по 0.5 CPU** -TODO после `make track1`: перенести из evidence/track1/summary.md таблицы по сериям, графики из report.html и выводы: - -| Серия | Наблюдение | Узкое место (утилизация) | Вывод | +| config | пик RPS | × к 1 реплике | узкое место на пике | | --- | --- | --- | --- | -| A_fixed_total | TODO | TODO | TODO | -| B_scale_out | TODO | TODO | TODO: с какого N рост прекращается и почему | -| C_shared_resources | TODO | TODO | TODO: какой ресурс снимает насыщение | -| D_improvement | TODO | TODO | TODO: какое улучшение подтверждено (или ни одно) | +| 1×0.50 | 295 | 1.00 | **API 1.00** | +| 2×0.50 | 372 | 1.26 | **Redis 1.00** (API 0.77) | +| 4×0.50 | 357 | 1.21 | **Redis 0.97** (API 0.43) | + +**Saturation point — 2 реплики.** С одной на две реплики RPS растёт на 26% (снимается упор в CPU API), дальше роста нет: Redis (0.5 CPU) загружен на 100% лимита, а CPU API простаивает (0.43). Рост реплик перестаёт помогать, потому что каждая запись делает SCAN по keyspace Redis, и общий Redis насыщается раньше API. + +**C — проверка причины (4×0.5 API)** + +| config | RPS c=16 / 64 | util Redis | вывод | +| --- | --- | --- | --- | +| базовая | 455 / 494 | 1.00 | — | +| PG 2 CPU | 463 / 501 | 1.00 | +1%, в пределах шума | +| LB 1 CPU | 453 / 486 | 0.99 | 0% | +| **Redis 1 CPU** | **492 / 538** | **0.55** | **+8–9%**, Redis перестаёт быть насыщенным | + +RPS поднимает только ресурс Redis — гипотеза C подтверждена. Прирост ограничен (+9%), потому что дальше сказывается CPU хоста (см. E). + +**D — подтверждённое улучшение (4×0.5 API)** + +| кандидат | RPS c=32 / 64 | p95 c=32, ms | util Redis | подтверждено | +| --- | --- | --- | --- | --- | +| baseline (`scan`) | 214 / 222 | 346 | 1.00 | — | +| **`CACHE_INVALIDATION=version`** | **544 / 549** | **130** | **0.24** | **да: +148% RPS, −57% p95 при c=64; все 3 повтора лучше всех 3 повторов baseline** | +| `DB_POOL_MAX=8` | 208 / 234 | 347 | 1.00 | нет (+5%, внутри разброса) | +| `LB_BALANCE=leastconn` | 232 / 224 | 321 | 0.99 | нет (+1%) | + +Изменение кода: ключ кэша истории включает версию чата, запись делает один `INCR` вместо `SCAN`+`DEL` ([message_cache.go](internal/repository/redis/message_cache.go)). Корректность сохранена: к моменту ответа на запись версия уже увеличена, и следующее чтение идёт по новому ключу (smoke и идемпотентность проходят в обоих режимах). Режим `version` — значение по умолчанию в compose.yaml. + +**E — рост реплик после улучшения** + +| config | пик RPS | p95 c=64, ms | util API / PG / Redis | CPU контейнеров, ядер из 2 | +| --- | --- | --- | --- | --- | +| 1×0.50 | 560 | 176 | **1.00** / 0.40 / 0.23 | 1.09 | +| 2×0.50 | **618** | 207 | 0.78 / 0.55 / 0.24 | 1.55 | +| 4×0.50 | 599 | 244 | 0.42 / 0.51 / 0.27 | 1.56 | + +После улучшения одна реплика даёт почти вдвое больше, чем в B (на другом процессоре runner, поэтому сравнение приблизительное). Но вторая реплика добавляет лишь +10%, а четвёртая — ничего: RPS 618 → 599, p95 растёт (207 → 244 ms), активных соединений PostgreSQL в пике больше (29 → 45). Ни один контейнер не упирается в лимит; вместе они занимают ≈1.56 из 2 vCPU runner, остальное делят генератор нагрузки, dockerd и сетевой стек. Интерпретация: **следующий потолок — CPU узла**, и реплики на одном двухъядерном узле не добавляют вычислительной мощности. Это интерпретация, а не прямое измерение: CPU генератора нагрузки не измерялся. + +### Выводы трека + +1. При фиксированном CPU реплики не увеличивают пропускную способность и ухудшают p95 (A). +2. При росте ресурсов насыщение наступает на 2 репликах из-за общей зависимости — Redis (B); это подтверждено изменением только её ресурса (C). +3. Подтверждённое улучшение — инвалидация кэша по версии вместо SCAN: ×2.5 RPS и −57% p95 на той же конфигурации (D). +4. После улучшения точка насыщения смещается к CPU узла (E): дальше масштабировать нужно узлами, а не репликами на одном узле. ### Ограничения трека -- Один хост: генератор нагрузки, LB, API и БД делят физические ядра; лимиты Docker — это квоты CFS, а не выделенные ядра. Если пик упирается в CPU клиента, это видно по CPU хоста, и вывод о стенде делать нельзя. -- Closed-loop показывает пропускную способность при заданном параллелизме, но не задержку при фиксированной входящей нагрузке; для отдельных точек можно повторить с `-rate`. -- История растёт во время серии; GET читает первые 50 сообщений чата по индексу, поэтому стоимость чтения от объёма почти не зависит, но размер таблиц растёт. -- Утилизация из `docker stats` усредняется с шагом ~1–2 s; короткие всплески не видны. +- Runner 2 vCPU: сумма лимитов в конфигурациях 4×0.5 (3.5–4 CPU) больше, чем у хоста; лимиты Docker — квоты CFS. Поэтому «утилизация лимита < 1» не значит, что CPU свободен. +- Сокращённая методика: 3 уровня параллелизма, 15 s, 3 повтора; точка насыщения определена с шагом ×4 по параллелизму. +- Разные job — разные модели CPU; абсолютные RPS сравнимы только внутри серии (база C даёт 494 RPS против 357 у B 4×0.5 при одинаковой конфигурации — другой процессор). +- Аномалия: в 2 из 3 повторов `A 4×0.25 c=64` сборщик `docker stats` почти не получил замеров (утилизация занижена, RPS нормальный). Медиана утилизации в этой точке недостоверна; вывод по A сделан по c=4/16. +- Только closed-loop; задержки — успешных запросов (ошибок не было). +- История растёт во время серии; GET читает первые 50 сообщений по индексу, поэтому стоимость чтения от объёма почти не зависит. ## Ограничения и следующие шаги -- Выдерживается отказ одной API-реплики (процесс/контейнер). Не выдерживается: отказ LB, PostgreSQL, Redis, хоста — это SPOF (один узел, БД не реплицирована). -- Миграции совместимы с работающей версией только при подходе expand→contract; `0002` только добавляет таблицу, поэтому старые реплики продолжают работать во время rolling update. Деструктивные миграции так применять нельзя. -- Idempotency-ключи хранятся в PostgreSQL рядом с сообщением — атомарность без распределённых транзакций, ценой одной лишней записи на POST. +- Выдерживается отказ одной API-реплики (процесс/контейнер). Не выдерживается отказ LB, PostgreSQL, Redis или хоста — это SPOF (один узел, БД не реплицирована). +- Миграции совместимы с работающей версией только при подходе expand→contract; `0002` только добавляет таблицу. Деструктивные миграции так применять нельзя. +- Ключи идемпотентности хранятся в PostgreSQL рядом с сообщением — атомарность без распределённых транзакций ценой одной лишней записи на POST. - Ошибки, сгенерированные самим HAProxy (502/503/504), не содержат X-Instance-Id — это допускается контрактом. -- Результаты Docker-стенда (таблицы TODO выше) ещё не получены из-за отсутствия виртуализации на машине разработки; после включения VT-x/WSL2 — запустить `sh scripts/collect-evidence.sh` и заполнить таблицы. +- Docker-стенд на машине разработки не запускается (нет VT-x), доказательства получены на GitHub runner. На любой машине с Docker всё воспроизводится теми же командами. diff --git a/evidence/docker_ps.txt b/evidence/docker_ps.txt new file mode 100644 index 00000000..998401a6 --- /dev/null +++ b/evidence/docker_ps.txt @@ -0,0 +1,8 @@ +2026-10-23T14:49:09Z +Docker Compose version v2.38.2 +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi2026lab3-api-1 mtusi2026lab3-api:local "/app/api" api 13 seconds ago Up 6 seconds (healthy) 8080/tcp +mtusi2026lab3-api-2 mtusi2026lab3-api:local "/app/api" api 13 seconds ago Up 6 seconds (healthy) 8080/tcp +mtusi2026lab3-lb-1 haproxy:3.0.5-alpine "docker-entrypoint.s…" lb 13 seconds ago Up Less than a second 127.0.0.1:8080->8080/tcp, 127.0.0.1:8404->8404/tcp +mtusi2026lab3-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 13 seconds ago Up 13 seconds (healthy) 5432/tcp +mtusi2026lab3-redis-1 redis:7.4.1-alpine "docker-entrypoint.s…" redis 13 seconds ago Up 13 seconds (healthy) 6379/tcp diff --git a/evidence/docker_ps_final.txt b/evidence/docker_ps_final.txt new file mode 100644 index 00000000..23ddacd4 --- /dev/null +++ b/evidence/docker_ps_final.txt @@ -0,0 +1,7 @@ +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi2026lab3-api-3 mtusi2026lab3-api:local "/app/api" api About a minute ago Up About a minute (healthy) 8080/tcp +mtusi2026lab3-api-4 mtusi2026lab3-api:local "/app/api" api About a minute ago Up About a minute (healthy) 8080/tcp +mtusi2026lab3-lb-1 haproxy:3.0.5-alpine "docker-entrypoint.s…" lb 5 minutes ago Up 3 minutes 127.0.0.1:8080->8080/tcp, 127.0.0.1:8404->8404/tcp +mtusi2026lab3-migrate-1 migrate/migrate:v4.17.0 "/bin/sh -c 'exec mi…" migrate 5 minutes ago Exited (0) 3 minutes ago +mtusi2026lab3-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 5 minutes ago Up 4 minutes (healthy) 5432/tcp +mtusi2026lab3-redis-1 redis:7.4.1-alpine "docker-entrypoint.s…" redis 5 minutes ago Up 4 minutes (healthy) 6379/tcp diff --git a/evidence/docker_stats.txt b/evidence/docker_stats.txt new file mode 100644 index 00000000..3554dbf2 --- /dev/null +++ b/evidence/docker_stats.txt @@ -0,0 +1,5 @@ +mtusi2026lab3-api-4 0.10% 39.38MiB / 256MiB +mtusi2026lab3-api-3 2.83% 48.86MiB / 256MiB +mtusi2026lab3-lb-1 0.12% 8.852MiB / 128MiB +mtusi2026lab3-postgres-1 0.07% 72.59MiB / 512MiB +mtusi2026lab3-redis-1 0.50% 9.191MiB / 256MiB diff --git a/evidence/failover_1.txt b/evidence/failover_1.txt new file mode 100644 index 00000000..376fcb9d --- /dev/null +++ b/evidence/failover_1.txt @@ -0,0 +1,8 @@ +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 143, "failed_attempts": 0, "first_recovery_seconds": 3.393} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +-- контейнеры api после stop-one: +mtusi2026lab3-api-1 259a4143c86a Up 27 seconds (healthy) +mtusi2026lab3-api-2 904a0714df9b Exited (0) 11 seconds ago +mtusi2026lab3-api-1 Up 35 seconds (healthy) +mtusi2026lab3-api-2 Up 6 seconds (healthy) diff --git a/evidence/failover_2.txt b/evidence/failover_2.txt new file mode 100644 index 00000000..7ed4acc0 --- /dev/null +++ b/evidence/failover_2.txt @@ -0,0 +1,8 @@ +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 144, "failed_attempts": 0, "first_recovery_seconds": 3.361} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +-- контейнеры api после stop-one: +mtusi2026lab3-api-1 259a4143c86a Up 50 seconds (healthy) +mtusi2026lab3-api-2 904a0714df9b Exited (0) 12 seconds ago +mtusi2026lab3-api-1 Up 58 seconds (healthy) +mtusi2026lab3-api-2 Up 6 seconds (healthy) diff --git a/evidence/failover_series.json b/evidence/failover_series.json new file mode 100644 index 00000000..a7e82aa8 --- /dev/null +++ b/evidence/failover_series.json @@ -0,0 +1,64 @@ +{ + "concurrency": 4, + "replicas": 2, + "total": { + "seconds": 53.99, + "ok": 18773, + "errors": 0, + "ok_rps": 347.7 + }, + "confirmed_writes": 9388, + "stored_messages": 9389, + "duplicates": 0, + "lost_confirmed": 0, + "per_replica": [ + { + "target_instance": "259a4143c86a", + "docker_stop_seconds": 3.57, + "before": { + "seconds": 5.0, + "ok": 1739, + "errors": 0, + "ok_rps": 347.8 + }, + "during_stop_and_observe": { + "seconds": 15.0, + "ok": 5428, + "errors": 0, + "ok_rps": 361.9 + }, + "errors_after_stop": 0, + "recovery_seconds": 0.0, + "target_last_served_after_stop_seconds": 0.75, + "other_instances_after": [ + "904a0714df9b" + ], + "restore_healthy_seconds": 6.24, + "restore_serving_via_lb_seconds": 6.25 + }, + { + "target_instance": "904a0714df9b", + "docker_stop_seconds": 4.12, + "before": { + "seconds": 5.0, + "ok": 1729, + "errors": 0, + "ok_rps": 345.8 + }, + "during_stop_and_observe": { + "seconds": 15.0, + "ok": 5370, + "errors": 0, + "ok_rps": 357.9 + }, + "errors_after_stop": 0, + "recovery_seconds": 0.0, + "target_last_served_after_stop_seconds": 1.46, + "other_instances_after": [ + "259a4143c86a" + ], + "restore_healthy_seconds": 6.81, + "restore_serving_via_lb_seconds": 6.81 + } + ] +} diff --git a/evidence/idempotency_concurrent.json b/evidence/idempotency_concurrent.json new file mode 100644 index 00000000..0d310544 --- /dev/null +++ b/evidence/idempotency_concurrent.json @@ -0,0 +1,88 @@ +{ + "rounds": 10, + "parallel_per_round": 16, + "distinct_instances_seen": 2, + "duplicates_found": 0, + "per_round": [ + { + "round": 0, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 1, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 2, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 3, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 4, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 5, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 6, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 7, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 8, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + }, + { + "round": 9, + "requests": 16, + "status_201": 16, + "distinct_messages": 1, + "stored": 1, + "instances": 2 + } + ] +} diff --git a/evidence/instances.txt b/evidence/instances.txt new file mode 100644 index 00000000..d79262fd --- /dev/null +++ b/evidence/instances.txt @@ -0,0 +1,2 @@ +259a4143c86a 10 +904a0714df9b 10 diff --git a/evidence/load_baseline.json b/evidence/load_baseline.json new file mode 100644 index 00000000..b7749f9f --- /dev/null +++ b/evidence/load_baseline.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.076, + "concurrency": 4, + "successful_requests": 11769, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 391.312, + "successful_latency_ms": { + "p50": 9.744, + "p95": 15.681, + "p99": 22.066 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..3a6ad1fa --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,14 @@ +-- до: +mtusi2026lab3-api-1 Up 58 seconds (healthy) +mtusi2026lab3-api-2 Up 6 seconds (healthy) +mtusi2026lab3-lb-1 Up 52 seconds +mtusi2026lab3-postgres-1 Up About a minute (healthy) +mtusi2026lab3-redis-1 Up About a minute (healthy) +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +-- после: +mtusi2026lab3-api-1 Up 6 seconds (healthy) +mtusi2026lab3-api-2 Up 6 seconds (healthy) +mtusi2026lab3-lb-1 Up Less than a second +mtusi2026lab3-postgres-1 Up 12 seconds (healthy) +mtusi2026lab3-redis-1 Up 12 seconds (healthy) diff --git a/evidence/rolling_update.txt b/evidence/rolling_update.txt new file mode 100644 index 00000000..1707a204 --- /dev/null +++ b/evidence/rolling_update.txt @@ -0,0 +1,89 @@ +-- до: +mtusi2026lab3-api-1 259a4143c86a Up About a minute (healthy) +mtusi2026lab3-api-2 904a0714df9b Up About a minute (healthy) +#1 [internal] load local bake definitions +#1 reading from stdin 380B done +#1 DONE 0.0s + +#2 [internal] load build definition from Dockerfile +#2 transferring dockerfile: 2.22kB 0.0s done +#2 DONE 0.0s + +#3 [internal] load metadata for docker.io/library/alpine:3.20 +#3 ... + +#4 [internal] load metadata for docker.io/library/golang:1.26-alpine +#4 DONE 0.2s + +#3 [internal] load metadata for docker.io/library/alpine:3.20 +#3 DONE 0.2s + +#5 [internal] load .dockerignore +#5 transferring context: 212B 0.0s done +#5 DONE 0.0s + +#6 [builder 1/6] FROM docker.io/library/golang:1.26-alpine@sha256:27f2d3b83cfc5803c8078f8e730af0f7c431bf067afaec8f60a36fb763187cba +#6 DONE 0.0s + +#7 [stage-1 1/5] FROM docker.io/library/alpine:3.20@sha256:d9e853e87e55526f6b2917df91a2115c36dd7c696a35be12163d44e6e2a4b6bc +#7 DONE 0.0s + +#8 [internal] load build context +#8 transferring context: 4.90kB 0.0s done +#8 DONE 0.0s + +#9 [stage-1 2/5] RUN apk --no-cache add ca-certificates tzdata +#9 CACHED + +#10 [builder 3/6] COPY go.mod go.sum ./ +#10 CACHED + +#11 [builder 6/6] RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -trimpath -o /out/api ./cmd/api +#11 CACHED + +#12 [builder 5/6] COPY . . +#12 CACHED + +#13 [stage-1 4/5] WORKDIR /app +#13 CACHED + +#14 [stage-1 3/5] RUN addgroup -g 1001 -S appgroup && adduser -u 1001 -S appuser -G appgroup +#14 CACHED + +#15 [builder 2/6] WORKDIR /src +#15 CACHED + +#16 [builder 4/6] RUN go mod download +#16 CACHED + +#17 [stage-1 5/5] COPY --from=builder --chown=appuser:appgroup /out/api /app/api +#17 CACHED + +#18 exporting to image +#18 exporting layers done +#18 writing image sha256:7963c3b2693515ae76dcf3c09b301780531b7a8fb5b79635f635351694eb6a56 done +#18 naming to docker.io/library/mtusi2026lab3-api:local done +#18 DONE 0.0s + +#19 resolving provenance for metadata file +#19 DONE 0.0s + api Built + Container mtusi2026lab3-postgres-1 Running +no change + Container mtusi2026lab3-api-1 Running + Container mtusi2026lab3-api-2 Running + Container mtusi2026lab3-api-3 Creating + Container mtusi2026lab3-api-3 Created + Container mtusi2026lab3-api-3 Starting + Container mtusi2026lab3-api-3 Started +replaced /mtusi2026lab3-api-1 + Container mtusi2026lab3-api-2 Running + Container mtusi2026lab3-api-3 Running + Container mtusi2026lab3-api-4 Creating + Container mtusi2026lab3-api-4 Created + Container mtusi2026lab3-api-4 Starting + Container mtusi2026lab3-api-4 Started +replaced /mtusi2026lab3-api-2 +mtusi2026lab3-api-3 22525ed8c455 mtusi2026lab3-api:local Up 22 seconds (healthy) +mtusi2026lab3-api-4 c20f2f6e88d4 mtusi2026lab3-api:local Up 10 seconds (healthy) +-- замена заняла 27 s (внутри 90 s нагрузки) diff --git a/evidence/rolling_update_load.json b/evidence/rolling_update_load.json new file mode 100644 index 00000000..8ba972f8 --- /dev/null +++ b/evidence/rolling_update_load.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 90.0, + "elapsed_seconds": 90.074, + "concurrency": 4, + "successful_requests": 33461, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 371.484, + "successful_latency_ms": { + "p50": 9.922, + "p95": 17.746, + "p99": 27.682 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/runner.txt b/evidence/runner.txt new file mode 100644 index 00000000..80902415 --- /dev/null +++ b/evidence/runner.txt @@ -0,0 +1,6 @@ +2 + total used free shared buff/cache available +Mem: 7938 1223 2825 93 4297 6715 +Swap: 3071 0 3071 +28.0.4 +Docker Compose version v2.38.2 diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..fc20f9dd --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1 @@ +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/track1/RUNS.txt b/evidence/track1/RUNS.txt index 0aab0cef..61a90355 100644 --- a/evidence/track1/RUNS.txt +++ b/evidence/track1/RUNS.txt @@ -1 +1,2 @@ run1=https://github.com/CharaWein/2026_lab3/actions/runs/39970452644 commit=fe4b4cf series=A_fixed_total,B_scale_out,D_improvement +run2=https://github.com/CharaWein/2026_lab3/actions/runs/39972671424 commit=0a37181 series=C_shared_resources,E_scale_out_after_fix; levels 3-4 evidence from run2 diff --git a/evidence/track1/raw.jsonl b/evidence/track1/raw.jsonl index 38afefa0..5119ba03 100644 --- a/evidence/track1/raw.jsonl +++ b/evidence/track1/raw.jsonl @@ -76,3 +76,54 @@ {"series": "D_improvement", "config": "leastconn", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"6da49288d253": 869, "7ac067adaf65": 824, "d3722c53e810": 826, "ded1e0e9c432": 833}, "label": "D_improvement/leastconn", "latency_ms": {"max": 799.42, "p50": 418.691, "p95": 616.116, "p99": 745.163}, "mode": "closed", "ok": 3352, "ok_read_rps": 108.86666666666666, "ok_rps": 223.46666666666667, "ok_write_rps": 114.6, "rate": 0, "read_ms": {"max": 95.196, "p50": 29.791, "p95": 52.519, "p99": 67.112}, "requests": 3352, "timestamp": "2026-10-23T14:42:44Z", "warmup_s": 3, "write_ms": {"max": 799.42, "p50": 513.092, "p95": 648.06, "p99": 767.753}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.2, "cpu_pct_max_per_container": 21.0, "cpu_utilization_of_limit": 0.383, "mem_max_mib": 210.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.4, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.088, "mem_max_mib": 9.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 23.4, "cpu_utilization_of_limit": 0.196, "mem_max_mib": 222.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.9, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 0.999, "mem_max_mib": 15.2}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 65}}, "pool": {"acquires": 11718, "empty_acquire_ratio": 0.0027, "avg_acquire_wait_ms": 1.677, "pool_max_conns_total": 80}} {"series": "D_improvement", "config": "leastconn", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"6da49288d253": 815, "7ac067adaf65": 797, "d3722c53e810": 750, "ded1e0e9c432": 815}, "label": "D_improvement/leastconn", "latency_ms": {"max": 953.834, "p50": 428.862, "p95": 671.277, "p99": 863.492}, "mode": "closed", "ok": 3177, "ok_read_rps": 104.33333333333333, "ok_rps": 211.8, "ok_write_rps": 107.46666666666667, "rate": 0, "read_ms": {"max": 101.445, "p50": 32.01, "p95": 60.8, "p99": 82.726}, "requests": 3177, "timestamp": "2026-10-23T14:43:06Z", "warmup_s": 3, "write_ms": {"max": 953.834, "p50": 541.934, "p95": 731.866, "p99": 887.26}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.8, "cpu_pct_max_per_container": 21.5, "cpu_utilization_of_limit": 0.375, "mem_max_mib": 65.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.4, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.089, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.2, "cpu_pct_max_per_container": 22.2, "cpu_utilization_of_limit": 0.192, "mem_max_mib": 226.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.7, "cpu_pct_max_per_container": 50.3, "cpu_utilization_of_limit": 0.993, "mem_max_mib": 21.8}, "postgres_connections": {"active_max": 2, "active_mean": 0.4, "total_max": 65}}, "pool": {"acquires": 11171, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 80}} {"series": "D_improvement", "config": "leastconn", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"6da49288d253": 930, "7ac067adaf65": 942, "d3722c53e810": 939, "ded1e0e9c432": 986}, "label": "D_improvement/leastconn", "latency_ms": {"max": 727.596, "p50": 376.223, "p95": 573.296, "p99": 642.229}, "mode": "closed", "ok": 3797, "ok_read_rps": 125.4, "ok_rps": 253.13333333333333, "ok_write_rps": 127.73333333333333, "rate": 0, "read_ms": {"max": 95.122, "p50": 26.395, "p95": 48.755, "p99": 66.78}, "requests": 3797, "timestamp": "2026-10-23T14:43:27Z", "warmup_s": 3, "write_ms": {"max": 727.596, "p50": 454.803, "p95": 604.676, "p99": 665.068}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.7, "cpu_pct_max_per_container": 22.9, "cpu_utilization_of_limit": 0.415, "mem_max_mib": 59.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.095, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.1, "cpu_pct_max_per_container": 24.6, "cpu_utilization_of_limit": 0.211, "mem_max_mib": 231.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.7, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 0.995, "mem_max_mib": 21.2}, "postgres_connections": {"active_max": 2, "active_mean": 0.8, "total_max": 66}}, "pool": {"acquires": 13027, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.022, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"1502dda7098d": 1764, "592d00ce1975": 1763, "87fdaa0d39ef": 1765, "aaa2f5ed6e90": 1766}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 160.335, "p50": 32.167, "p95": 80.126, "p99": 98.803}, "mode": "closed", "ok": 7058, "ok_read_rps": 232.46666666666667, "ok_rps": 470.53333333333336, "ok_write_rps": 238.06666666666666, "rate": 0, "read_ms": {"max": 80.302, "p50": 5.201, "p95": 16.317, "p99": 24.032}, "requests": 7058, "timestamp": "2026-10-23T14:49:36Z", "warmup_s": 3, "write_ms": {"max": 160.335, "p50": 58.789, "p95": 87.146, "p99": 110.176}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.1, "cpu_pct_max_per_container": 21.2, "cpu_utilization_of_limit": 0.361, "mem_max_mib": 144.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.6, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.111, "mem_max_mib": 10.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.3, "cpu_pct_max_per_container": 25.8, "cpu_utilization_of_limit": 0.233, "mem_max_mib": 88.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 11.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 25}}, "pool": {"acquires": 24138, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.035, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"1502dda7098d": 1707, "592d00ce1975": 1705, "87fdaa0d39ef": 1709, "aaa2f5ed6e90": 1706}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 230.273, "p50": 28.196, "p95": 80.561, "p99": 116.881}, "mode": "closed", "ok": 6827, "ok_read_rps": 226.6, "ok_rps": 455.1333333333333, "ok_write_rps": 228.53333333333333, "rate": 0, "read_ms": {"max": 52.366, "p50": 5.524, "p95": 16.366, "p99": 24.989}, "requests": 6827, "timestamp": "2026-10-23T14:49:57Z", "warmup_s": 3, "write_ms": {"max": 230.273, "p50": 60.174, "p95": 95.486, "p99": 142.96}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.0, "cpu_pct_max_per_container": 21.4, "cpu_utilization_of_limit": 0.36, "mem_max_mib": 254.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.4, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.108, "mem_max_mib": 10.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.9, "cpu_pct_max_per_container": 28.5, "cpu_utilization_of_limit": 0.239, "mem_max_mib": 92.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.3, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 0.987, "mem_max_mib": 11.1}, "postgres_connections": {"active_max": 16, "active_mean": 2.7, "total_max": 25}}, "pool": {"acquires": 23618, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"1502dda7098d": 1673, "592d00ce1975": 1673, "87fdaa0d39ef": 1677, "aaa2f5ed6e90": 1679}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 190.625, "p50": 35.192, "p95": 84.017, "p99": 106.295}, "mode": "closed", "ok": 6702, "ok_read_rps": 219.73333333333332, "ok_rps": 446.8, "ok_write_rps": 227.06666666666666, "rate": 0, "read_ms": {"max": 90.053, "p50": 5.546, "p95": 17.437, "p99": 26.036}, "requests": 6702, "timestamp": "2026-10-23T14:50:18Z", "warmup_s": 3, "write_ms": {"max": 190.625, "p50": 61.373, "p95": 93.086, "p99": 119.239}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.9, "cpu_pct_max_per_container": 21.0, "cpu_utilization_of_limit": 0.357, "mem_max_mib": 256.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.3, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.106, "mem_max_mib": 10.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.0, "cpu_pct_max_per_container": 24.5, "cpu_utilization_of_limit": 0.23, "mem_max_mib": 100.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.991, "mem_max_mib": 11.5}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 27}}, "pool": {"acquires": 23187, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"1502dda7098d": 1850, "592d00ce1975": 1852, "87fdaa0d39ef": 1846, "aaa2f5ed6e90": 1854}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 478.86, "p50": 61.639, "p95": 290.529, "p99": 357.652}, "mode": "closed", "ok": 7402, "ok_read_rps": 249.33333333333334, "ok_rps": 493.46666666666664, "ok_write_rps": 244.13333333333333, "rate": 0, "read_ms": {"max": 239.502, "p50": 14.858, "p95": 36.717, "p99": 62.556}, "requests": 7402, "timestamp": "2026-10-23T14:50:38Z", "warmup_s": 3, "write_ms": {"max": 478.86, "p50": 236.886, "p95": 330.947, "p99": 368.836}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.4, "cpu_pct_max_per_container": 19.5, "cpu_utilization_of_limit": 0.348, "mem_max_mib": 248.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.7, "cpu_pct_max_per_container": 6.1, "cpu_utilization_of_limit": 0.115, "mem_max_mib": 12.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 28.9, "cpu_pct_max_per_container": 38.1, "cpu_utilization_of_limit": 0.289, "mem_max_mib": 201.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.4, "cpu_pct_max_per_container": 50.2, "cpu_utilization_of_limit": 0.988, "mem_max_mib": 13.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 71}}, "pool": {"acquires": 25090, "empty_acquire_ratio": 0.0018, "avg_acquire_wait_ms": 0.95, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"1502dda7098d": 1843, "592d00ce1975": 1841, "87fdaa0d39ef": 1835, "aaa2f5ed6e90": 1831}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 467.476, "p50": 173.538, "p95": 286.882, "p99": 318.978}, "mode": "closed", "ok": 7350, "ok_read_rps": 242.93333333333334, "ok_rps": 490, "ok_write_rps": 247.06666666666666, "rate": 0, "read_ms": {"max": 66.851, "p50": 14.844, "p95": 31.552, "p99": 43.658}, "requests": 7350, "timestamp": "2026-10-23T14:51:02Z", "warmup_s": 3, "write_ms": {"max": 467.476, "p50": 238.017, "p95": 300.506, "p99": 336.39}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.9, "cpu_pct_max_per_container": 20.7, "cpu_utilization_of_limit": 0.357, "mem_max_mib": 66.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.9, "cpu_pct_max_per_container": 6.1, "cpu_utilization_of_limit": 0.118, "mem_max_mib": 12.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.3, "cpu_pct_max_per_container": 26.1, "cpu_utilization_of_limit": 0.233, "mem_max_mib": 216.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.8, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 0.996, "mem_max_mib": 13.4}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 76}}, "pool": {"acquires": 25452, "empty_acquire_ratio": 0.0004, "avg_acquire_wait_ms": 0.07, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"1502dda7098d": 1885, "592d00ce1975": 1892, "87fdaa0d39ef": 1887, "aaa2f5ed6e90": 1893}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 363.423, "p50": 43.192, "p95": 282.669, "p99": 315.756}, "mode": "closed", "ok": 7557, "ok_read_rps": 254.26666666666668, "ok_rps": 503.8, "ok_write_rps": 249.53333333333333, "rate": 0, "read_ms": {"max": 67.27, "p50": 14.611, "p95": 31.85, "p99": 42.69}, "requests": 7557, "timestamp": "2026-10-23T14:51:23Z", "warmup_s": 3, "write_ms": {"max": 363.423, "p50": 233.457, "p95": 297.186, "p99": 326.57}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.7, "cpu_pct_max_per_container": 20.1, "cpu_utilization_of_limit": 0.354, "mem_max_mib": 66.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.9, "cpu_pct_max_per_container": 6.4, "cpu_utilization_of_limit": 0.118, "mem_max_mib": 12.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.2, "cpu_pct_max_per_container": 26.7, "cpu_utilization_of_limit": 0.242, "mem_max_mib": 222.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.5, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 1.009, "mem_max_mib": 19.9}, "postgres_connections": {"active_max": 3, "active_mean": 1, "total_max": 76}}, "pool": {"acquires": 26279, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1735, "556742a4f088": 1734, "ef72a9be18da": 1736, "fc5aa456cbb9": 1735}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 160.112, "p50": 35.652, "p95": 77.879, "p99": 97.226}, "mode": "closed", "ok": 6940, "ok_read_rps": 225.6, "ok_rps": 462.6666666666667, "ok_write_rps": 237.06666666666666, "rate": 0, "read_ms": {"max": 65.784, "p50": 5.109, "p95": 16.762, "p99": 23.418}, "requests": 6940, "timestamp": "2026-10-23T14:52:02Z", "warmup_s": 3, "write_ms": {"max": 160.112, "p50": 60.291, "p95": 84.988, "p99": 105.268}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.3, "cpu_pct_max_per_container": 19.3, "cpu_utilization_of_limit": 0.345, "mem_max_mib": 138.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.2, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.104, "mem_max_mib": 12.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.0, "cpu_pct_max_per_container": 25.2, "cpu_utilization_of_limit": 0.11, "mem_max_mib": 78.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 1.0, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 22}}, "pool": {"acquires": 23791, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.026, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1767, "556742a4f088": 1769, "ef72a9be18da": 1770, "fc5aa456cbb9": 1770}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 142.767, "p50": 27.646, "p95": 78.701, "p99": 97.969}, "mode": "closed", "ok": 7076, "ok_read_rps": 235.33333333333334, "ok_rps": 471.73333333333335, "ok_write_rps": 236.4, "rate": 0, "read_ms": {"max": 78.659, "p50": 5.293, "p95": 16.645, "p99": 25.537}, "requests": 7076, "timestamp": "2026-10-23T14:52:23Z", "warmup_s": 3, "write_ms": {"max": 142.767, "p50": 59.866, "p95": 86.675, "p99": 104.769}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.6, "cpu_pct_max_per_container": 18.7, "cpu_utilization_of_limit": 0.353, "mem_max_mib": 253.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.4, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.107, "mem_max_mib": 12.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 25.9, "cpu_pct_max_per_container": 48.9, "cpu_utilization_of_limit": 0.129, "mem_max_mib": 87.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.9, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 0.999, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 3, "active_mean": 0.6, "total_max": 24}}, "pool": {"acquires": 24139, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1697, "556742a4f088": 1702, "ef72a9be18da": 1699, "fc5aa456cbb9": 1701}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 523.409, "p50": 29.69, "p95": 80.507, "p99": 106.675}, "mode": "closed", "ok": 6799, "ok_read_rps": 225.8, "ok_rps": 453.26666666666665, "ok_write_rps": 227.46666666666667, "rate": 0, "read_ms": {"max": 488.253, "p50": 5.23, "p95": 17.048, "p99": 27.697}, "requests": 6799, "timestamp": "2026-10-23T14:52:43Z", "warmup_s": 3, "write_ms": {"max": 523.409, "p50": 60.172, "p95": 90.321, "p99": 123.025}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.6, "cpu_pct_max_per_container": 20.1, "cpu_utilization_of_limit": 0.351, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.3, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.105, "mem_max_mib": 12.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.0, "cpu_pct_max_per_container": 23.7, "cpu_utilization_of_limit": 0.105, "mem_max_mib": 90.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.1, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 0.981, "mem_max_mib": 12.4}, "postgres_connections": {"active_max": 2, "active_mean": 0.3, "total_max": 24}}, "pool": {"acquires": 23342, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1928, "556742a4f088": 1931, "ef72a9be18da": 1935, "fc5aa456cbb9": 1931}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 381.264, "p50": 41.328, "p95": 274.17, "p99": 303.446}, "mode": "closed", "ok": 7725, "ok_read_rps": 260, "ok_rps": 515, "ok_write_rps": 255, "rate": 0, "read_ms": {"max": 85.668, "p50": 13.89, "p95": 30.587, "p99": 40.858}, "requests": 7725, "timestamp": "2026-10-23T14:53:04Z", "warmup_s": 3, "write_ms": {"max": 381.264, "p50": 231.108, "p95": 287.286, "p99": 317.716}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.5, "cpu_pct_max_per_container": 19.6, "cpu_utilization_of_limit": 0.351, "mem_max_mib": 253.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.8, "cpu_pct_max_per_container": 6.1, "cpu_utilization_of_limit": 0.116, "mem_max_mib": 13.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.0, "cpu_pct_max_per_container": 25.7, "cpu_utilization_of_limit": 0.115, "mem_max_mib": 126.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 1.002, "mem_max_mib": 14.1}, "postgres_connections": {"active_max": 2, "active_mean": 0.3, "total_max": 38}}, "pool": {"acquires": 26579, "empty_acquire_ratio": 0.0005, "avg_acquire_wait_ms": 0.039, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1877, "556742a4f088": 1878, "ef72a9be18da": 1876, "fc5aa456cbb9": 1876}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 357.749, "p50": 170.525, "p95": 276.212, "p99": 306.586}, "mode": "closed", "ok": 7507, "ok_read_rps": 249.46666666666667, "ok_rps": 500.46666666666664, "ok_write_rps": 251, "rate": 0, "read_ms": {"max": 68.919, "p50": 14.375, "p95": 32.948, "p99": 46.39}, "requests": 7507, "timestamp": "2026-10-23T14:53:26Z", "warmup_s": 3, "write_ms": {"max": 357.749, "p50": 234.683, "p95": 291.6, "p99": 312.457}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.3, "cpu_pct_max_per_container": 19.3, "cpu_utilization_of_limit": 0.345, "mem_max_mib": 254.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.5, "cpu_pct_max_per_container": 5.9, "cpu_utilization_of_limit": 0.11, "mem_max_mib": 12.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 27.5, "cpu_pct_max_per_container": 50.1, "cpu_utilization_of_limit": 0.137, "mem_max_mib": 201.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.2, "cpu_pct_max_per_container": 50.3, "cpu_utilization_of_limit": 0.985, "mem_max_mib": 13.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 71}}, "pool": {"acquires": 25842, "empty_acquire_ratio": 0.0023, "avg_acquire_wait_ms": 0.293, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1832, "556742a4f088": 1835, "ef72a9be18da": 1836, "fc5aa456cbb9": 1834}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 347.404, "p50": 181.951, "p95": 285.071, "p99": 313.469}, "mode": "closed", "ok": 7337, "ok_read_rps": 241.33333333333334, "ok_rps": 489.1333333333333, "ok_write_rps": 247.8, "rate": 0, "read_ms": {"max": 77.213, "p50": 14.228, "p95": 30.046, "p99": 44.373}, "requests": 7337, "timestamp": "2026-10-23T14:53:48Z", "warmup_s": 3, "write_ms": {"max": 347.404, "p50": 239.436, "p95": 299.849, "p99": 325.239}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.5, "cpu_pct_max_per_container": 19.6, "cpu_utilization_of_limit": 0.35, "mem_max_mib": 70.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.5, "cpu_pct_max_per_container": 6.0, "cpu_utilization_of_limit": 0.111, "mem_max_mib": 13.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.7, "cpu_pct_max_per_container": 28.0, "cpu_utilization_of_limit": 0.118, "mem_max_mib": 216.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.4, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.988, "mem_max_mib": 13.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 74}}, "pool": {"acquires": 25356, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.025, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1754, "556742a4f088": 1755, "ef72a9be18da": 1751, "fc5aa456cbb9": 1751}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 137.218, "p50": 21.89, "p95": 82.014, "p99": 98.872}, "mode": "closed", "ok": 7011, "ok_read_rps": 238.6, "ok_rps": 467.4, "ok_write_rps": 228.8, "rate": 0, "read_ms": {"max": 50.918, "p50": 5.503, "p95": 16.543, "p99": 25.7}, "requests": 7011, "timestamp": "2026-10-23T14:54:18Z", "warmup_s": 3, "write_ms": {"max": 137.218, "p50": 61.045, "p95": 90.519, "p99": 106.075}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.2, "cpu_pct_max_per_container": 20.1, "cpu_utilization_of_limit": 0.365, "mem_max_mib": 248.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.5, "cpu_pct_max_per_container": 5.8, "cpu_utilization_of_limit": 0.055, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.4, "cpu_pct_max_per_container": 27.9, "cpu_utilization_of_limit": 0.234, "mem_max_mib": 82.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.4, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 14.1}, "postgres_connections": {"active_max": 2, "active_mean": 0.6, "total_max": 23}}, "pool": {"acquires": 23652, "empty_acquire_ratio": 0.0008, "avg_acquire_wait_ms": 0.03, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1693, "556742a4f088": 1692, "ef72a9be18da": 1690, "fc5aa456cbb9": 1689}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 210.125, "p50": 29.763, "p95": 84.306, "p99": 105.96}, "mode": "closed", "ok": 6764, "ok_read_rps": 225.06666666666666, "ok_rps": 450.93333333333334, "ok_write_rps": 225.86666666666667, "rate": 0, "read_ms": {"max": 91.522, "p50": 5.381, "p95": 15.445, "p99": 26.942}, "requests": 6764, "timestamp": "2026-10-23T14:54:39Z", "warmup_s": 3, "write_ms": {"max": 210.125, "p50": 61.551, "p95": 92.639, "p99": 113.351}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.2, "cpu_pct_max_per_container": 19.8, "cpu_utilization_of_limit": 0.364, "mem_max_mib": 241.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.4, "cpu_pct_max_per_container": 5.8, "cpu_utilization_of_limit": 0.054, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.6, "cpu_pct_max_per_container": 26.0, "cpu_utilization_of_limit": 0.236, "mem_max_mib": 90.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 1.003, "mem_max_mib": 13.3}, "postgres_connections": {"active_max": 4, "active_mean": 1.1, "total_max": 26}}, "pool": {"acquires": 23075, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.006, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1698, "556742a4f088": 1697, "ef72a9be18da": 1699, "fc5aa456cbb9": 1700}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 152.795, "p50": 22.14, "p95": 83.952, "p99": 103.892}, "mode": "closed", "ok": 6794, "ok_read_rps": 228.26666666666668, "ok_rps": 452.93333333333334, "ok_write_rps": 224.66666666666666, "rate": 0, "read_ms": {"max": 47.918, "p50": 5.328, "p95": 13.257, "p99": 21.843}, "requests": 6794, "timestamp": "2026-10-23T14:54:59Z", "warmup_s": 3, "write_ms": {"max": 152.795, "p50": 62.273, "p95": 92.382, "p99": 113.289}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.8, "cpu_pct_max_per_container": 22.7, "cpu_utilization_of_limit": 0.375, "mem_max_mib": 244.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.7, "cpu_pct_max_per_container": 5.9, "cpu_utilization_of_limit": 0.057, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.6, "cpu_pct_max_per_container": 25.0, "cpu_utilization_of_limit": 0.226, "mem_max_mib": 96.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.7, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.993, "mem_max_mib": 13.0}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 26}}, "pool": {"acquires": 22930, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1821, "556742a4f088": 1822, "ef72a9be18da": 1826, "fc5aa456cbb9": 1827}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 434.54, "p50": 47.631, "p95": 299.221, "p99": 343.583}, "mode": "closed", "ok": 7296, "ok_read_rps": 244.8, "ok_rps": 486.4, "ok_write_rps": 241.6, "rate": 0, "read_ms": {"max": 68.739, "p50": 14.803, "p95": 30.454, "p99": 44.397}, "requests": 7296, "timestamp": "2026-10-23T14:55:21Z", "warmup_s": 3, "write_ms": {"max": 434.54, "p50": 239.652, "p95": 320.022, "p99": 360.744}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.0, "cpu_pct_max_per_container": 20.2, "cpu_utilization_of_limit": 0.36, "mem_max_mib": 244.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.8, "cpu_pct_max_per_container": 6.4, "cpu_utilization_of_limit": 0.058, "mem_max_mib": 9.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.1, "cpu_pct_max_per_container": 26.2, "cpu_utilization_of_limit": 0.241, "mem_max_mib": 204.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.3, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 0.985, "mem_max_mib": 14.1}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 73}}, "pool": {"acquires": 24903, "empty_acquire_ratio": 0.0028, "avg_acquire_wait_ms": 0.975, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1804, "556742a4f088": 1814, "ef72a9be18da": 1817, "fc5aa456cbb9": 1812}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 391.209, "p50": 186.725, "p95": 293.161, "p99": 330.416}, "mode": "closed", "ok": 7247, "ok_read_rps": 239.26666666666668, "ok_rps": 483.1333333333333, "ok_write_rps": 243.86666666666667, "rate": 0, "read_ms": {"max": 82.769, "p50": 14.364, "p95": 30.377, "p99": 48.517}, "requests": 7247, "timestamp": "2026-10-23T14:55:43Z", "warmup_s": 3, "write_ms": {"max": 391.209, "p50": 240.098, "p95": 312.037, "p99": 340.71}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.7, "cpu_pct_max_per_container": 20.6, "cpu_utilization_of_limit": 0.353, "mem_max_mib": 65.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.8, "cpu_pct_max_per_container": 6.4, "cpu_utilization_of_limit": 0.058, "mem_max_mib": 10.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.0, "cpu_pct_max_per_container": 26.3, "cpu_utilization_of_limit": 0.24, "mem_max_mib": 214.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 0.992, "mem_max_mib": 14.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 74}}, "pool": {"acquires": 25397, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1839, "556742a4f088": 1835, "ef72a9be18da": 1836, "fc5aa456cbb9": 1836}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 364.483, "p50": 35.818, "p95": 292.592, "p99": 333.181}, "mode": "closed", "ok": 7346, "ok_read_rps": 250.13333333333333, "ok_rps": 489.73333333333335, "ok_write_rps": 239.6, "rate": 0, "read_ms": {"max": 73.214, "p50": 14.733, "p95": 30.89, "p99": 42.413}, "requests": 7346, "timestamp": "2026-10-23T14:56:05Z", "warmup_s": 3, "write_ms": {"max": 364.483, "p50": 245.118, "p95": 309.845, "p99": 343.49}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.6, "cpu_pct_max_per_container": 20.4, "cpu_utilization_of_limit": 0.352, "mem_max_mib": 65.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.8, "cpu_pct_max_per_container": 6.4, "cpu_utilization_of_limit": 0.058, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.2, "cpu_pct_max_per_container": 26.0, "cpu_utilization_of_limit": 0.232, "mem_max_mib": 216.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.8, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.996, "mem_max_mib": 14.4}, "postgres_connections": {"active_max": 3, "active_mean": 0.9, "total_max": 73}}, "pool": {"acquires": 25116, "empty_acquire_ratio": 0.0016, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1824, "556742a4f088": 1829, "ef72a9be18da": 1828, "fc5aa456cbb9": 1825}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 128.548, "p50": 28.82, "p95": 78.131, "p99": 99.385}, "mode": "closed", "ok": 7306, "ok_read_rps": 241.73333333333332, "ok_rps": 487.06666666666666, "ok_write_rps": 245.33333333333334, "rate": 0, "read_ms": {"max": 49.619, "p50": 5.113, "p95": 12.695, "p99": 20.412}, "requests": 7306, "timestamp": "2026-10-23T14:56:35Z", "warmup_s": 3, "write_ms": {"max": 128.548, "p50": 56.884, "p95": 87.38, "p99": 107.192}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.8, "cpu_pct_max_per_container": 22.6, "cpu_utilization_of_limit": 0.397, "mem_max_mib": 63.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.8, "cpu_pct_max_per_container": 6.5, "cpu_utilization_of_limit": 0.115, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 27.4, "cpu_pct_max_per_container": 43.2, "cpu_utilization_of_limit": 0.274, "mem_max_mib": 232.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 52.6, "cpu_pct_max_per_container": 55.1, "cpu_utilization_of_limit": 0.526, "mem_max_mib": 18.1}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 73}}, "pool": {"acquires": 24850, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1845, "556742a4f088": 1847, "ef72a9be18da": 1846, "fc5aa456cbb9": 1844}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 272.259, "p50": 30.712, "p95": 76.349, "p99": 97.135}, "mode": "closed", "ok": 7382, "ok_read_rps": 242.86666666666667, "ok_rps": 492.1333333333333, "ok_write_rps": 249.26666666666668, "rate": 0, "read_ms": {"max": 77.1, "p50": 5.032, "p95": 11.856, "p99": 20.182}, "requests": 7382, "timestamp": "2026-10-23T14:56:56Z", "warmup_s": 3, "write_ms": {"max": 272.259, "p50": 55.321, "p95": 85.157, "p99": 111.38}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.1, "cpu_pct_max_per_container": 21.9, "cpu_utilization_of_limit": 0.403, "mem_max_mib": 63.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.9, "cpu_pct_max_per_container": 6.2, "cpu_utilization_of_limit": 0.117, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.4, "cpu_pct_max_per_container": 26.0, "cpu_utilization_of_limit": 0.244, "mem_max_mib": 228.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 53.7, "cpu_pct_max_per_container": 55.5, "cpu_utilization_of_limit": 0.537, "mem_max_mib": 18.0}, "postgres_connections": {"active_max": 16, "active_mean": 2.4, "total_max": 73}}, "pool": {"acquires": 25229, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1894, "556742a4f088": 1896, "ef72a9be18da": 1901, "fc5aa456cbb9": 1896}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 141.528, "p50": 28.028, "p95": 75.485, "p99": 103.578}, "mode": "closed", "ok": 7587, "ok_read_rps": 249.66666666666666, "ok_rps": 505.8, "ok_write_rps": 256.1333333333333, "rate": 0, "read_ms": {"max": 64.106, "p50": 5.24, "p95": 13.184, "p99": 23.025}, "requests": 7587, "timestamp": "2026-10-23T14:57:19Z", "warmup_s": 3, "write_ms": {"max": 141.528, "p50": 53.699, "p95": 86.008, "p99": 111.28}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.4, "cpu_pct_max_per_container": 22.7, "cpu_utilization_of_limit": 0.407, "mem_max_mib": 71.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.9, "cpu_pct_max_per_container": 6.2, "cpu_utilization_of_limit": 0.118, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 25.2, "cpu_pct_max_per_container": 26.1, "cpu_utilization_of_limit": 0.252, "mem_max_mib": 227.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 55.0, "cpu_pct_max_per_container": 56.3, "cpu_utilization_of_limit": 0.55, "mem_max_mib": 14.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 73}}, "pool": {"acquires": 26166, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 1956, "556742a4f088": 1959, "ef72a9be18da": 1956, "fc5aa456cbb9": 1959}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 403.765, "p50": 145.339, "p95": 280.676, "p99": 325.283}, "mode": "closed", "ok": 7830, "ok_read_rps": 259.93333333333334, "ok_rps": 522, "ok_write_rps": 262.06666666666666, "rate": 0, "read_ms": {"max": 85.914, "p50": 13.761, "p95": 27.473, "p99": 37.889}, "requests": 7830, "timestamp": "2026-10-23T14:57:41Z", "warmup_s": 3, "write_ms": {"max": 403.765, "p50": 221.005, "p95": 299.949, "p99": 354.354}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.3, "cpu_pct_max_per_container": 22.0, "cpu_utilization_of_limit": 0.386, "mem_max_mib": 65.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 6.3, "cpu_pct_max_per_container": 6.7, "cpu_utilization_of_limit": 0.125, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 29.2, "cpu_pct_max_per_container": 44.0, "cpu_utilization_of_limit": 0.292, "mem_max_mib": 248.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 53.2, "cpu_pct_max_per_container": 55.4, "cpu_utilization_of_limit": 0.532, "mem_max_mib": 13.4}, "postgres_connections": {"active_max": 2, "active_mean": 0.6, "total_max": 79}}, "pool": {"acquires": 27266, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.06, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 2023, "556742a4f088": 2006, "ef72a9be18da": 2019, "fc5aa456cbb9": 2021}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 319.672, "p50": 38.515, "p95": 266.303, "p99": 289.011}, "mode": "closed", "ok": 8069, "ok_read_rps": 269.8666666666667, "ok_rps": 537.9333333333333, "ok_write_rps": 268.06666666666666, "rate": 0, "read_ms": {"max": 53.801, "p50": 13.708, "p95": 25.409, "p99": 33.758}, "requests": 8069, "timestamp": "2026-10-23T14:58:03Z", "warmup_s": 3, "write_ms": {"max": 319.672, "p50": 220.781, "p95": 277.338, "p99": 296.396}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 21.8, "cpu_utilization_of_limit": 0.393, "mem_max_mib": 68.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 6.3, "cpu_pct_max_per_container": 6.5, "cpu_utilization_of_limit": 0.125, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 26.6, "cpu_pct_max_per_container": 28.6, "cpu_utilization_of_limit": 0.266, "mem_max_mib": 247.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 54.8, "cpu_pct_max_per_container": 58.4, "cpu_utilization_of_limit": 0.548, "mem_max_mib": 17.4}, "postgres_connections": {"active_max": 2, "active_mean": 0.6, "total_max": 78}}, "pool": {"acquires": 28074, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322932736"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4a204741c04b": 2040, "556742a4f088": 2031, "ef72a9be18da": 2037, "fc5aa456cbb9": 2042}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 360.494, "p50": 131.864, "p95": 272.159, "p99": 304.745}, "mode": "closed", "ok": 8150, "ok_read_rps": 270.73333333333335, "ok_rps": 543.3333333333334, "ok_write_rps": 272.6, "rate": 0, "read_ms": {"max": 63.143, "p50": 13.435, "p95": 27.061, "p99": 35.516}, "requests": 8150, "timestamp": "2026-10-23T14:58:23Z", "warmup_s": 3, "write_ms": {"max": 360.494, "p50": 213.661, "p95": 289.346, "p99": 316.335}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 21.8, "cpu_utilization_of_limit": 0.392, "mem_max_mib": 64.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 6.4, "cpu_pct_max_per_container": 6.6, "cpu_utilization_of_limit": 0.128, "mem_max_mib": 10.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 26.4, "cpu_pct_max_per_container": 27.9, "cpu_utilization_of_limit": 0.264, "mem_max_mib": 251.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 55.0, "cpu_pct_max_per_container": 57.4, "cpu_utilization_of_limit": 0.55, "mem_max_mib": 14.1}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 78}}, "pool": {"acquires": 28085, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"d84589879ca7": 7231}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 51.897, "p50": 5.633, "p95": 31.897, "p99": 39.572}, "mode": "closed", "ok": 7231, "ok_read_rps": 240.26666666666668, "ok_rps": 482.06666666666666, "ok_write_rps": 241.8, "rate": 0, "read_ms": {"max": 48.118, "p50": 5.125, "p95": 29.423, "p99": 38.747}, "requests": 7231, "timestamp": "2026-10-23T14:49:47Z", "warmup_s": 3, "write_ms": {"max": 51.897, "p50": 6.254, "p95": 33.299, "p99": 39.905}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 49.9, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.999, "mem_max_mib": 137.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.3, "cpu_pct_max_per_container": 8.8, "cpu_utilization_of_limit": 0.167, "mem_max_mib": 8.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 36.7, "cpu_pct_max_per_container": 41.6, "cpu_utilization_of_limit": 0.367, "mem_max_mib": 42.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 11.4, "cpu_pct_max_per_container": 14.6, "cpu_utilization_of_limit": 0.228, "mem_max_mib": 29.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 5}}, "pool": {"acquires": 25111, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"d84589879ca7": 7129}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 97.942, "p50": 5.725, "p95": 31.014, "p99": 39.026}, "mode": "closed", "ok": 7129, "ok_read_rps": 234.93333333333334, "ok_rps": 475.26666666666665, "ok_write_rps": 240.33333333333334, "rate": 0, "read_ms": {"max": 60.261, "p50": 5.123, "p95": 29.213, "p99": 38.52}, "requests": 7129, "timestamp": "2026-10-23T14:50:10Z", "warmup_s": 3, "write_ms": {"max": 97.942, "p50": 6.278, "p95": 32.142, "p99": 39.631}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 1.002, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.5, "cpu_pct_max_per_container": 9.1, "cpu_utilization_of_limit": 0.169, "mem_max_mib": 8.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 38.7, "cpu_pct_max_per_container": 44.0, "cpu_utilization_of_limit": 0.387, "mem_max_mib": 47.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 11.5, "cpu_pct_max_per_container": 15.1, "cpu_utilization_of_limit": 0.229, "mem_max_mib": 52.1}, "postgres_connections": {"active_max": 1, "active_mean": 0.9, "total_max": 5}}, "pool": {"acquires": 24670, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"d84589879ca7": 6978}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 71.068, "p50": 5.795, "p95": 32.088, "p99": 40.255}, "mode": "closed", "ok": 6978, "ok_read_rps": 233.66666666666666, "ok_rps": 465.2, "ok_write_rps": 231.53333333333333, "rate": 0, "read_ms": {"max": 71.068, "p50": 5.284, "p95": 31.772, "p99": 39.517}, "requests": 6978, "timestamp": "2026-10-23T14:50:32Z", "warmup_s": 3, "write_ms": {"max": 64.966, "p50": 6.352, "p95": 32.396, "p99": 41.253}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 1.003, "mem_max_mib": 242.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.4, "cpu_pct_max_per_container": 9.0, "cpu_utilization_of_limit": 0.168, "mem_max_mib": 8.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 36.4, "cpu_pct_max_per_container": 42.2, "cpu_utilization_of_limit": 0.364, "mem_max_mib": 50.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 11.2, "cpu_pct_max_per_container": 13.8, "cpu_utilization_of_limit": 0.223, "mem_max_mib": 62.6}, "postgres_connections": {"active_max": 2, "active_mean": 0.6, "total_max": 5}}, "pool": {"acquires": 23976, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"d84589879ca7": 7662}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 134.873, "p50": 24.447, "p95": 66.167, "p99": 84.066}, "mode": "closed", "ok": 7662, "ok_read_rps": 259.06666666666666, "ok_rps": 510.8, "ok_write_rps": 251.73333333333332, "rate": 0, "read_ms": {"max": 92.824, "p50": 20.49, "p95": 57.816, "p99": 71.749}, "requests": 7662, "timestamp": "2026-10-23T14:50:54Z", "warmup_s": 3, "write_ms": {"max": 134.873, "p50": 29.257, "p95": 71.697, "p99": 90.117}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 1.0, "mem_max_mib": 223.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.5, "cpu_pct_max_per_container": 9.0, "cpu_utilization_of_limit": 0.169, "mem_max_mib": 8.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 37.6, "cpu_pct_max_per_container": 45.7, "cpu_utilization_of_limit": 0.376, "mem_max_mib": 80.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 10.3, "cpu_pct_max_per_container": 11.1, "cpu_utilization_of_limit": 0.205, "mem_max_mib": 62.0}, "postgres_connections": {"active_max": 1, "active_mean": 0.2, "total_max": 18}}, "pool": {"acquires": 26030, "empty_acquire_ratio": 0.0005, "avg_acquire_wait_ms": 0.044, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"d84589879ca7": 7680}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 147.929, "p50": 24.677, "p95": 66.031, "p99": 79.93}, "mode": "closed", "ok": 7680, "ok_read_rps": 259.26666666666665, "ok_rps": 512, "ok_write_rps": 252.73333333333332, "rate": 0, "read_ms": {"max": 112.467, "p50": 21.711, "p95": 59.838, "p99": 76.491}, "requests": 7680, "timestamp": "2026-10-23T14:51:17Z", "warmup_s": 3, "write_ms": {"max": 147.929, "p50": 28.173, "p95": 69.773, "p99": 82.778}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 49.8, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 0.995, "mem_max_mib": 64.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.5, "cpu_pct_max_per_container": 9.5, "cpu_utilization_of_limit": 0.17, "mem_max_mib": 8.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 34.7, "cpu_pct_max_per_container": 38.7, "cpu_utilization_of_limit": 0.347, "mem_max_mib": 84.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 13.8, "cpu_pct_max_per_container": 31.8, "cpu_utilization_of_limit": 0.277, "mem_max_mib": 59.0}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 17}}, "pool": {"acquires": 26396, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"d84589879ca7": 7865}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 129.888, "p50": 24.074, "p95": 65.21, "p99": 81.169}, "mode": "closed", "ok": 7865, "ok_read_rps": 261.6, "ok_rps": 524.3333333333334, "ok_write_rps": 262.73333333333335, "rate": 0, "read_ms": {"max": 115.32, "p50": 20.635, "p95": 59.999, "p99": 72.969}, "requests": 7865, "timestamp": "2026-10-23T14:51:40Z", "warmup_s": 3, "write_ms": {"max": 129.888, "p50": 27.198, "p95": 69.862, "p99": 85.8}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.3, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 64.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.6, "cpu_pct_max_per_container": 10.0, "cpu_utilization_of_limit": 0.172, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 36.4, "cpu_pct_max_per_container": 39.3, "cpu_utilization_of_limit": 0.364, "mem_max_mib": 87.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 10.8, "cpu_pct_max_per_container": 15.0, "cpu_utilization_of_limit": 0.216, "mem_max_mib": 58.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 17}}, "pool": {"acquires": 27060, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"d84589879ca7": 8451}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 290.631, "p50": 108.658, "p95": 177.337, "p99": 205.905}, "mode": "closed", "ok": 8451, "ok_read_rps": 279.73333333333335, "ok_rps": 563.4, "ok_write_rps": 283.6666666666667, "rate": 0, "read_ms": {"max": 250.765, "p50": 103.688, "p95": 165.099, "p99": 195.479}, "requests": 8451, "timestamp": "2026-10-23T14:52:02Z", "warmup_s": 3, "write_ms": {"max": 290.631, "p50": 114.609, "p95": 184.618, "p99": 212.59}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 49.9, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 0.999, "mem_max_mib": 68.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 10.2, "cpu_pct_max_per_container": 11.2, "cpu_utilization_of_limit": 0.204, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 40.7, "cpu_pct_max_per_container": 47.4, "cpu_utilization_of_limit": 0.407, "mem_max_mib": 97.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 11.5, "cpu_pct_max_per_container": 14.6, "cpu_utilization_of_limit": 0.23, "mem_max_mib": 59.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 20}}, "pool": {"acquires": 30288, "empty_acquire_ratio": 0.8948, "avg_acquire_wait_ms": 13.655, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"d84589879ca7": 8400}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 288.798, "p50": 109.088, "p95": 175.975, "p99": 202.438}, "mode": "closed", "ok": 8400, "ok_read_rps": 287.4, "ok_rps": 560, "ok_write_rps": 272.6, "rate": 0, "read_ms": {"max": 266.894, "p50": 105.743, "p95": 168.485, "p99": 192.139}, "requests": 8400, "timestamp": "2026-10-23T14:52:25Z", "warmup_s": 3, "write_ms": {"max": 288.798, "p50": 113.572, "p95": 182.726, "p99": 213.974}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.6, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.012, "mem_max_mib": 67.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.4, "cpu_pct_max_per_container": 10.6, "cpu_utilization_of_limit": 0.189, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 37.0, "cpu_pct_max_per_container": 39.2, "cpu_utilization_of_limit": 0.37, "mem_max_mib": 100.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 11.8, "cpu_pct_max_per_container": 20.3, "cpu_utilization_of_limit": 0.235, "mem_max_mib": 42.9}, "postgres_connections": {"active_max": 2, "active_mean": 0.5, "total_max": 20}}, "pool": {"acquires": 29883, "empty_acquire_ratio": 0.8652, "avg_acquire_wait_ms": 12.267, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"d84589879ca7": 8330}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 305.232, "p50": 109.29, "p95": 175.427, "p99": 204.492}, "mode": "closed", "ok": 8330, "ok_read_rps": 275.2, "ok_rps": 555.3333333333334, "ok_write_rps": 280.1333333333333, "rate": 0, "read_ms": {"max": 261.746, "p50": 104.072, "p95": 163.027, "p99": 191.553}, "requests": 8330, "timestamp": "2026-10-23T14:52:47Z", "warmup_s": 3, "write_ms": {"max": 305.232, "p50": 116.549, "p95": 182.917, "p99": 211.486}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 49.8, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.997, "mem_max_mib": 80.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.2, "cpu_pct_max_per_container": 9.9, "cpu_utilization_of_limit": 0.184, "mem_max_mib": 10.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 39.7, "cpu_pct_max_per_container": 45.3, "cpu_utilization_of_limit": 0.397, "mem_max_mib": 104.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 10.6, "cpu_pct_max_per_container": 14.4, "cpu_utilization_of_limit": 0.212, "mem_max_mib": 34.9}, "postgres_connections": {"active_max": 2, "active_mean": 0.6, "total_max": 21}}, "pool": {"acquires": 29897, "empty_acquire_ratio": 0.8929, "avg_acquire_wait_ms": 14.225, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 4574, "2116fbbd7d1b": 4572}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 72.886, "p50": 5.615, "p95": 11.998, "p99": 20.64}, "mode": "closed", "ok": 9146, "ok_read_rps": 307.4, "ok_rps": 609.7333333333333, "ok_write_rps": 302.3333333333333, "rate": 0, "read_ms": {"max": 56.91, "p50": 5.251, "p95": 11.474, "p99": 17.871}, "requests": 9146, "timestamp": "2026-10-23T14:53:19Z", "warmup_s": 3, "write_ms": {"max": 72.886, "p50": 5.981, "p95": 12.784, "p99": 21.92}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 39.7, "cpu_pct_max_per_container": 41.1, "cpu_utilization_of_limit": 0.794, "mem_max_mib": 138.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 10.7, "cpu_pct_max_per_container": 11.4, "cpu_utilization_of_limit": 0.214, "mem_max_mib": 10.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 43.3, "cpu_pct_max_per_container": 47.5, "cpu_utilization_of_limit": 0.433, "mem_max_mib": 79.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 17.3, "cpu_pct_max_per_container": 26.6, "cpu_utilization_of_limit": 0.346, "mem_max_mib": 48.5}, "postgres_connections": {"active_max": 3, "active_mean": 1, "total_max": 8}}, "pool": {"acquires": 30940, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 4585, "2116fbbd7d1b": 4585}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 56.637, "p50": 5.709, "p95": 11.581, "p99": 20.054}, "mode": "closed", "ok": 9170, "ok_read_rps": 305.6666666666667, "ok_rps": 611.3333333333334, "ok_write_rps": 305.6666666666667, "rate": 0, "read_ms": {"max": 56.637, "p50": 5.375, "p95": 10.76, "p99": 17.782}, "requests": 9170, "timestamp": "2026-10-23T14:53:41Z", "warmup_s": 3, "write_ms": {"max": 55.405, "p50": 6.015, "p95": 12.427, "p99": 22.094}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 40.1, "cpu_pct_max_per_container": 41.3, "cpu_utilization_of_limit": 0.801, "mem_max_mib": 241.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 10.8, "cpu_pct_max_per_container": 11.2, "cpu_utilization_of_limit": 0.215, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 45.2, "cpu_pct_max_per_container": 48.6, "cpu_utilization_of_limit": 0.452, "mem_max_mib": 90.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 13.9, "cpu_pct_max_per_container": 17.0, "cpu_utilization_of_limit": 0.278, "mem_max_mib": 69.7}, "postgres_connections": {"active_max": 3, "active_mean": 1.4, "total_max": 8}}, "pool": {"acquires": 31320, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 4369, "2116fbbd7d1b": 4367}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 76.12, "p50": 5.942, "p95": 12.199, "p99": 21.545}, "mode": "closed", "ok": 8736, "ok_read_rps": 292.4, "ok_rps": 582.4, "ok_write_rps": 290, "rate": 0, "read_ms": {"max": 76.12, "p50": 5.805, "p95": 11.805, "p99": 20.406}, "requests": 8736, "timestamp": "2026-10-23T14:54:01Z", "warmup_s": 3, "write_ms": {"max": 64.649, "p50": 6.091, "p95": 12.512, "p99": 22.298}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.3, "cpu_pct_max_per_container": 40.6, "cpu_utilization_of_limit": 0.765, "mem_max_mib": 235.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 10.2, "cpu_pct_max_per_container": 10.9, "cpu_utilization_of_limit": 0.203, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 46.5, "cpu_pct_max_per_container": 51.4, "cpu_utilization_of_limit": 0.465, "mem_max_mib": 86.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 16.6, "cpu_pct_max_per_container": 38.2, "cpu_utilization_of_limit": 0.332, "mem_max_mib": 78.3}, "postgres_connections": {"active_max": 2, "active_mean": 0.9, "total_max": 8}}, "pool": {"acquires": 29474, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 4635, "2116fbbd7d1b": 4631}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 347.366, "p50": 23.047, "p95": 52.358, "p99": 72.581}, "mode": "closed", "ok": 9266, "ok_read_rps": 303.26666666666665, "ok_rps": 617.7333333333333, "ok_write_rps": 314.46666666666664, "rate": 0, "read_ms": {"max": 347.366, "p50": 16.807, "p95": 41.11, "p99": 55.019}, "requests": 9266, "timestamp": "2026-10-23T14:54:22Z", "warmup_s": 3, "write_ms": {"max": 148.715, "p50": 30.013, "p95": 58.662, "p99": 81.648}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.6, "cpu_pct_max_per_container": 41.5, "cpu_utilization_of_limit": 0.773, "mem_max_mib": 223.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 10.0, "cpu_pct_max_per_container": 10.6, "cpu_utilization_of_limit": 0.2, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 48.7, "cpu_pct_max_per_container": 52.4, "cpu_utilization_of_limit": 0.487, "mem_max_mib": 138.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 17.8, "cpu_pct_max_per_container": 33.2, "cpu_utilization_of_limit": 0.355, "mem_max_mib": 74.5}, "postgres_connections": {"active_max": 9, "active_mean": 4.8, "total_max": 27}}, "pool": {"acquires": 31237, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.049, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 4692, "2116fbbd7d1b": 4689}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 132.319, "p50": 22.931, "p95": 51.393, "p99": 73.644}, "mode": "closed", "ok": 9381, "ok_read_rps": 315.3333333333333, "ok_rps": 625.4, "ok_write_rps": 310.06666666666666, "rate": 0, "read_ms": {"max": 117.434, "p50": 16.824, "p95": 39.196, "p99": 52.55}, "requests": 9381, "timestamp": "2026-10-23T14:54:43Z", "warmup_s": 3, "write_ms": {"max": 132.319, "p50": 30.49, "p95": 59.126, "p99": 85.486}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 40.4, "cpu_pct_max_per_container": 42.0, "cpu_utilization_of_limit": 0.808, "mem_max_mib": 202.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.8, "cpu_pct_max_per_container": 10.1, "cpu_utilization_of_limit": 0.197, "mem_max_mib": 10.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 51.4, "cpu_pct_max_per_container": 54.5, "cpu_utilization_of_limit": 0.514, "mem_max_mib": 141.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 16.8, "cpu_pct_max_per_container": 33.4, "cpu_utilization_of_limit": 0.337, "mem_max_mib": 72.3}, "postgres_connections": {"active_max": 7, "active_mean": 3.6, "total_max": 28}}, "pool": {"acquires": 31625, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 4525, "2116fbbd7d1b": 4526}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 170.769, "p50": 23.502, "p95": 54.313, "p99": 80.293}, "mode": "closed", "ok": 9051, "ok_read_rps": 300.46666666666664, "ok_rps": 603.4, "ok_write_rps": 302.93333333333334, "rate": 0, "read_ms": {"max": 170.769, "p50": 17.046, "p95": 41.654, "p99": 56.833}, "requests": 9051, "timestamp": "2026-10-23T14:55:04Z", "warmup_s": 3, "write_ms": {"max": 164.343, "p50": 31.049, "p95": 62.735, "p99": 87.396}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 39.0, "cpu_pct_max_per_container": 42.8, "cpu_utilization_of_limit": 0.779, "mem_max_mib": 186.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.5, "cpu_pct_max_per_container": 10.3, "cpu_utilization_of_limit": 0.191, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 53.3, "cpu_utilization_of_limit": 0.496, "mem_max_mib": 144.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 21.2, "cpu_pct_max_per_container": 39.7, "cpu_utilization_of_limit": 0.424, "mem_max_mib": 73.1}, "postgres_connections": {"active_max": 12, "active_mean": 5.5, "total_max": 29}}, "pool": {"acquires": 30992, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 4476, "2116fbbd7d1b": 4494}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 363.531, "p50": 100.856, "p95": 206.533, "p99": 260.686}, "mode": "closed", "ok": 8970, "ok_read_rps": 294.93333333333334, "ok_rps": 598, "ok_write_rps": 303.06666666666666, "rate": 0, "read_ms": {"max": 242.456, "p50": 69.85, "p95": 136.189, "p99": 173.196}, "requests": 8970, "timestamp": "2026-10-23T14:55:25Z", "warmup_s": 3, "write_ms": {"max": 363.531, "p50": 137.397, "p95": 230.226, "p99": 277.529}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 39.2, "cpu_pct_max_per_container": 40.7, "cpu_utilization_of_limit": 0.783, "mem_max_mib": 197.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.4, "cpu_pct_max_per_container": 9.6, "cpu_utilization_of_limit": 0.188, "mem_max_mib": 11.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 55.0, "cpu_pct_max_per_container": 56.1, "cpu_utilization_of_limit": 0.55, "mem_max_mib": 180.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 11.6, "cpu_pct_max_per_container": 12.1, "cpu_utilization_of_limit": 0.231, "mem_max_mib": 69.9}, "postgres_connections": {"active_max": 32, "active_mean": 27, "total_max": 40}}, "pool": {"acquires": 31413, "empty_acquire_ratio": 0.7589, "avg_acquire_wait_ms": 10.552, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 4571, "2116fbbd7d1b": 4519}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 454.574, "p50": 98.17, "p95": 208.648, "p99": 267.046}, "mode": "closed", "ok": 9090, "ok_read_rps": 298.8666666666667, "ok_rps": 606, "ok_write_rps": 307.1333333333333, "rate": 0, "read_ms": {"max": 254.289, "p50": 67.557, "p95": 134.449, "p99": 166.981}, "requests": 9090, "timestamp": "2026-10-23T14:55:47Z", "warmup_s": 3, "write_ms": {"max": 454.574, "p50": 135.142, "p95": 232.728, "p99": 306.293}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 40.1, "cpu_pct_max_per_container": 40.6, "cpu_utilization_of_limit": 0.802, "mem_max_mib": 63.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 10.2, "cpu_pct_max_per_container": 10.4, "cpu_utilization_of_limit": 0.203, "mem_max_mib": 11.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 57.9, "cpu_pct_max_per_container": 60.9, "cpu_utilization_of_limit": 0.579, "mem_max_mib": 187.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 11.9, "cpu_pct_max_per_container": 12.3, "cpu_utilization_of_limit": 0.238, "mem_max_mib": 53.2}, "postgres_connections": {"active_max": 29, "active_mean": 28.3, "total_max": 41}}, "pool": {"acquires": 31745, "empty_acquire_ratio": 0.8254, "avg_acquire_wait_ms": 11.401, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 4535, "2116fbbd7d1b": 4524}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 412.042, "p50": 99.557, "p95": 197.779, "p99": 237.825}, "mode": "closed", "ok": 9059, "ok_read_rps": 305.73333333333335, "ok_rps": 603.9333333333333, "ok_write_rps": 298.2, "rate": 0, "read_ms": {"max": 412.042, "p50": 70.512, "p95": 135.774, "p99": 166.066}, "requests": 9059, "timestamp": "2026-10-23T14:56:09Z", "warmup_s": 3, "write_ms": {"max": 346.969, "p50": 138.323, "p95": 216.076, "p99": 259.669}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.6, "cpu_pct_max_per_container": 40.6, "cpu_utilization_of_limit": 0.771, "mem_max_mib": 62.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 10.1, "cpu_pct_max_per_container": 10.6, "cpu_utilization_of_limit": 0.201, "mem_max_mib": 11.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 54.2, "cpu_pct_max_per_container": 56.6, "cpu_utilization_of_limit": 0.542, "mem_max_mib": 192.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 14.0, "cpu_pct_max_per_container": 18.7, "cpu_utilization_of_limit": 0.28, "mem_max_mib": 46.9}, "postgres_connections": {"active_max": 25, "active_mean": 8.3, "total_max": 40}}, "pool": {"acquires": 31531, "empty_acquire_ratio": 0.7986, "avg_acquire_wait_ms": 10.553, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 2249, "1d4d2744a3a6": 2248, "2116fbbd7d1b": 2249, "5f696d47f489": 2249}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 73.667, "p50": 5.683, "p95": 13.024, "p99": 20.185}, "mode": "closed", "ok": 8995, "ok_read_rps": 299.26666666666665, "ok_rps": 599.6666666666666, "ok_write_rps": 300.4, "rate": 0, "read_ms": {"max": 42.135, "p50": 5.074, "p95": 11.266, "p99": 18.647}, "requests": 8995, "timestamp": "2026-10-23T14:56:39Z", "warmup_s": 3, "write_ms": {"max": 73.667, "p50": 6.35, "p95": 13.981, "p99": 21.253}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 24.0, "cpu_utilization_of_limit": 0.425, "mem_max_mib": 138.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.9, "cpu_pct_max_per_container": 10.6, "cpu_utilization_of_limit": 0.199, "mem_max_mib": 10.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 43.3, "cpu_pct_max_per_container": 46.5, "cpu_utilization_of_limit": 0.433, "mem_max_mib": 205.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 14.1, "cpu_pct_max_per_container": 16.8, "cpu_utilization_of_limit": 0.281, "mem_max_mib": 52.4}, "postgres_connections": {"active_max": 3, "active_mean": 1.1, "total_max": 46}}, "pool": {"acquires": 30279, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 2190, "1d4d2744a3a6": 2190, "2116fbbd7d1b": 2192, "5f696d47f489": 2191}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 68.471, "p50": 5.818, "p95": 13.157, "p99": 20.894}, "mode": "closed", "ok": 8763, "ok_read_rps": 293.73333333333335, "ok_rps": 584.2, "ok_write_rps": 290.46666666666664, "rate": 0, "read_ms": {"max": 68.471, "p50": 5.339, "p95": 11.864, "p99": 18.463}, "requests": 8763, "timestamp": "2026-10-23T14:57:00Z", "warmup_s": 3, "write_ms": {"max": 58.573, "p50": 6.356, "p95": 14.255, "p99": 22.489}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 22.8, "cpu_utilization_of_limit": 0.426, "mem_max_mib": 246.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 10.0, "cpu_pct_max_per_container": 10.4, "cpu_utilization_of_limit": 0.2, "mem_max_mib": 10.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 44.2, "cpu_pct_max_per_container": 46.6, "cpu_utilization_of_limit": 0.442, "mem_max_mib": 211.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 14.7, "cpu_pct_max_per_container": 17.4, "cpu_utilization_of_limit": 0.295, "mem_max_mib": 70.7}, "postgres_connections": {"active_max": 2, "active_mean": 0.8, "total_max": 47}}, "pool": {"acquires": 29347, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 2247, "1d4d2744a3a6": 2248, "2116fbbd7d1b": 2247, "5f696d47f489": 2247}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 46.413, "p50": 5.796, "p95": 12.542, "p99": 19.606}, "mode": "closed", "ok": 8989, "ok_read_rps": 298.93333333333334, "ok_rps": 599.2666666666667, "ok_write_rps": 300.3333333333333, "rate": 0, "read_ms": {"max": 45.953, "p50": 5.193, "p95": 10.978, "p99": 17.645}, "requests": 8989, "timestamp": "2026-10-23T14:57:22Z", "warmup_s": 3, "write_ms": {"max": 46.413, "p50": 6.447, "p95": 13.776, "p99": 20.631}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.5, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.431, "mem_max_mib": 238.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.9, "cpu_pct_max_per_container": 10.4, "cpu_utilization_of_limit": 0.198, "mem_max_mib": 10.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 44.2, "cpu_pct_max_per_container": 46.0, "cpu_utilization_of_limit": 0.442, "mem_max_mib": 214.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 14.6, "cpu_pct_max_per_container": 16.4, "cpu_utilization_of_limit": 0.293, "mem_max_mib": 74.2}, "postgres_connections": {"active_max": 3, "active_mean": 1.7, "total_max": 47}}, "pool": {"acquires": 30707, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 2270, "1d4d2744a3a6": 2270, "2116fbbd7d1b": 2270, "5f696d47f489": 2273}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 359.016, "p50": 23.061, "p95": 54.586, "p99": 78.528}, "mode": "closed", "ok": 9083, "ok_read_rps": 305.1333333333333, "ok_rps": 605.5333333333333, "ok_write_rps": 300.4, "rate": 0, "read_ms": {"max": 359.016, "p50": 14.655, "p95": 35.289, "p99": 55.054}, "requests": 9083, "timestamp": "2026-10-23T14:57:43Z", "warmup_s": 3, "write_ms": {"max": 185.153, "p50": 34.185, "p95": 61.637, "p99": 88.602}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.8, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.417, "mem_max_mib": 236.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.5, "cpu_pct_max_per_container": 9.8, "cpu_utilization_of_limit": 0.189, "mem_max_mib": 10.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 48.3, "cpu_pct_max_per_container": 48.9, "cpu_utilization_of_limit": 0.483, "mem_max_mib": 239.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 14.8, "cpu_pct_max_per_container": 16.0, "cpu_utilization_of_limit": 0.295, "mem_max_mib": 73.4}, "postgres_connections": {"active_max": 9, "active_mean": 6.2, "total_max": 56}}, "pool": {"acquires": 30781, "empty_acquire_ratio": 0.0003, "avg_acquire_wait_ms": 0.025, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 2218, "1d4d2744a3a6": 2219, "2116fbbd7d1b": 2218, "5f696d47f489": 2215}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 161.345, "p50": 23.532, "p95": 56.579, "p99": 76.23}, "mode": "closed", "ok": 8870, "ok_read_rps": 299.53333333333336, "ok_rps": 591.3333333333334, "ok_write_rps": 291.8, "rate": 0, "read_ms": {"max": 107.061, "p50": 14.785, "p95": 37.191, "p99": 55.572}, "requests": 8870, "timestamp": "2026-10-23T14:58:05Z", "warmup_s": 3, "write_ms": {"max": 161.345, "p50": 35.6, "p95": 62.679, "p99": 90.54}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.8, "cpu_pct_max_per_container": 23.9, "cpu_utilization_of_limit": 0.415, "mem_max_mib": 238.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.6, "cpu_pct_max_per_container": 10.2, "cpu_utilization_of_limit": 0.191, "mem_max_mib": 10.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 45.7, "cpu_pct_max_per_container": 49.4, "cpu_utilization_of_limit": 0.457, "mem_max_mib": 247.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 18.0, "cpu_pct_max_per_container": 27.1, "cpu_utilization_of_limit": 0.36, "mem_max_mib": 76.4}, "postgres_connections": {"active_max": 10, "active_mean": 8.2, "total_max": 56}}, "pool": {"acquires": 30361, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 2201, "1d4d2744a3a6": 2199, "2116fbbd7d1b": 2201, "5f696d47f489": 2200}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 196.624, "p50": 24.02, "p95": 56.004, "p99": 76.312}, "mode": "closed", "ok": 8801, "ok_read_rps": 295.2, "ok_rps": 586.7333333333333, "ok_write_rps": 291.53333333333336, "rate": 0, "read_ms": {"max": 99.652, "p50": 14.995, "p95": 39.561, "p99": 55.215}, "requests": 8801, "timestamp": "2026-10-23T14:58:26Z", "warmup_s": 3, "write_ms": {"max": 196.624, "p50": 35.304, "p95": 63.553, "p99": 84.235}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.6, "cpu_pct_max_per_container": 23.5, "cpu_utilization_of_limit": 0.411, "mem_max_mib": 247.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.7, "cpu_pct_max_per_container": 10.1, "cpu_utilization_of_limit": 0.193, "mem_max_mib": 10.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 45.6, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 0.456, "mem_max_mib": 249.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 13.3, "cpu_pct_max_per_container": 14.1, "cpu_utilization_of_limit": 0.266, "mem_max_mib": 69.8}, "postgres_connections": {"active_max": 5, "active_mean": 3.2, "total_max": 57}}, "pool": {"acquires": 30199, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 2240, "1d4d2744a3a6": 2250, "2116fbbd7d1b": 2230, "5f696d47f489": 2246}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 554.644, "p50": 87.938, "p95": 243.258, "p99": 351.806}, "mode": "closed", "ok": 8966, "ok_read_rps": 298.1333333333333, "ok_rps": 597.7333333333333, "ok_write_rps": 299.6, "rate": 0, "read_ms": {"max": 522.205, "p50": 46.765, "p95": 105.385, "p99": 151.341}, "requests": 8966, "timestamp": "2026-10-23T14:58:48Z", "warmup_s": 3, "write_ms": {"max": 554.644, "p50": 154.301, "p95": 288.231, "p99": 400.177}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.2, "cpu_pct_max_per_container": 22.0, "cpu_utilization_of_limit": 0.404, "mem_max_mib": 236.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.3, "cpu_pct_max_per_container": 10.6, "cpu_utilization_of_limit": 0.187, "mem_max_mib": 11.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 51.3, "cpu_pct_max_per_container": 52.7, "cpu_utilization_of_limit": 0.513, "mem_max_mib": 314.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 13.7, "cpu_pct_max_per_container": 14.0, "cpu_utilization_of_limit": 0.274, "mem_max_mib": 68.4}, "postgres_connections": {"active_max": 45, "active_mean": 26.7, "total_max": 81}}, "pool": {"acquires": 30318, "empty_acquire_ratio": 0.038, "avg_acquire_wait_ms": 0.766, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 2233, "1d4d2744a3a6": 2232, "2116fbbd7d1b": 2234, "5f696d47f489": 2233}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 454.421, "p50": 86.151, "p95": 244.085, "p99": 321.814}, "mode": "closed", "ok": 8932, "ok_read_rps": 298, "ok_rps": 595.4666666666667, "ok_write_rps": 297.46666666666664, "rate": 0, "read_ms": {"max": 282.472, "p50": 45.3, "p95": 112.225, "p99": 164.543}, "requests": 8932, "timestamp": "2026-10-23T14:59:09Z", "warmup_s": 3, "write_ms": {"max": 454.421, "p50": 160.854, "p95": 281.895, "p99": 357.2}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.8, "cpu_pct_max_per_container": 21.6, "cpu_utilization_of_limit": 0.416, "mem_max_mib": 63.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.7, "cpu_pct_max_per_container": 9.9, "cpu_utilization_of_limit": 0.194, "mem_max_mib": 11.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 52.5, "cpu_pct_max_per_container": 53.5, "cpu_utilization_of_limit": 0.525, "mem_max_mib": 315.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 12.8, "cpu_pct_max_per_container": 13.3, "cpu_utilization_of_limit": 0.257, "mem_max_mib": 60.2}, "postgres_connections": {"active_max": 38, "active_mean": 25, "total_max": 80}}, "pool": {"acquires": 30490, "empty_acquire_ratio": 0.0216, "avg_acquire_wait_ms": 0.079, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"0c3123b2f1ed": 2206, "1d4d2744a3a6": 2209, "2116fbbd7d1b": 2206, "5f696d47f489": 2202}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 546.27, "p50": 88.108, "p95": 248.993, "p99": 361.321}, "mode": "closed", "ok": 8823, "ok_read_rps": 291, "ok_rps": 588.2, "ok_write_rps": 297.2, "rate": 0, "read_ms": {"max": 211.362, "p50": 46.769, "p95": 109.003, "p99": 145.071}, "requests": 8823, "timestamp": "2026-10-23T14:59:31Z", "warmup_s": 3, "write_ms": {"max": 546.27, "p50": 159.803, "p95": 291.212, "p99": 410.307}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.1, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.422, "mem_max_mib": 68.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.2, "cpu_pct_max_per_container": 9.5, "cpu_utilization_of_limit": 0.184, "mem_max_mib": 11.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 48.3, "cpu_pct_max_per_container": 50.4, "cpu_utilization_of_limit": 0.483, "mem_max_mib": 320.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 14.5, "cpu_pct_max_per_container": 15.4, "cpu_utilization_of_limit": 0.291, "mem_max_mib": 53.0}, "postgres_connections": {"active_max": 54, "active_mean": 39.7, "total_max": 80}}, "pool": {"acquires": 30746, "empty_acquire_ratio": 0.0167, "avg_acquire_wait_ms": 0.054, "pool_max_conns_total": 80}} diff --git a/evidence/track1/report.html b/evidence/track1/report.html new file mode 100644 index 00000000..1cebfbb3 --- /dev/null +++ b/evidence/track1/report.html @@ -0,0 +1,33 @@ +Трек 1 отчёт

Трек 1 — цена масштабирования

Медианы по повторам. Наведите на точку — значение. Полные данные — таблицы под графиками и summary.csv.

A_fixed_total — Фиксированный суммарный бюджет API: 1.0 CPU / 768M

Гипотеза: При фиксированном суммарном CPU рост числа реплик не увеличивает пиковый RPS (тот же бюджет) и немного ухудшает p95 из-за накладных расходов на процесс и пул соединений; выигрыш реплик — только отказоустойчивость.

Успешные RPS
1x1.002x0.504x0.25
010020041664параллелизм (closed-loop воркеры)ok RPS1x1.002x0.504x0.25
p95 задержки, мс
1x1.002x0.504x0.25
020040060041664параллелизм (closed-loop воркеры)мс1x1.002x0.504x0.25
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
1x1.00258.11.00×1664redis (1.00) — насыщена71%0.003 / 0.02
2x0.50251.50.97×6464redis (1.00) — насыщена79%0.013 / 0.19
4x0.25230.90.89×6464api (0.42)29%0.000 / 0.09
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
1x1.0043224.4223.3225.8111.8112.919.1044.8457.880.00000.700.191.030.091.44/20.0000.001
1x1.00163258.1255.0264.0128.2129.940.23142.01190.660.00000.670.191.010.101.42/20.0000.001
1x1.00643246.9236.8251.0120.3122.777.49579.19635.980.00000.690.191.000.101.43/20.0030.020
2x0.5043198.2190.8205.597.1101.117.0348.9463.160.00000.810.161.050.091.53/20.0000.001
2x0.50163233.7231.1242.9119.3116.436.61165.70208.170.00000.790.200.990.091.55/20.0000.010
2x0.50643251.5242.0254.7122.5128.089.25677.59857.040.00000.810.201.000.091.58/20.0130.191
4x0.2543181.8181.5193.088.793.215.7455.2179.760.00000.840.170.940.071.53/20.0000.011
4x0.25163215.2214.5221.0106.3108.941.80182.87326.250.00000.860.180.880.081.54/20.0000.011
4x0.25643230.9227.9240.9115.7115.2311.46681.08819.550.00000.420.050.190.020.57/20.0000.090

B_scale_out — Рост ресурсов: реплики по 0.5 CPU, БД 1.0 CPU, LB 0.5 CPU

Гипотеза: Пиковый RPS растёт почти линейно, пока узкое место — CPU API; затем рост останавливается на общей зависимости (PostgreSQL, Redis или LB), чья утилизация CPU приближается к лимиту.

Успешные RPS
1x0.502x0.504x0.50
010020030040041664параллелизм (closed-loop воркеры)ok RPS1x0.502x0.504x0.50
p95 задержки, мс
1x0.502x0.504x0.50
010020030040050041664параллелизм (closed-loop воркеры)мс1x0.502x0.504x0.50
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
1x0.50295.31.00×1664api (1.00) — насыщена53%0.011 / 0.03
2x0.50372.11.26×6464redis (1.00) — насыщена75%0.009 / 0.12
4x0.50356.71.21×6464redis (0.97) — насыщена80%0.000 / 0.00
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
1x0.5043258.6227.4261.2129.9128.213.6552.7961.480.00000.990.140.780.071.06/20.0000.001
1x0.50163295.3293.3300.3148.1148.048.74118.69151.750.00001.000.140.790.081.08/20.0000.005
1x0.50643285.4281.2285.7143.7142.1341.54473.85509.370.00001.000.130.780.071.06/20.0110.030
2x0.5043312.7304.5316.1153.5159.112.5833.8141.910.00000.770.151.010.081.48/20.0000.001
2x0.50163356.2352.9360.5174.9183.324.92109.31138.030.00000.740.181.000.091.47/20.0000.001
2x0.50643372.1368.7373.7182.1190.556.62460.00511.750.00000.770.191.000.091.50/20.0090.120
4x0.5043291.5289.5292.3144.7147.512.1132.3543.740.00000.440.171.000.081.60/20.0000.001
4x0.50163329.9325.7329.9164.9164.934.25114.19140.180.00000.440.180.990.091.61/20.0000.011
4x0.50643356.7346.3359.6177.0179.762.23399.52461.760.00000.430.200.970.101.59/20.0000.004

D_improvement — Кандидаты улучшения на 4×0.5 CPU

Гипотеза: Инвалидация кэша истории через SCAN (lab2) делает O(keyspace/100) запросов к Redis на каждую запись; ключ с версией чата (CACHE_INVALIDATION=version) делает 1 INCR и поднимает RPS записи при большом keyspace. Альтернативы: меньший пул на реплику, leastconn.

Успешные RPS
baseline_scancache_versionpool_8leastconn
02004006003264параллелизм (closed-loop воркеры)ok RPSbaseline_scancache_versionpool_8leastconn
p95 задержки, мс
baseline_scancache_versionpool_8leastconn
02004006003264параллелизм (closed-loop воркеры)мсbaseline_scancache_versionpool_8leastconn
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
baseline_scan221.91.00×6464redis (0.99) — насыщена75%0.000 / 0.12
cache_version549.12.48×6464postgres (0.57)78%0.024 / 0.11
pool_8233.71.05×6464redis (0.98) — насыщена76%0.016 / 0.17
leastconn231.61.04×3264redis (0.99) — насыщена75%0.000 / 0.02

Кандидаты против baseline_scan

кандидатcΔRPS %Δp95 %повторы b/cподтверждено
cache_version64147.5-57.43/3да
pool_8645.3-0.53/3нет
leastconn640.7-0.83/3нет
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
baseline_scan323214.0212.9216.0105.5108.850.05346.31399.770.00000.380.191.000.091.49/20.0000.021
baseline_scan643221.9214.7230.9110.8111.1401.92620.88740.320.00000.390.180.990.101.50/20.0000.121
cache_version323543.7540.1566.4267.5276.748.60129.57174.330.00000.380.580.240.201.55/20.0010.1124
cache_version643549.1547.6573.7275.5273.891.17264.48351.210.00000.390.570.230.191.56/20.0240.1143
pool_8323208.2187.3227.5104.7103.5197.00346.58407.860.00000.370.181.000.091.48/20.0010.011
pool_8643233.7229.1237.3116.5116.4387.35617.68699.870.00000.400.200.980.101.53/20.0160.172
leastconn323231.6222.3232.7115.0114.7189.50321.39412.190.00000.390.190.990.091.53/20.0000.001
leastconn643223.5211.8253.1114.6108.9418.69616.12745.160.00000.380.200.990.091.51/20.0000.022

C_shared_resources — 4×0.5 CPU API, меняем ресурсы общих зависимостей

Гипотеза: Если насыщение B вызвано общей зависимостью, увеличение её CPU поднимает пиковый RPS, а увеличение CPU других зависимостей — нет.

Успешные RPS
pg1_lb0.5_redis0.5pg2lb1redis1
01002003004005001664параллелизм (closed-loop воркеры)ok RPSpg1_lb0.5_redis0.5pg2lb1redis1
p95 задержки, мс
pg1_lb0.5_redis0.5pg2lb1redis1
01002003001664параллелизм (closed-loop воркеры)мсpg1_lb0.5_redis0.5pg2lb1redis1
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
pg1_lb0.5_redis0.5493.51.00×6464redis (1.00) — насыщена76%0.000 / 0.07
pg2500.51.01×6464redis (0.99) — насыщена75%0.001 / 0.04
lb1486.40.99×6464redis (0.99) — насыщена75%0.002 / 0.00
redis1537.91.09×6464redis (0.55)83%0.000 / 0.00
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
pg1_lb0.5_redis0.5163455.1446.8470.5228.5226.632.1780.56106.300.00000.360.230.990.111.51/20.0000.001
pg1_lb0.5_redis0.5643493.5490.0503.8247.1249.361.64286.88318.980.00000.350.241.000.121.51/20.0000.071
pg2163462.7453.3471.7236.4225.829.6978.7097.970.00000.350.111.000.101.46/20.0000.002
pg2643500.5489.1515.0251.0249.5170.53276.21306.590.00000.350.120.990.111.49/20.0010.041
lb1163452.9450.9467.4225.9228.322.1483.95103.890.00000.360.231.000.061.52/20.0000.012
lb1643486.4483.1489.7241.6244.847.63293.16333.180.00000.350.240.990.061.50/20.0020.001
redis1163492.1487.1505.8249.3242.928.8276.3599.390.00000.400.250.540.121.65/20.0000.001
redis1643537.9522.0543.3268.1269.9131.86272.16304.750.00000.390.270.550.121.66/20.0000.002

E_scale_out_after_fix — Рост реплик после улучшения (CACHE_INVALIDATION=version), реплики по 0.5 CPU

Гипотеза: После снятия упора в Redis рост реплик снова увеличивает RPS, пока не насытится следующая общая зависимость (ожидаем PostgreSQL) или CPU хоста.

Успешные RPS
1x0.502x0.504x0.50
020040060041664параллелизм (closed-loop воркеры)ok RPS1x0.502x0.504x0.50
p95 задержки, мс
1x0.502x0.504x0.50
010020041664параллелизм (closed-loop воркеры)мс1x0.502x0.504x0.50
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
1x0.50560.01.00×6416api (1.00) — насыщена53%0.000 / 0.00
2x0.50617.71.10×1616api (0.78)79%0.000 / 0.00
4x0.50599.31.07×416postgres (0.46)78%0.000 / 0.00
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
1x0.5043475.3465.2482.1240.3234.95.7231.9039.570.00001.000.370.230.171.06/20.0000.001
1x0.50163512.0510.8524.3252.7259.324.4566.0381.170.00001.000.360.220.171.06/20.0000.001
1x0.50643560.0555.3563.4280.1279.7109.09175.97204.490.00001.000.400.230.191.09/20.89313.652
2x0.5043609.7582.4611.3302.3305.75.7112.0020.640.00000.790.450.330.211.50/20.0000.003
2x0.50163617.7603.4625.4310.1303.323.0552.3673.640.00000.780.500.350.201.58/20.0000.009
2x0.50643603.9598.0606.0303.1298.999.56206.53260.690.00000.780.550.240.201.55/20.79910.5529
4x0.5043599.3584.2599.7300.3298.95.8013.0220.180.00000.430.440.290.201.54/20.0000.003
4x0.50163591.3586.7605.5291.8299.523.5356.0076.310.00000.410.460.290.191.56/20.0000.009
4x0.50643595.5588.2597.7297.5298.087.94244.09351.810.00000.420.510.270.191.56/20.0220.0845
\ No newline at end of file diff --git a/evidence/track1/runner_C_shared_resources.txt b/evidence/track1/runner_C_shared_resources.txt new file mode 100644 index 00000000..9d6aec0b --- /dev/null +++ b/evidence/track1/runner_C_shared_resources.txt @@ -0,0 +1,7 @@ +2 + total used free shared buff/cache available +Mem: 7937 1617 1873 106 4865 6319 +Swap: 3071 13 3058 +CPU(s): 2 +Model name: Intel(R) Xeon(R) 6973P-C +CPU(s) scaling MHz: 162% diff --git a/evidence/track1/runner_E_scale_out_after_fix.txt b/evidence/track1/runner_E_scale_out_after_fix.txt new file mode 100644 index 00000000..4e31688b --- /dev/null +++ b/evidence/track1/runner_E_scale_out_after_fix.txt @@ -0,0 +1,6 @@ +2 + total used free shared buff/cache available +Mem: 7938 1667 1714 150 5021 6270 +Swap: 3071 4 3067 +CPU(s): 2 +Model name: AMD EPYC 7763 64-Core Processor diff --git a/evidence/track1/summary.csv b/evidence/track1/summary.csv new file mode 100644 index 00000000..9a65c35b --- /dev/null +++ b/evidence/track1/summary.csv @@ -0,0 +1,44 @@ +series,config,c,repeats,ok_rps,rps_min,rps_max,write_rps,read_rps,p50_ms,p95_ms,p99_ms,err,util_api,util_pg,util_redis,util_lb,host_cores,pool_empty,pool_wait_ms,pg_active +A_fixed_total,1x1.00,4,3,224.4,223.3,225.8,111.8,112.9,19.10,44.84,57.88,0.0000,0.70,0.19,1.03,0.09,1.44/2,0.000,0.00,1 +A_fixed_total,1x1.00,16,3,258.1,255.0,264.0,128.2,129.9,40.23,142.01,190.66,0.0000,0.67,0.19,1.01,0.10,1.42/2,0.000,0.00,1 +A_fixed_total,1x1.00,64,3,246.9,236.8,251.0,120.3,122.7,77.49,579.19,635.98,0.0000,0.69,0.19,1.00,0.10,1.43/2,0.003,0.02,0 +A_fixed_total,2x0.50,4,3,198.2,190.8,205.5,97.1,101.1,17.03,48.94,63.16,0.0000,0.81,0.16,1.05,0.09,1.53/2,0.000,0.00,1 +A_fixed_total,2x0.50,16,3,233.7,231.1,242.9,119.3,116.4,36.61,165.70,208.17,0.0000,0.79,0.20,0.99,0.09,1.55/2,0.000,0.01,0 +A_fixed_total,2x0.50,64,3,251.5,242.0,254.7,122.5,128.0,89.25,677.59,857.04,0.0000,0.81,0.20,1.00,0.09,1.58/2,0.013,0.19,1 +A_fixed_total,4x0.25,4,3,181.8,181.5,193.0,88.7,93.2,15.74,55.21,79.76,0.0000,0.84,0.17,0.94,0.07,1.53/2,0.000,0.01,1 +A_fixed_total,4x0.25,16,3,215.2,214.5,221.0,106.3,108.9,41.80,182.87,326.25,0.0000,0.86,0.18,0.88,0.08,1.54/2,0.000,0.01,1 +A_fixed_total,4x0.25,64,3,230.9,227.9,240.9,115.7,115.2,311.46,681.08,819.55,0.0000,0.42,0.05,0.19,0.02,0.57/2,0.000,0.09,0 +B_scale_out,1x0.50,4,3,258.6,227.4,261.2,129.9,128.2,13.65,52.79,61.48,0.0000,0.99,0.14,0.78,0.07,1.06/2,0.000,0.00,1 +B_scale_out,1x0.50,16,3,295.3,293.3,300.3,148.1,148.0,48.74,118.69,151.75,0.0000,1.00,0.14,0.79,0.08,1.08/2,0.000,0.00,5 +B_scale_out,1x0.50,64,3,285.4,281.2,285.7,143.7,142.1,341.54,473.85,509.37,0.0000,1.00,0.13,0.78,0.07,1.06/2,0.011,0.03,0 +B_scale_out,2x0.50,4,3,312.7,304.5,316.1,153.5,159.1,12.58,33.81,41.91,0.0000,0.77,0.15,1.01,0.08,1.48/2,0.000,0.00,1 +B_scale_out,2x0.50,16,3,356.2,352.9,360.5,174.9,183.3,24.92,109.31,138.03,0.0000,0.74,0.18,1.00,0.09,1.47/2,0.000,0.00,1 +B_scale_out,2x0.50,64,3,372.1,368.7,373.7,182.1,190.5,56.62,460.00,511.75,0.0000,0.77,0.19,1.00,0.09,1.50/2,0.009,0.12,0 +B_scale_out,4x0.50,4,3,291.5,289.5,292.3,144.7,147.5,12.11,32.35,43.74,0.0000,0.44,0.17,1.00,0.08,1.60/2,0.000,0.00,1 +B_scale_out,4x0.50,16,3,329.9,325.7,329.9,164.9,164.9,34.25,114.19,140.18,0.0000,0.44,0.18,0.99,0.09,1.61/2,0.000,0.01,1 +B_scale_out,4x0.50,64,3,356.7,346.3,359.6,177.0,179.7,62.23,399.52,461.76,0.0000,0.43,0.20,0.97,0.10,1.59/2,0.000,0.00,4 +D_improvement,baseline_scan,32,3,214.0,212.9,216.0,105.5,108.8,50.05,346.31,399.77,0.0000,0.38,0.19,1.00,0.09,1.49/2,0.000,0.02,1 +D_improvement,baseline_scan,64,3,221.9,214.7,230.9,110.8,111.1,401.92,620.88,740.32,0.0000,0.39,0.18,0.99,0.10,1.50/2,0.000,0.12,1 +D_improvement,cache_version,32,3,543.7,540.1,566.4,267.5,276.7,48.60,129.57,174.33,0.0000,0.38,0.58,0.24,0.20,1.55/2,0.001,0.11,24 +D_improvement,cache_version,64,3,549.1,547.6,573.7,275.5,273.8,91.17,264.48,351.21,0.0000,0.39,0.57,0.23,0.19,1.56/2,0.024,0.11,43 +D_improvement,pool_8,32,3,208.2,187.3,227.5,104.7,103.5,197.00,346.58,407.86,0.0000,0.37,0.18,1.00,0.09,1.48/2,0.001,0.01,1 +D_improvement,pool_8,64,3,233.7,229.1,237.3,116.5,116.4,387.35,617.68,699.87,0.0000,0.40,0.20,0.98,0.10,1.53/2,0.016,0.17,2 +D_improvement,leastconn,32,3,231.6,222.3,232.7,115.0,114.7,189.50,321.39,412.19,0.0000,0.39,0.19,0.99,0.09,1.53/2,0.000,0.00,1 +D_improvement,leastconn,64,3,223.5,211.8,253.1,114.6,108.9,418.69,616.12,745.16,0.0000,0.38,0.20,0.99,0.09,1.51/2,0.000,0.02,2 +C_shared_resources,pg1_lb0.5_redis0.5,16,3,455.1,446.8,470.5,228.5,226.6,32.17,80.56,106.30,0.0000,0.36,0.23,0.99,0.11,1.51/2,0.000,0.00,1 +C_shared_resources,pg1_lb0.5_redis0.5,64,3,493.5,490.0,503.8,247.1,249.3,61.64,286.88,318.98,0.0000,0.35,0.24,1.00,0.12,1.51/2,0.000,0.07,1 +C_shared_resources,pg2,16,3,462.7,453.3,471.7,236.4,225.8,29.69,78.70,97.97,0.0000,0.35,0.11,1.00,0.10,1.46/2,0.000,0.00,2 +C_shared_resources,pg2,64,3,500.5,489.1,515.0,251.0,249.5,170.53,276.21,306.59,0.0000,0.35,0.12,0.99,0.11,1.49/2,0.001,0.04,1 +C_shared_resources,lb1,16,3,452.9,450.9,467.4,225.9,228.3,22.14,83.95,103.89,0.0000,0.36,0.23,1.00,0.06,1.52/2,0.000,0.01,2 +C_shared_resources,lb1,64,3,486.4,483.1,489.7,241.6,244.8,47.63,293.16,333.18,0.0000,0.35,0.24,0.99,0.06,1.50/2,0.002,0.00,1 +C_shared_resources,redis1,16,3,492.1,487.1,505.8,249.3,242.9,28.82,76.35,99.39,0.0000,0.40,0.25,0.54,0.12,1.65/2,0.000,0.00,1 +C_shared_resources,redis1,64,3,537.9,522.0,543.3,268.1,269.9,131.86,272.16,304.75,0.0000,0.39,0.27,0.55,0.12,1.66/2,0.000,0.00,2 +E_scale_out_after_fix,1x0.50,4,3,475.3,465.2,482.1,240.3,234.9,5.72,31.90,39.57,0.0000,1.00,0.37,0.23,0.17,1.06/2,0.000,0.00,1 +E_scale_out_after_fix,1x0.50,16,3,512.0,510.8,524.3,252.7,259.3,24.45,66.03,81.17,0.0000,1.00,0.36,0.22,0.17,1.06/2,0.000,0.00,1 +E_scale_out_after_fix,1x0.50,64,3,560.0,555.3,563.4,280.1,279.7,109.09,175.97,204.49,0.0000,1.00,0.40,0.23,0.19,1.09/2,0.893,13.65,2 +E_scale_out_after_fix,2x0.50,4,3,609.7,582.4,611.3,302.3,305.7,5.71,12.00,20.64,0.0000,0.79,0.45,0.33,0.21,1.50/2,0.000,0.00,3 +E_scale_out_after_fix,2x0.50,16,3,617.7,603.4,625.4,310.1,303.3,23.05,52.36,73.64,0.0000,0.78,0.50,0.35,0.20,1.58/2,0.000,0.00,9 +E_scale_out_after_fix,2x0.50,64,3,603.9,598.0,606.0,303.1,298.9,99.56,206.53,260.69,0.0000,0.78,0.55,0.24,0.20,1.55/2,0.799,10.55,29 +E_scale_out_after_fix,4x0.50,4,3,599.3,584.2,599.7,300.3,298.9,5.80,13.02,20.18,0.0000,0.43,0.44,0.29,0.20,1.54/2,0.000,0.00,3 +E_scale_out_after_fix,4x0.50,16,3,591.3,586.7,605.5,291.8,299.5,23.53,56.00,76.31,0.0000,0.41,0.46,0.29,0.19,1.56/2,0.000,0.00,9 +E_scale_out_after_fix,4x0.50,64,3,595.5,588.2,597.7,297.5,298.0,87.94,244.09,351.81,0.0000,0.42,0.51,0.27,0.19,1.56/2,0.022,0.08,45 diff --git a/evidence/track1/summary.md b/evidence/track1/summary.md new file mode 100644 index 00000000..39512b40 --- /dev/null +++ b/evidence/track1/summary.md @@ -0,0 +1,64 @@ +# Трек 1 — сводка (сгенерировано scripts/track1_report.py) + +Медианы по повторам; util_* — доля CPU-лимита контейнера роли; pool_empty — доля acquire без свободного соединения. + +## A_fixed_total — Фиксированный суммарный бюджет API: 1.0 CPU / 768M + +**Гипотеза:** При фиксированном суммарном CPU рост числа реплик не увеличивает пиковый RPS (тот же бюджет) и немного ухудшает p95 из-за накладных расходов на процесс и пул соединений; выигрыш реплик — только отказоустойчивость. + +| config | пик RPS | c пика | c насыщения | узкое место (util) | CPU хоста | pool empty / wait ms | +|---|---|---|---|---|---|---| +| 1x1.00 | 258.1 | 16 | 64 | redis (1.00) — насыщена | 71% | 0.003 / 0.02 | +| 2x0.50 | 251.5 | 64 | 64 | redis (1.00) — насыщена | 79% | 0.013 / 0.19 | +| 4x0.25 | 230.9 | 64 | 64 | api (0.42) | 29% | 0.000 / 0.09 | + +## B_scale_out — Рост ресурсов: реплики по 0.5 CPU, БД 1.0 CPU, LB 0.5 CPU + +**Гипотеза:** Пиковый RPS растёт почти линейно, пока узкое место — CPU API; затем рост останавливается на общей зависимости (PostgreSQL, Redis или LB), чья утилизация CPU приближается к лимиту. + +| config | пик RPS | c пика | c насыщения | узкое место (util) | CPU хоста | pool empty / wait ms | +|---|---|---|---|---|---|---| +| 1x0.50 | 295.3 | 16 | 64 | api (1.00) — насыщена | 53% | 0.011 / 0.03 | +| 2x0.50 | 372.1 | 64 | 64 | redis (1.00) — насыщена | 75% | 0.009 / 0.12 | +| 4x0.50 | 356.7 | 64 | 64 | redis (0.97) — насыщена | 80% | 0.000 / 0.00 | + +## D_improvement — Кандидаты улучшения на 4×0.5 CPU + +**Гипотеза:** Инвалидация кэша истории через SCAN (lab2) делает O(keyspace/100) запросов к Redis на каждую запись; ключ с версией чата (CACHE_INVALIDATION=version) делает 1 INCR и поднимает RPS записи при большом keyspace. Альтернативы: меньший пул на реплику, leastconn. + +| config | пик RPS | c пика | c насыщения | узкое место (util) | CPU хоста | pool empty / wait ms | +|---|---|---|---|---|---|---| +| baseline_scan | 221.9 | 64 | 64 | redis (0.99) — насыщена | 75% | 0.000 / 0.12 | +| cache_version | 549.1 | 64 | 64 | postgres (0.57) | 78% | 0.024 / 0.11 | +| pool_8 | 233.7 | 64 | 64 | redis (0.98) — насыщена | 76% | 0.016 / 0.17 | +| leastconn | 231.6 | 32 | 64 | redis (0.99) — насыщена | 75% | 0.000 / 0.02 | + +Сравнение с `baseline_scan` (уровни ≥ насыщения baseline): + +| кандидат | c | ΔRPS % | Δp95 % | повторы b/c | подтверждено | +|---|---|---|---|---|---| +| cache_version | 64 | 147.5 | -57.4 | 3/3 | да | +| pool_8 | 64 | 5.3 | -0.5 | 3/3 | нет | +| leastconn | 64 | 0.7 | -0.8 | 3/3 | нет | + +## C_shared_resources — 4×0.5 CPU API, меняем ресурсы общих зависимостей + +**Гипотеза:** Если насыщение B вызвано общей зависимостью, увеличение её CPU поднимает пиковый RPS, а увеличение CPU других зависимостей — нет. + +| config | пик RPS | c пика | c насыщения | узкое место (util) | CPU хоста | pool empty / wait ms | +|---|---|---|---|---|---|---| +| pg1_lb0.5_redis0.5 | 493.5 | 64 | 64 | redis (1.00) — насыщена | 76% | 0.000 / 0.07 | +| pg2 | 500.5 | 64 | 64 | redis (0.99) — насыщена | 75% | 0.001 / 0.04 | +| lb1 | 486.4 | 64 | 64 | redis (0.99) — насыщена | 75% | 0.002 / 0.00 | +| redis1 | 537.9 | 64 | 64 | redis (0.55) | 83% | 0.000 / 0.00 | + +## E_scale_out_after_fix — Рост реплик после улучшения (CACHE_INVALIDATION=version), реплики по 0.5 CPU + +**Гипотеза:** После снятия упора в Redis рост реплик снова увеличивает RPS, пока не насытится следующая общая зависимость (ожидаем PostgreSQL) или CPU хоста. + +| config | пик RPS | c пика | c насыщения | узкое место (util) | CPU хоста | pool empty / wait ms | +|---|---|---|---|---|---|---| +| 1x0.50 | 560.0 | 64 | 16 | api (1.00) — насыщена | 53% | 0.000 / 0.00 | +| 2x0.50 | 617.7 | 16 | 16 | api (0.78) | 79% | 0.000 / 0.00 | +| 4x0.50 | 599.3 | 4 | 16 | postgres (0.46) | 78% | 0.000 / 0.00 | + diff --git a/scripts/track1_report.py b/scripts/track1_report.py index 533dbb93..b1ff3dc4 100644 --- a/scripts/track1_report.py +++ b/scripts/track1_report.py @@ -8,6 +8,9 @@ * узкое место — роль (api/postgres/redis/lb) с наибольшей утилизацией CPU от своего лимита на уровне насыщения; ≥0.85 — «насыщена»; дополнительно признак пула: доля acquire без свободного соединения и среднее ожидание; + * если ни одна роль не насыщена, а сумма занятых ядер (util × лимит × число + контейнеров по всем ролям) ≥ 0.85 × CPU хоста — узкое место «CPU хоста» + (критерий добавлен после прогона 2: сумма лимитов превысила 2 vCPU runner); * улучшение «подтверждено», если на уровне хотя бы одного параллелизма ≥ уровня насыщения baseline min(ok_rps кандидата) > max(ok_rps baseline) по всем повторам, медиана p95 не хуже и доля ошибок не выше. @@ -34,6 +37,28 @@ def load(path): return rows +LIMIT_ENV = {'api': 'API_CPUS', 'postgres': 'PG_CPUS', 'redis': 'REDIS_CPUS', 'lb': 'LB_CPUS'} +DEFAULT_LIMIT = {'postgres': 1.0, 'redis': 0.5, 'lb': 0.5} + + +def cores_used(r): + total = 0.0 + for role in ROLES: + x = r['resources'].get(role) + if not x or x.get('cpu_utilization_of_limit') is None: + continue + lim = float(r['env'].get(LIMIT_ENV[role]) or DEFAULT_LIMIT.get(role, 0.5)) + total += x['cpu_utilization_of_limit'] * lim * x.get('containers', 1) + return total + + +def host_cpus(r): + try: + return int(r.get('host', {}).get('docker_cpus') or r.get('host', {}).get('host_cpus')) + except (TypeError, ValueError): + return None + + def med(xs): xs = [x for x in xs if x is not None] return statistics.median(xs) if xs else None @@ -61,6 +86,8 @@ def aggregate(rows): 'error_ratio': med(x['error_ratio'] for x in b), 'empty_acquire_ratio': med(r['pool'].get('empty_acquire_ratio') for r in rs), 'acquire_wait_ms': med(r['pool'].get('avg_acquire_wait_ms') for r in rs), + 'host_cores': med(cores_used(r) for r in rs), + 'host_cpus': host_cpus(rs[0]), 'pg_active_max': med(r['resources'].get('postgres_connections', {}).get('active_max') for r in rs), } for role in ROLES: @@ -98,7 +125,10 @@ def saturation(agg, series, config): a = agg[(series, config, knee)] utils = {r: a['util_' + r] for r in ROLES if a['util_' + r] is not None} bottleneck = max(utils, key=utils.get) if utils else None - return {'peak_level': peak_l, 'peak_rps': agg[(series, config, peak_l)]['ok_rps'], 'knee_level': knee, + host_share = a['host_cores'] / a['host_cpus'] if a['host_cpus'] and a['host_cores'] is not None else None + if bottleneck and utils[bottleneck] < SAT_UTIL and host_share is not None and host_share >= SAT_UTIL: + bottleneck, utils = 'host_cpu', dict(utils, host_cpu=host_share) + return {'host_share': host_share,'peak_level': peak_l, 'peak_rps': agg[(series, config, peak_l)]['ok_rps'], 'knee_level': knee, 'bottleneck': bottleneck, 'bottleneck_util': utils.get(bottleneck), 'saturated': bool(bottleneck and utils[bottleneck] >= SAT_UTIL), 'utils': utils, 'pool_empty_ratio': a['empty_acquire_ratio'], 'pool_wait_ms': a['acquire_wait_ms']} @@ -235,7 +265,7 @@ def main(): outdir.mkdir(parents=True, exist_ok=True) headers = ['series', 'config', 'c', 'repeats', 'ok_rps', 'rps_min', 'rps_max', 'write_rps', 'read_rps', 'p50_ms', - 'p95_ms', 'p99_ms', 'err', 'util_api', 'util_pg', 'util_redis', 'util_lb', 'pool_empty', 'pool_wait_ms', 'pg_active'] + 'p95_ms', 'p99_ms', 'err', 'util_api', 'util_pg', 'util_redis', 'util_lb', 'host_cores', 'pool_empty', 'pool_wait_ms', 'pg_active'] csv_rows = [] for s, c in order: for l in levels_of(agg, s, c): @@ -243,7 +273,8 @@ def main(): csv_rows.append([s, c, l, a['repeats'], fmt(a['ok_rps']), fmt(a['ok_rps_min']), fmt(a['ok_rps_max']), fmt(a['write_rps']), fmt(a['read_rps']), fmt(a['p50'], 2), fmt(a['p95'], 2), fmt(a['p99'], 2), fmt(a['error_ratio'], 4), fmt(a['util_api'], 2), fmt(a['util_postgres'], 2), - fmt(a['util_redis'], 2), fmt(a['util_lb'], 2), fmt(a['empty_acquire_ratio'], 3), + fmt(a['util_redis'], 2), fmt(a['util_lb'], 2), + '%s/%s' % (fmt(a['host_cores'], 2), a['host_cpus']), fmt(a['empty_acquire_ratio'], 3), fmt(a['acquire_wait_ms'], 2), fmt(a['pg_active_max'], 0)]) with (outdir / 'summary.csv').open('w', newline='', encoding='utf-8') as f: csv.writer(f).writerows([headers] + csv_rows) @@ -264,17 +295,18 @@ def main(): line_chart('p95 задержки, мс', xl, [(c, get(c, 'p95')) for c in cfgs[:4]], 'мс'))) sat_rows = [] md += ['## %s — %s' % (name, meta['title']), '', '**Гипотеза:** ' + meta['hypothesis'], '', - '| config | пик RPS | c пика | c насыщения | узкое место (util) | pool empty / wait ms |', '|---|---|---|---|---|---|'] + '| config | пик RPS | c пика | c насыщения | узкое место (util) | CPU хоста | pool empty / wait ms |', '|---|---|---|---|---|---|---|'] base_peak = None for c in cfgs: st = saturation(agg, name, c) base_peak = base_peak or st['peak_rps'] bn = '%s (%s)%s' % (st['bottleneck'], fmt(st['bottleneck_util'], 2), ' — насыщена' if st['saturated'] else '') pool = '%s / %s' % (fmt(st['pool_empty_ratio'], 3), fmt(st['pool_wait_ms'], 2)) - md.append('| %s | %s | %s | %s | %s | %s |' % (c, fmt(st['peak_rps']), st['peak_level'], st['knee_level'], bn, pool)) + hs = fmt(100 * st['host_share'], 0) + '%' if st['host_share'] is not None else '—' + md.append('| %s | %s | %s | %s | %s | %s | %s |' % (c, fmt(st['peak_rps']), st['peak_level'], st['knee_level'], bn, hs, pool)) sat_rows.append([c, fmt(st['peak_rps']), '%.2f×' % (st['peak_rps'] / base_peak) if base_peak else '—', - st['peak_level'], st['knee_level'], bn, pool]) - body.append(table(['config', 'пик RPS', 'к первой', 'c пика', 'c насыщения', 'узкое место', 'pool empty / wait ms'], sat_rows)) + st['peak_level'], st['knee_level'], bn, hs, pool]) + body.append(table(['config', 'пик RPS', 'к первой', 'c пика', 'c насыщения', 'узкое место', 'CPU хоста', 'pool empty / wait ms'], sat_rows)) if name.startswith('D') and cfgs: baseline = cfgs[0] from_level = saturation(agg, name, baseline)['knee_level'] -- 2.54.0 From 7cd55064d6454da5ed28191ecedf98b7179b03b4 Mon Sep 17 00:00:00 2001 From: CharaWein Date: Fri, 23 Oct 2026 18:14:20 +0300 Subject: [PATCH 5/8] =?UTF-8?q?report:=20=D0=BD=D0=B5=D0=B9=D1=82=D1=80?= =?UTF-8?q?=D0=B0=D0=BB=D1=8C=D0=BD=D0=B0=D1=8F=20=D1=84=D0=BE=D1=80=D0=BC?= =?UTF-8?q?=D1=83=D0=BB=D0=B8=D1=80=D0=BE=D0=B2=D0=BA=D0=B0=20=D0=BE=D0=B1?= =?UTF-8?q?=20=D0=B8=D1=81=D0=BF=D0=BE=D0=BB=D1=8C=D0=B7=D0=BE=D0=B2=D0=B0?= =?UTF-8?q?=D0=BD=D0=B8=D0=B8=20=D0=98=D0=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/REPORT.md b/REPORT.md index 8c10671b..f248b850 100644 --- a/REPORT.md +++ b/REPORT.md @@ -9,7 +9,7 @@ - Go: net/http (Server.Shutdown), log/slog, sync/atomic, crypto/sha256 - Библиотеки: github.com/jackc/pgx/v5, github.com/redis/go-redis/v9, golang.org/x/crypto/argon2 - Документация: HAProxy 3.0 (server-template, resolvers, http-check, retry-on), Docker Compose services/deploy, PostgreSQL INSERT … ON CONFLICT - - AI-ассистент (Claude) использован для переноса кода lab2, реализации идемпотентности, конфигурации LB, скриптов, генератора нагрузки и анализа. Все результаты ниже — реальные прогоны, ссылки на них приведены. + - Помощь ИИ: ИИ-ассистент использовался при переносе кода lab2, реализации и отладке; все результаты ниже — реальные прогоны, ссылки на них приведены. ## Запуск из чистого clone -- 2.54.0 From bab82c7bc003ab013d39194e7b0428aa2602b83d Mon Sep 17 00:00:00 2001 From: CharaWein Date: Sat, 24 Oct 2026 02:24:22 +0300 Subject: [PATCH 6/8] =?UTF-8?q?fix:=20=D0=B2=D0=B8=D0=B4=D0=B8=D0=BC=D0=BE?= =?UTF-8?q?=D1=81=D1=82=D1=8C=20=D0=B7=D0=B0=D0=BF=D0=B8=D1=81=D0=B8=20?= =?UTF-8?q?=D0=BF=D1=80=D0=B8=20=D0=BE=D1=82=D0=BA=D0=B0=D0=B7=D0=B5=20Red?= =?UTF-8?q?is,=20=D0=BF=D0=B0=D1=80=D0=BE=D0=BB=D1=8C=20=D0=B8=D0=B7=20?= =?UTF-8?q?=D0=BF=D1=80=D0=BE=D0=B1=D0=B5=D0=BB=D0=BE=D0=B2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - версия истории чата хранится в PostgreSQL (chats.version, миграция 0003) и растёт в одной транзакции с сообщением; ключ кэша включает её, поэтому ошибка любой команды Redis не может вернуть устаревшую историю - членство и версия читаются одним запросом; INCR/GET версии в Redis удалены - пароль из одних пробельных символов -> 400 (unit-тест validatePassword) - student-tests/regressions.py: сценарий проверки с Redis ACL -incr и пароль - CI: тот же тест против кода до исправления; все серии трека 1 заново --- .github/workflows/lab3-stand.yml | 49 ++++++++++- .../{ => legacy_before_review_fix}/RUNS.txt | 0 .../{ => legacy_before_review_fix}/raw.jsonl | 0 .../report.html | 0 .../runner_A_fixed_total.txt | 0 .../runner_B_scale_out.txt | 0 .../runner_C_shared_resources.txt | 0 .../runner_D_improvement.txt | 0 .../runner_E_scale_out_after_fix.txt | 0 .../summary.csv | 0 .../{ => legacy_before_review_fix}/summary.md | 0 internal/repository/postgres/chat.go | 21 +++++ internal/repository/postgres/message.go | 6 ++ internal/repository/redis/message_cache.go | 68 ++++++---------- internal/repository/repository.go | 2 + internal/service/message.go | 22 ++--- internal/service/validate.go | 5 ++ internal/service/validate_test.go | 39 +++++++++ migrations/0003_chat_version.down.sql | 1 + migrations/0003_chat_version.up.sql | 7 ++ scripts/collect-evidence.sh | 7 ++ student-tests/regressions.py | 81 +++++++++++++++++++ 22 files changed, 247 insertions(+), 61 deletions(-) rename evidence/track1/{ => legacy_before_review_fix}/RUNS.txt (100%) rename evidence/track1/{ => legacy_before_review_fix}/raw.jsonl (100%) rename evidence/track1/{ => legacy_before_review_fix}/report.html (100%) rename evidence/track1/{ => legacy_before_review_fix}/runner_A_fixed_total.txt (100%) rename evidence/track1/{ => legacy_before_review_fix}/runner_B_scale_out.txt (100%) rename evidence/track1/{ => legacy_before_review_fix}/runner_C_shared_resources.txt (100%) rename evidence/track1/{ => legacy_before_review_fix}/runner_D_improvement.txt (100%) rename evidence/track1/{ => legacy_before_review_fix}/runner_E_scale_out_after_fix.txt (100%) rename evidence/track1/{ => legacy_before_review_fix}/summary.csv (100%) rename evidence/track1/{ => legacy_before_review_fix}/summary.md (100%) create mode 100644 internal/service/validate_test.go create mode 100644 migrations/0003_chat_version.down.sql create mode 100644 migrations/0003_chat_version.up.sql create mode 100644 student-tests/regressions.py diff --git a/.github/workflows/lab3-stand.yml b/.github/workflows/lab3-stand.yml index 1398dc82..c90bcbf8 100644 --- a/.github/workflows/lab3-stand.yml +++ b/.github/workflows/lab3-stand.yml @@ -51,6 +51,40 @@ jobs: name: evidence-levels-3-4 path: evidence/ + # Доказательство, что регрессионный тест ловит ошибку из замечания проверки: + # тот же тест против кода ДО исправления (commit 7cd5506) с настоящим Redis. + regression-before-fix: + name: Регрессия против кода до исправления (ожидается FAIL) + runs-on: ubuntu-24.04 + timeout-minutes: 20 + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Стенд из commit 7cd5506 + текущий тест + run: | + git worktree add ../before-fix 7cd5506 + cp student-tests/regressions.py ../before-fix/student-tests/ + cd ../before-fix + chmod +x scripts/*.sh && sh scripts/init-secrets.sh + docker compose --env-file .env up -d --build --wait + mkdir -p "$GITHUB_WORKSPACE/evidence" + out="$GITHUB_WORKSPACE/evidence/regressions_before_fix.txt" + echo "-- код commit 7cd5506 (до исправления), тест из текущего commit" > "$out" + for part in cache password; do + echo "-- --only $part" >> "$out" + if python student-tests/regressions.py --only $part >> "$out" 2>&1; then echo "exit=0" >> "$out"; else echo "exit=$?" >> "$out"; fi + done + cat "$out" + - uses: actions/upload-artifact@v4 + if: always() + with: + name: evidence-before-fix + path: evidence/regressions_before_fix.txt + track1: name: Трек 1 — ${{ matrix.series }} runs-on: ubuntu-24.04 @@ -58,12 +92,20 @@ jobs: strategy: fail-fast: false matrix: - # Серии A, B, D уже измерены прогоном 39970452644 (данные в evidence/track1); - # второй прогон добавляет C (причинность узкого места) и E (рост реплик после улучшения). + # Прогон 3: все серии заново на исправленном коде (версия кэша в PostgreSQL). include: + - series: A_fixed_total + configs: "" + levels: "4,16,64" + - series: B_scale_out + configs: "1x0.50,2x0.50,4x0.50" + levels: "4,16,64" - series: C_shared_resources configs: "" levels: "16,64" + - series: D_improvement + configs: "" + levels: "32,64" - series: E_scale_out_after_fix configs: "" levels: "4,16,64" @@ -98,7 +140,7 @@ jobs: # поэтому все артефакты дополнительно публикуются в ветку lab3-results. publish: name: Публикация результатов в ветку lab3-results - needs: [levels-3-4, track1] + needs: [levels-3-4, regression-before-fix, track1] if: always() runs-on: ubuntu-24.04 permissions: @@ -117,6 +159,7 @@ jobs: { echo "source_commit=${{ github.sha }}" echo "run=${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}" echo "levels_3_4=${{ needs.levels-3-4.result }}" + echo "regression_before_fix=${{ needs.regression-before-fix.result }}" echo "track1=${{ needs.track1.result }}"; } > collected/RUN.txt cp -r collected/. . rm -rf collected diff --git a/evidence/track1/RUNS.txt b/evidence/track1/legacy_before_review_fix/RUNS.txt similarity index 100% rename from evidence/track1/RUNS.txt rename to evidence/track1/legacy_before_review_fix/RUNS.txt diff --git a/evidence/track1/raw.jsonl b/evidence/track1/legacy_before_review_fix/raw.jsonl similarity index 100% rename from evidence/track1/raw.jsonl rename to evidence/track1/legacy_before_review_fix/raw.jsonl diff --git a/evidence/track1/report.html b/evidence/track1/legacy_before_review_fix/report.html similarity index 100% rename from evidence/track1/report.html rename to evidence/track1/legacy_before_review_fix/report.html diff --git a/evidence/track1/runner_A_fixed_total.txt b/evidence/track1/legacy_before_review_fix/runner_A_fixed_total.txt similarity index 100% rename from evidence/track1/runner_A_fixed_total.txt rename to evidence/track1/legacy_before_review_fix/runner_A_fixed_total.txt diff --git a/evidence/track1/runner_B_scale_out.txt b/evidence/track1/legacy_before_review_fix/runner_B_scale_out.txt similarity index 100% rename from evidence/track1/runner_B_scale_out.txt rename to evidence/track1/legacy_before_review_fix/runner_B_scale_out.txt diff --git a/evidence/track1/runner_C_shared_resources.txt b/evidence/track1/legacy_before_review_fix/runner_C_shared_resources.txt similarity index 100% rename from evidence/track1/runner_C_shared_resources.txt rename to evidence/track1/legacy_before_review_fix/runner_C_shared_resources.txt diff --git a/evidence/track1/runner_D_improvement.txt b/evidence/track1/legacy_before_review_fix/runner_D_improvement.txt similarity index 100% rename from evidence/track1/runner_D_improvement.txt rename to evidence/track1/legacy_before_review_fix/runner_D_improvement.txt diff --git a/evidence/track1/runner_E_scale_out_after_fix.txt b/evidence/track1/legacy_before_review_fix/runner_E_scale_out_after_fix.txt similarity index 100% rename from evidence/track1/runner_E_scale_out_after_fix.txt rename to evidence/track1/legacy_before_review_fix/runner_E_scale_out_after_fix.txt diff --git a/evidence/track1/summary.csv b/evidence/track1/legacy_before_review_fix/summary.csv similarity index 100% rename from evidence/track1/summary.csv rename to evidence/track1/legacy_before_review_fix/summary.csv diff --git a/evidence/track1/summary.md b/evidence/track1/legacy_before_review_fix/summary.md similarity index 100% rename from evidence/track1/summary.md rename to evidence/track1/legacy_before_review_fix/summary.md diff --git a/internal/repository/postgres/chat.go b/internal/repository/postgres/chat.go index 95349384..255f8313 100644 --- a/internal/repository/postgres/chat.go +++ b/internal/repository/postgres/chat.go @@ -98,6 +98,27 @@ func (r *ChatRepository) IsMember(ctx context.Context, chatID, userID string) (b return false, fmt.Errorf("check chat exists: %w", err) } +// MemberVersion одним запросом возвращает версию истории чата и признак членства. +// Несуществующий чат — ErrNotFound. +func (r *ChatRepository) MemberVersion(ctx context.Context, chatID, userID string) (int64, bool, error) { + const q = ` + SELECT c.version, + EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = $2::uuid) + FROM chats c + WHERE c.id = $1::uuid + ` + var version int64 + var member bool + err := r.pool.QueryRow(ctx, q, chatID, userID).Scan(&version, &member) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return 0, false, repository.ErrNotFound + } + return 0, false, fmt.Errorf("select chat version: %w", err) + } + return version, member, nil +} + func (r *ChatRepository) ListByMember(ctx context.Context, userID string, cursor time.Time, cursorID string, limit int) ([]*domain.Chat, error) { const qChats = ` SELECT c.id, c.title, c.created_at diff --git a/internal/repository/postgres/message.go b/internal/repository/postgres/message.go index 324afbe6..d389ae9b 100644 --- a/internal/repository/postgres/message.go +++ b/internal/repository/postgres/message.go @@ -71,6 +71,12 @@ func (r *MessageRepository) CreateIdempotent(ctx context.Context, msg *domain.Me return nil, false, fmt.Errorf("insert idempotency key: %w", err) } if tag.RowsAffected() == 1 { + // Версия истории растёт атомарно с сообщением: после COMMIT любое чтение + // увидит новую версию и не попадёт в кэш, записанный до этого сообщения. + const bumpVersion = `UPDATE chats SET version = version + 1 WHERE id = $1::uuid` + if _, err := tx.Exec(ctx, bumpVersion, msg.ChatID); err != nil { + return nil, false, fmt.Errorf("bump chat version: %w", err) + } if err := tx.Commit(ctx); err != nil { return nil, false, fmt.Errorf("commit tx: %w", err) } diff --git a/internal/repository/redis/message_cache.go b/internal/repository/redis/message_cache.go index f1cb7b08..5c4c777c 100644 --- a/internal/repository/redis/message_cache.go +++ b/internal/repository/redis/message_cache.go @@ -12,23 +12,27 @@ import ( "github.com/charawein/mtusi2026lab3/internal/domain" ) -// Режимы инвалидации кэша истории (CACHE_INVALIDATION): -// - "scan" (поведение lab2): ключ без версии; запись делает INCR версии и -// удаляет ключи чата через SCAN — O(размер keyspace) запросов к Redis на запись; -// - "version": версия чата входит в ключ; запись делает только INCR, старые -// ключи становятся недостижимыми и истекают по TTL. O(1) на запись. +// Ключ кэша истории всегда содержит версию чата из PostgreSQL (chats.version), +// которая растёт в одной транзакции с сообщением. Поэтому после подтверждённой +// записи следующее чтение идёт по новому ключу, даже если Redis отказал в +// любой команде: устаревшие ключи просто истекают по TTL. +// +// CACHE_INVALIDATION влияет только на стоимость записи (эксперимент трека 1): +// - "version": запись не обращается к Redis; +// - "scan": дополнительно удаляет ключи чата через SCAN, как в lab2 — +// O(размер keyspace/100) запросов к Redis на запись. На корректность не влияет. const ( InvalidationScan = "scan" InvalidationVersion = "version" ) type MessageCache struct { - client *redis.Client - versionedKeys bool + client *redis.Client + scanOnSet bool } func NewMessageCache(client *redis.Client, mode string) *MessageCache { - return &MessageCache{client: client, versionedKeys: mode != InvalidationScan} + return &MessageCache{client: client, scanOnSet: mode == InvalidationScan} } type cacheEntry struct { @@ -36,38 +40,12 @@ type cacheEntry struct { NextCursor string `json:"next_cursor"` } -func (c *MessageCache) cacheKey(chatID string, version int64, cursor string, limit int) string { - if c.versionedKeys { - return fmt.Sprintf("messages:%s:v%d:%s:%d", chatID, version, cursor, limit) - } - return fmt.Sprintf("messages:%s:%s:%d", chatID, cursor, limit) -} - -func versionKey(chatID string) string { - return "chat_version:" + chatID -} - -// GetVersion возвращает текущую версию чата. 0, если ключа нет. -func (c *MessageCache) GetVersion(ctx context.Context, chatID string) int64 { - v, err := c.client.Get(ctx, versionKey(chatID)).Int64() - if err != nil { - return 0 - } - return v -} - -// IncrVersion увеличивает версию чата. Используется в Send для инвалидации. -func (c *MessageCache) IncrVersion(ctx context.Context, chatID string) int64 { - v, err := c.client.Incr(ctx, versionKey(chatID)).Result() - if err != nil { - slog.Warn("redis incr version failed", "chat_id", chatID, "err", err) - return 0 - } - return v +func cacheKey(chatID string, version int64, cursor string, limit int) string { + return fmt.Sprintf("messages:%s:v%d:%s:%d", chatID, version, cursor, limit) } func (c *MessageCache) Get(ctx context.Context, chatID string, version int64, cursor string, limit int) ([]*domain.Message, string, bool) { - raw, err := c.client.Get(ctx, c.cacheKey(chatID, version, cursor, limit)).Bytes() + raw, err := c.client.Get(ctx, cacheKey(chatID, version, cursor, limit)).Bytes() if err != nil { return nil, "", false } @@ -85,18 +63,22 @@ func (c *MessageCache) Set(ctx context.Context, chatID string, version int64, cu slog.Warn("marshal cache entry failed", "err", err) return } - if err := c.client.Set(ctx, c.cacheKey(chatID, version, cursor, limit), raw, 30*time.Second).Err(); err != nil { + if err := c.client.Set(ctx, cacheKey(chatID, version, cursor, limit), raw, 30*time.Second).Err(); err != nil { // Redis недоступен — не падаем, работаем без кэша. slog.Warn("redis set failed", "chat_id", chatID, "err", err) } } -// OnWrite вызывается после успешной записи сообщения, до ответа клиенту. -// Ошибки Redis игнорируются — при недоступности кэш устареет по TTL. +// OnWrite вызывается после успешной записи сообщения. Свежесть чтения уже +// обеспечена ростом chats.version в транзакции записи; в режиме scan здесь +// только воспроизводится стоимость удаления старых ключей (lab2), и ошибка +// Redis не может сделать историю устаревшей. func (c *MessageCache) OnWrite(ctx context.Context, chatID string) { - c.IncrVersion(ctx, chatID) - if !c.versionedKeys { - _ = c.Invalidate(ctx, chatID) + if !c.scanOnSet { + return + } + if err := c.Invalidate(ctx, chatID); err != nil { + slog.Warn("redis scan invalidation failed", "chat_id", chatID, "err", err) } } diff --git a/internal/repository/repository.go b/internal/repository/repository.go index 0baad7b2..a83850c9 100644 --- a/internal/repository/repository.go +++ b/internal/repository/repository.go @@ -32,6 +32,8 @@ type ChatRepository interface { Create(ctx context.Context, chat *domain.Chat) error GetByID(ctx context.Context, id string) (*domain.Chat, error) IsMember(ctx context.Context, chatID, userID string) (bool, error) + // MemberVersion — версия истории чата (растёт с каждым сообщением) и членство. + MemberVersion(ctx context.Context, chatID, userID string) (version int64, member bool, err error) ListByMember(ctx context.Context, userID string, cursor time.Time, cursorID string, limit int) ([]*domain.Chat, error) } diff --git a/internal/service/message.go b/internal/service/message.go index 9c04bcc1..ba493890 100644 --- a/internal/service/message.go +++ b/internal/service/message.go @@ -84,7 +84,7 @@ func (s *MessageService) Send(ctx context.Context, senderID, chatID, text, idemp return stored, nil } - // Инвалидация: увеличение версии чата (+ SCAN-удаление в режиме scan). + // Версия чата уже увеличена в транзакции записи; здесь только режим scan. if s.cache != nil { s.cache.OnWrite(ctx, chatID) } @@ -102,7 +102,9 @@ func (s *MessageService) List(ctx context.Context, callerID, chatID, cursor stri return nil, "", ErrInvalidInput } - ok, err := s.chats.IsMember(ctx, chatID, callerID) + // Членство и версия истории — одним запросом к PostgreSQL. Версия читается + // до истории, поэтому под ключом версии v лежат данные не старее v. + version, ok, err := s.chats.MemberVersion(ctx, chatID, callerID) if err != nil { if errors.Is(err, repository.ErrNotFound) { return nil, "", ErrNotFound @@ -113,15 +115,9 @@ func (s *MessageService) List(ctx context.Context, callerID, chatID, cursor stri return nil, "", ErrNotFound } - // Проверяем кэш. Если версия изменилась между GetVersion и Get — не используем. - var versionBefore int64 if s.cache != nil { - versionBefore = s.cache.GetVersion(ctx, chatID) // ← GetVersion не возвращает ошибку, ок - if items, next, hit := s.cache.Get(ctx, chatID, versionBefore, cursor, limit); hit { // ← Get: при ошибке false - // Проверяем, что версия не изменилась с момента Set - if s.cache.GetVersion(ctx, chatID) == versionBefore { - return items, next, nil - } + if items, next, hit := s.cache.Get(ctx, chatID, version, cursor, limit); hit { + return items, next, nil } } @@ -150,12 +146,8 @@ func (s *MessageService) List(ctx context.Context, callerID, chatID, cursor stri next = encodeCursor(chatID, last.CreatedAt, last.ID) } - // Записываем в кэш только если версия не изменилась за время чтения БД. if s.cache != nil { - versionAfter := s.cache.GetVersion(ctx, chatID) - if versionBefore == versionAfter { - s.cache.Set(ctx, chatID, versionBefore, cursor, limit, items, next) - } + s.cache.Set(ctx, chatID, version, cursor, limit, items, next) } return items, next, nil } diff --git a/internal/service/validate.go b/internal/service/validate.go index 854c09d9..2b4c78e7 100644 --- a/internal/service/validate.go +++ b/internal/service/validate.go @@ -8,7 +8,12 @@ import ( var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) +// validatePassword: 12–128 code points и не только пробельные символы +// (обязательная строка по контракту не может состоять из одних пробелов). func validatePassword(s string) bool { + if strings.TrimSpace(s) == "" { + return false + } n := utf8.RuneCountInString(s) return n >= 12 && n <= 128 } diff --git a/internal/service/validate_test.go b/internal/service/validate_test.go new file mode 100644 index 00000000..a8edb39f --- /dev/null +++ b/internal/service/validate_test.go @@ -0,0 +1,39 @@ +package service + +import ( + "strings" + "testing" +) + +func TestValidatePassword(t *testing.T) { + cases := []struct { + name string + in string + want bool + }{ + {"обычный", "correct-horse-12", true}, + {"ровно 12", strings.Repeat("a", 12), true}, + {"128 code points", strings.Repeat("я", 128), true}, + {"двоеточие допустимо", "pass:word:1234", true}, + {"пробелы внутри допустимы", " pass word ", true}, + {"короче 12", strings.Repeat("a", 11), false}, + {"длиннее 128", strings.Repeat("a", 129), false}, + {"12 пробелов", strings.Repeat(" ", 12), false}, + {"пробельные символы разных видов", strings.Repeat(" \t\n ", 4), false}, + {"пусто", "", false}, + } + for _, c := range cases { + if got := validatePassword(c.in); got != c.want { + t.Errorf("%s: validatePassword(%q) = %v, want %v", c.name, c.in, got, c.want) + } + } +} + +func TestValidateText(t *testing.T) { + if validateText(strings.Repeat(" ", 5)) { + t.Error("whitespace-only text must be rejected") + } + if !validateText("привет") { + t.Error("normal text must be accepted") + } +} diff --git a/migrations/0003_chat_version.down.sql b/migrations/0003_chat_version.down.sql new file mode 100644 index 00000000..717de47f --- /dev/null +++ b/migrations/0003_chat_version.down.sql @@ -0,0 +1 @@ +ALTER TABLE chats DROP COLUMN IF EXISTS version; diff --git a/migrations/0003_chat_version.up.sql b/migrations/0003_chat_version.up.sql new file mode 100644 index 00000000..6c2975a4 --- /dev/null +++ b/migrations/0003_chat_version.up.sql @@ -0,0 +1,7 @@ +-- migrations/0003_chat_version.sql + +-- Версия истории чата: увеличивается в той же транзакции, что и вставка сообщения. +-- Входит в ключ кэша истории, поэтому видимость подтверждённой записи не зависит +-- от доступности Redis. Только добавление столбца с DEFAULT — совместимо с +-- работающей предыдущей версией API (expand). +ALTER TABLE chats ADD COLUMN version BIGINT NOT NULL DEFAULT 0; diff --git a/scripts/collect-evidence.sh b/scripts/collect-evidence.sh index 76008673..8029128e 100755 --- a/scripts/collect-evidence.sh +++ b/scripts/collect-evidence.sh @@ -35,6 +35,13 @@ $PY tests/smoke.py --base-url "$BASE" | tee evidence/smoke.txt step "конкурентная идемпотентность" $PY student-tests/idempotency_concurrent.py --base-url "$BASE" --output evidence/idempotency_concurrent.json | tail -1 +step "регрессии: видимость записи при отказе Redis (ACL), пароль из пробелов" +{ echo "-- CACHE_INVALIDATION=version (по умолчанию)"; $PY student-tests/regressions.py --base-url "$BASE"; } > evidence/regressions.txt 2>&1 +CACHE_INVALIDATION=scan docker compose up -d --wait api >/dev/null 2>&1 +{ echo "-- CACHE_INVALIDATION=scan (реплики пересозданы)"; $PY student-tests/regressions.py --base-url "$BASE"; } >> evidence/regressions.txt 2>&1 +docker compose up -d --wait api >/dev/null 2>&1 +cat evidence/regressions.txt + step "публичный failover (2 прогона, между ними restore)" for n in 1 2; do { $PY tests/resilience.py --mode failover --action-script "$STOP" --base-url "$BASE" || echo "FAILED"; \ diff --git a/student-tests/regressions.py b/student-tests/regressions.py new file mode 100644 index 00000000..7ecd31ec --- /dev/null +++ b/student-tests/regressions.py @@ -0,0 +1,81 @@ +#!/usr/bin/env python3 +"""Регрессии по замечаниям проверки lab3. + +1. Видимость подтверждённой записи при отказе Redis в командах инвалидации: + чат с двумя сообщениями → закэшировать историю → в Redis запретить команды + через ACL (сначала только INCR, затем INCR+DEL+UNLINK+SCAN) → отправить + третье сообщение → каждое следующее чтение через LB обязано вернуть его. +2. Пароль из одних пробельных символов при регистрации → 400. + +Нужен запущенный Docker-стенд (redis-cli вызывается через docker compose exec). +ACL всегда восстанавливается в finally. --only cache|password запускает одну часть. +""" +import subprocess +import sys +import uuid +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) # публичный client.py +from client import Client, arguments, check, run +from resilience import history + +ROOT = Path(__file__).resolve().parents[1] +WHITESPACE_PASSWORDS = (' ' * 12, '\t' * 12, '  ' * 8) + + +def redis_cli(*args): + r = subprocess.run(['docker', 'compose', 'exec', '-T', 'redis', 'redis-cli', *args], + cwd=ROOT, capture_output=True, text=True, timeout=30) + check(r.returncode == 0, 'redis-cli failed: ' + r.stderr.strip()) + return r.stdout.strip() + + +def visibility_case(c, alice, bob, chat, denied): + path = '/api/v1/chats/' + chat['id'] + '/messages?limit=50' + before = [m['id'] for m in history(c, bob, chat)] + # Прогреваем кэш на обеих репликах. + for _ in range(4): + c.call('GET', path, actor=bob, schema='MessagePage') + redis_cli('ACL', 'SETUSER', 'default', *('-' + cmd for cmd in denied)) + try: + sent = c.message(alice, chat, 'после запрета ' + '+'.join(denied))['json'] + # Каждое следующее чтение (через любую реплику) видит подтверждённую запись. + for i in range(6): + page = c.call('GET', path, actor=bob, schema='MessagePage') + ids = [m['id'] for m in page['json']['items']] + check(sent['id'] in ids, 'read %d after 201 misses confirmed message (denied: %s)' % (i, denied)) + # Порядок (created_at до секунды, id): новое сообщение той же секунды может + # встать раньше старых, поэтому проверяем наличие, а не префикс. + check(set(before) <= set(ids), 'previously confirmed messages missing') + finally: + # reset — чтобы снять и точечные запреты, независимо от порядка правил. + redis_cli('ACL', 'SETUSER', 'default', 'reset', 'on', 'nopass', '~*', '&*', '+@all') + return len(before) + 1 + + +def main(): + def configure(p): + p.add_argument('--only', choices=['password', 'cache'], default=None) + args = arguments('Regression checks for lab3 review findings', configure) + c = Client(args.base_url, args.ca_file) + + # 2. Пароль из пробельных символов (пробелы, табуляции, неразрывные пробелы). + if args.only in (None, 'password'): + for pw in WHITESPACE_PASSWORDS: + c.call('POST', '/api/v1/users', 400, + body={'username': 'ws_' + uuid.uuid4().hex[:10], 'display_name': 'WS', 'password': pw}) + print('PASS: whitespace-only password rejected with 400 (3 variants)') + if args.only == 'password': + return + + # 1. Видимость записи при отказе Redis. + alice, bob, _, chat = c.bootstrap() + c.message(alice, chat, 'первое') + c.message(bob, chat, 'второе') + n = visibility_case(c, alice, bob, chat, ['incr']) + print('PASS: Redis ACL -incr: message visible on every next read (%d in history)' % n) + n = visibility_case(c, alice, bob, chat, ['incr', 'del', 'unlink', 'scan']) + print('PASS: Redis ACL -incr -del -unlink -scan: message visible on every next read (%d in history)' % n) + + +if __name__ == '__main__': + run(main) -- 2.54.0 From eec3e4347175ccc6d7348cded40c84fb503d3e88 Mon Sep 17 00:00:00 2001 From: CharaWein Date: Sat, 24 Oct 2026 02:40:42 +0300 Subject: [PATCH 7/8] =?UTF-8?q?track1:=20=D1=80=D0=B5=D0=B7=D1=83=D0=BB?= =?UTF-8?q?=D1=8C=D1=82=D0=B0=D1=82=D1=8B=20=D0=BF=D1=80=D0=BE=D0=B3=D0=BE?= =?UTF-8?q?=D0=BD=D0=B0=203,=20=D0=BF=D0=B5=D1=80=D0=B5=D0=B7=D0=B0=D0=BF?= =?UTF-8?q?=D1=83=D1=81=D0=BA=20=D1=81=D0=B5=D1=80=D0=B8=D0=B8=20C=20?= =?UTF-8?q?=D1=81=20=D0=BA=D0=BE=D0=BD=D1=82=D1=80=D0=BE=D0=BB=D1=8C=D0=BD?= =?UTF-8?q?=D0=BE=D0=B9=20=D0=B1=D0=B0=D0=B7=D0=BE=D0=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .github/workflows/lab3-stand.yml | 18 +-- REPORT.md | 14 +- evidence/docker_ps.txt | 2 +- evidence/docker_stats.txt | 10 +- evidence/failover_1.txt | 10 +- evidence/failover_2.txt | 10 +- evidence/failover_series.json | 50 +++---- evidence/instances.txt | 4 +- evidence/load_baseline.json | 12 +- evidence/persistence.txt | 6 +- evidence/regressions.txt | 8 ++ evidence/regressions_before_fix.txt | 7 + evidence/rolling_update.txt | 43 +++--- evidence/rolling_update_load.json | 12 +- evidence/runner.txt | 2 +- evidence/track1/RUNS.txt | 1 + evidence/track1/raw.jsonl | 129 ++++++++++++++++++ evidence/track1/report.html | 33 +++++ evidence/track1/runner_A_fixed_total.txt | 6 + evidence/track1/runner_B_scale_out.txt | 7 + evidence/track1/runner_C_shared_resources.txt | 6 + evidence/track1/runner_D_improvement.txt | 6 + .../track1/runner_E_scale_out_after_fix.txt | 6 + evidence/track1/summary.csv | 44 ++++++ evidence/track1/summary.md | 64 +++++++++ experiments/track1.json | 8 +- 26 files changed, 419 insertions(+), 99 deletions(-) create mode 100644 evidence/regressions.txt create mode 100644 evidence/regressions_before_fix.txt create mode 100644 evidence/track1/RUNS.txt create mode 100644 evidence/track1/raw.jsonl create mode 100644 evidence/track1/report.html create mode 100644 evidence/track1/runner_A_fixed_total.txt create mode 100644 evidence/track1/runner_B_scale_out.txt create mode 100644 evidence/track1/runner_C_shared_resources.txt create mode 100644 evidence/track1/runner_D_improvement.txt create mode 100644 evidence/track1/runner_E_scale_out_after_fix.txt create mode 100644 evidence/track1/summary.csv create mode 100644 evidence/track1/summary.md diff --git a/.github/workflows/lab3-stand.yml b/.github/workflows/lab3-stand.yml index c90bcbf8..fbe552e0 100644 --- a/.github/workflows/lab3-stand.yml +++ b/.github/workflows/lab3-stand.yml @@ -92,23 +92,13 @@ jobs: strategy: fail-fast: false matrix: - # Прогон 3: все серии заново на исправленном коде (версия кэша в PostgreSQL). + # Прогон 3 (40039513675) измерил A–E на исправленном коде. Прогон 4 переснимает + # только C: 5 повторов и базовая конфигурация в начале и в конце серии. include: - - series: A_fixed_total - configs: "" - levels: "4,16,64" - - series: B_scale_out - configs: "1x0.50,2x0.50,4x0.50" - levels: "4,16,64" - series: C_shared_resources configs: "" levels: "16,64" - - series: D_improvement - configs: "" - levels: "32,64" - - series: E_scale_out_after_fix - configs: "" - levels: "4,16,64" + repeats: 5 steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v5 @@ -123,7 +113,7 @@ jobs: run: | python scripts/track1.py --series ${{ matrix.series }} \ --configs "${{ matrix.configs }}" --levels "${{ matrix.levels }}" \ - --duration 15s --warmup 3s --repeats 3 \ + --duration 15s --warmup 3s --repeats ${{ matrix.repeats || 3 }} \ --output evidence/track1/raw_${{ matrix.series }}.jsonl - name: Окружение runner if: always() diff --git a/REPORT.md b/REPORT.md index f248b850..f986d484 100644 --- a/REPORT.md +++ b/REPORT.md @@ -67,7 +67,7 @@ Windows: `python3` там часто заглушка — используйте migrate (one-shot) ──► postgres — до старта api ``` -**Перенесено из lab2 без изменений:** API, валидация, Argon2id, keyset-пагинация, сессии в Redis с TTL (переживают рестарт благодаря AOF), кэш истории с версионированием чата. +**Перенесено из lab2:** API, валидация, Argon2id, keyset-пагинация, сессии в Redis с TTL (переживают рестарт благодаря AOF), кэш истории. Кэш и валидация пароля изменены по замечаниям проверки (см. «Исправления по замечаниям проверки»). **Изменено в lab3:** @@ -83,7 +83,8 @@ migrate (one-shot) ──► postgres — до старта api 3. **Миграции** — отдельный one-shot сервис `migrate` (golang-migrate хранит версию и берёт advisory lock); `api` зависит от него через `service_completed_successfully`, поэтому реплики не гоняются за схему. DSN читается из secret, пароль не хранится в compose.yaml (в lab2 был захардкожен — исправлено). 4. **Graceful shutdown**: по SIGTERM `/health/ready` сразу отвечает 503, процесс продолжает обслуживать запросы `DRAIN_DELAY=3s` (HAProxy за это время исключает его: inter 1s × fall 2), затем `http.Server.Shutdown` с `SHUTDOWN_TIMEOUT=8s`. `stop_grace_period: 15s` > 3 + 8, поэтому SIGKILL не обрывает запросы. 5. **LB HAProxy**: `server-template api 8 api:8080` + `resolvers docker` (127.0.0.11) — новые/пересозданные реплики подхватываются без перезапуска LB; `retry-on conn-failure` + `option redispatch` — повтор только когда запрос ещё не отправлен, поэтому неидемпотентные POST /users и /chats не дублируются. Sticky sessions нет: состояние общее. -6. **Ресурсы** (переопределяются переменными для трека 1): api 0.5 CPU/256M, lb 0.5/128M, postgres 1.0/512M, redis 0.5/256M. Сети: `front` (lb↔api) и `back` (api↔хранилища) — LB не видит БД. +6. **Кэш истории и версия чата.** Ключ кэша `messages:{chat}:v{version}:{cursor}:{limit}`, где `version` — столбец `chats.version` в PostgreSQL (миграция `0003_chat_version`). Версия увеличивается в **той же транзакции**, что и вставка сообщения; читатель получает версию тем же запросом, которым проверяет членство (`MemberVersion`). Поэтому после ответа 201 любое чтение идёт по новому ключу, и отказ Redis в любой команде (или полная недоступность кэша) не может вернуть устаревшую историю — старые ключи просто истекают по TTL 30 s. Redis на пути записи не нужен. +7. **Ресурсы** (переопределяются переменными для трека 1): api 0.5 CPU/256M, lb 0.5/128M, postgres 1.0/512M, redis 0.5/256M. Сети: `front` (lb↔api) и `back` (api↔хранилища) — LB не видит БД. **Критичные зависимости readiness:** PostgreSQL и Redis (сессии нужны каждому защищённому запросу) + флаг drain. `/health/live` — только жизнь процесса. @@ -96,6 +97,15 @@ migrate (one-shot) ──► postgres — до старта api **Соответствие .env.example:** APP_HOST/APP_PORT/APP_ENV/SESSION_TTL_SECONDS/IDEMPOTENCY_TTL_SECONDS — как есть; DATABASE_URL_FILE и CACHE_URL_FILE — docker secrets `/run/secrets/*`; SESSION_STORE=redis (сессии в Redis с lab2); API_REPLICAS → `deploy.replicas`; DRAIN_DELAY/SHUTDOWN_TIMEOUT — добавлены. +## Исправления по замечаниям проверки + +| Замечание | Причина | Исправление | Проверка | +| --- | --- | --- | --- | +| Подтверждённая запись может отсутствовать в следующем чтении: при `ACL SETUSER default -incr` POST → 201, строка в PostgreSQL есть, GET возвращает прежние два сообщения | версия чата для ключа кэша хранилась в Redis и увеличивалась `INCR` после COMMIT; ошибка `INCR` игнорировалась (`message_cache.go:95`), ключ не менялся, чтение попадало в старый кэш | версия перенесена в `chats.version` и растёт в транзакции записи; ключ кэша строится из версии, прочитанной из PostgreSQL вместе с проверкой членства; `INCR`/`GET` версии в Redis удалены. Режим `CACHE_INVALIDATION=scan` теперь только воспроизводит стоимость SCAN для эксперимента и на корректность не влияет | [student-tests/regressions.py](student-tests/regressions.py) — ровно сценарий проверки (2 сообщения → кэш → `ACL -incr` → 3-е → чтение) и жёсткий вариант `-incr -del -unlink -scan`, шесть чтений через обе реплики; в режимах `version` и `scan`. Тот же тест против кода до исправления — FAIL (job `regression-before-fix`) | +| Принимается пароль из одних пробелов (`" " × 12` → 201) | `validatePassword` проверял только длину | добавлена проверка `strings.TrimSpace(s) == ""` → 400; остальные обязательные строки (`display_name`, `title`, `text`) уже проверялись так же | unit-тест [validate_test.go](internal/service/validate_test.go) (пробелы, табуляции, NBSP, границы 12/128); HTTP-регрессия на 3 вариантах | + +Изменение кэша меняет путь записи и чтения, поэтому **все серии трека 1 переизмерены на исправленном коде** (прогон 3). Данные прогонов 1–2 на коде до исправления сохранены в `evidence/track1/legacy_before_review_fix/` и в выводах не используются. + ## Где запускался стенд На машине разработки Docker Desktop не запускается: в BIOS выключена аппаратная виртуализация (`VirtualizationFirmwareEnabled=False`, backend `hasNoVirtualization=true`). Поэтому все Docker-проверки выполнены на **GitHub-hosted runner** workflow [.github/workflows/lab3-stand.yml](.github/workflows/lab3-stand.yml) — тот же compose.yaml и те же скрипты, что и в инструкции выше: diff --git a/evidence/docker_ps.txt b/evidence/docker_ps.txt index 998401a6..9e6a7642 100644 --- a/evidence/docker_ps.txt +++ b/evidence/docker_ps.txt @@ -1,4 +1,4 @@ -2026-10-23T14:49:09Z +2026-10-23T23:26:03Z Docker Compose version v2.38.2 NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS mtusi2026lab3-api-1 mtusi2026lab3-api:local "/app/api" api 13 seconds ago Up 6 seconds (healthy) 8080/tcp diff --git a/evidence/docker_stats.txt b/evidence/docker_stats.txt index 3554dbf2..c1ab9bbf 100644 --- a/evidence/docker_stats.txt +++ b/evidence/docker_stats.txt @@ -1,5 +1,5 @@ -mtusi2026lab3-api-4 0.10% 39.38MiB / 256MiB -mtusi2026lab3-api-3 2.83% 48.86MiB / 256MiB -mtusi2026lab3-lb-1 0.12% 8.852MiB / 128MiB -mtusi2026lab3-postgres-1 0.07% 72.59MiB / 512MiB -mtusi2026lab3-redis-1 0.50% 9.191MiB / 256MiB +mtusi2026lab3-api-4 0.05% 37.14MiB / 256MiB +mtusi2026lab3-api-3 0.07% 38.68MiB / 256MiB +mtusi2026lab3-lb-1 0.10% 8.859MiB / 128MiB +mtusi2026lab3-postgres-1 0.50% 83.43MiB / 512MiB +mtusi2026lab3-redis-1 0.47% 8.711MiB / 256MiB diff --git a/evidence/failover_1.txt b/evidence/failover_1.txt index 376fcb9d..5f2da34e 100644 --- a/evidence/failover_1.txt +++ b/evidence/failover_1.txt @@ -1,8 +1,8 @@ Executing explicit failover hook; hook output suppressed to avoid leaking secrets. -{"observed_instances_before": 2, "successful_writes": 143, "failed_attempts": 0, "first_recovery_seconds": 3.393} +{"observed_instances_before": 2, "successful_writes": 144, "failed_attempts": 0, "first_recovery_seconds": 3.367} PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. -- контейнеры api после stop-one: -mtusi2026lab3-api-1 259a4143c86a Up 27 seconds (healthy) -mtusi2026lab3-api-2 904a0714df9b Exited (0) 11 seconds ago -mtusi2026lab3-api-1 Up 35 seconds (healthy) -mtusi2026lab3-api-2 Up 6 seconds (healthy) +mtusi2026lab3-api-1 4f142660cef9 Exited (0) 11 seconds ago +mtusi2026lab3-api-2 29c5ff8f740e Up 21 seconds (healthy) +mtusi2026lab3-api-1 Up 5 seconds (healthy) +mtusi2026lab3-api-2 Up 28 seconds (healthy) diff --git a/evidence/failover_2.txt b/evidence/failover_2.txt index 7ed4acc0..0e23a5ed 100644 --- a/evidence/failover_2.txt +++ b/evidence/failover_2.txt @@ -1,8 +1,8 @@ Executing explicit failover hook; hook output suppressed to avoid leaking secrets. -{"observed_instances_before": 2, "successful_writes": 144, "failed_attempts": 0, "first_recovery_seconds": 3.361} +{"observed_instances_before": 2, "successful_writes": 144, "failed_attempts": 0, "first_recovery_seconds": 3.277} PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. -- контейнеры api после stop-one: -mtusi2026lab3-api-1 259a4143c86a Up 50 seconds (healthy) -mtusi2026lab3-api-2 904a0714df9b Exited (0) 12 seconds ago -mtusi2026lab3-api-1 Up 58 seconds (healthy) -mtusi2026lab3-api-2 Up 6 seconds (healthy) +mtusi2026lab3-api-1 4f142660cef9 Exited (0) 12 seconds ago +mtusi2026lab3-api-2 29c5ff8f740e Up 44 seconds (healthy) +mtusi2026lab3-api-1 Up 6 seconds (healthy) +mtusi2026lab3-api-2 Up 51 seconds (healthy) diff --git a/evidence/failover_series.json b/evidence/failover_series.json index a7e82aa8..fb9ee67b 100644 --- a/evidence/failover_series.json +++ b/evidence/failover_series.json @@ -2,63 +2,63 @@ "concurrency": 4, "replicas": 2, "total": { - "seconds": 53.99, - "ok": 18773, + "seconds": 53.27, + "ok": 25481, "errors": 0, - "ok_rps": 347.7 + "ok_rps": 478.3 }, - "confirmed_writes": 9388, - "stored_messages": 9389, + "confirmed_writes": 12741, + "stored_messages": 12744, "duplicates": 0, "lost_confirmed": 0, "per_replica": [ { - "target_instance": "259a4143c86a", - "docker_stop_seconds": 3.57, + "target_instance": "4f142660cef9", + "docker_stop_seconds": 3.66, "before": { "seconds": 5.0, - "ok": 1739, + "ok": 2315, "errors": 0, - "ok_rps": 347.8 + "ok_rps": 463.0 }, "during_stop_and_observe": { "seconds": 15.0, - "ok": 5428, + "ok": 7402, "errors": 0, - "ok_rps": 361.9 + "ok_rps": 493.4 }, "errors_after_stop": 0, "recovery_seconds": 0.0, - "target_last_served_after_stop_seconds": 0.75, + "target_last_served_after_stop_seconds": 1.35, "other_instances_after": [ - "904a0714df9b" + "29c5ff8f740e" ], - "restore_healthy_seconds": 6.24, - "restore_serving_via_lb_seconds": 6.25 + "restore_healthy_seconds": 5.93, + "restore_serving_via_lb_seconds": 5.93 }, { - "target_instance": "904a0714df9b", - "docker_stop_seconds": 4.12, + "target_instance": "29c5ff8f740e", + "docker_stop_seconds": 3.98, "before": { "seconds": 5.0, - "ok": 1729, + "ok": 2401, "errors": 0, - "ok_rps": 345.8 + "ok_rps": 480.2 }, "during_stop_and_observe": { "seconds": 15.0, - "ok": 5370, + "ok": 7272, "errors": 0, - "ok_rps": 357.9 + "ok_rps": 484.8 }, "errors_after_stop": 0, "recovery_seconds": 0.0, - "target_last_served_after_stop_seconds": 1.46, + "target_last_served_after_stop_seconds": 1.34, "other_instances_after": [ - "259a4143c86a" + "4f142660cef9" ], - "restore_healthy_seconds": 6.81, - "restore_serving_via_lb_seconds": 6.81 + "restore_healthy_seconds": 6.38, + "restore_serving_via_lb_seconds": 6.38 } ] } diff --git a/evidence/instances.txt b/evidence/instances.txt index d79262fd..b669a337 100644 --- a/evidence/instances.txt +++ b/evidence/instances.txt @@ -1,2 +1,2 @@ -259a4143c86a 10 -904a0714df9b 10 +932349e41b13 10 +9c02b883d167 10 diff --git a/evidence/load_baseline.json b/evidence/load_baseline.json index b7749f9f..5a0c72b1 100644 --- a/evidence/load_baseline.json +++ b/evidence/load_baseline.json @@ -2,16 +2,16 @@ "lab": 3, "workload": "closed-loop POST messages; no automatic retries", "requested_duration_seconds": 30.0, - "elapsed_seconds": 30.076, + "elapsed_seconds": 30.096, "concurrency": 4, - "successful_requests": 11769, + "successful_requests": 15496, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 391.312, + "successful_rps": 514.887, "successful_latency_ms": { - "p50": 9.744, - "p95": 15.681, - "p99": 22.066 + "p50": 7.382, + "p95": 11.918, + "p99": 16.148 }, "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." } diff --git a/evidence/persistence.txt b/evidence/persistence.txt index 3a6ad1fa..a4c0bd9d 100644 --- a/evidence/persistence.txt +++ b/evidence/persistence.txt @@ -1,7 +1,7 @@ -- до: -mtusi2026lab3-api-1 Up 58 seconds (healthy) -mtusi2026lab3-api-2 Up 6 seconds (healthy) -mtusi2026lab3-lb-1 Up 52 seconds +mtusi2026lab3-api-1 Up 6 seconds (healthy) +mtusi2026lab3-api-2 Up 51 seconds (healthy) +mtusi2026lab3-lb-1 Up About a minute mtusi2026lab3-postgres-1 Up About a minute (healthy) mtusi2026lab3-redis-1 Up About a minute (healthy) Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. diff --git a/evidence/regressions.txt b/evidence/regressions.txt new file mode 100644 index 00000000..8ba24866 --- /dev/null +++ b/evidence/regressions.txt @@ -0,0 +1,8 @@ +-- CACHE_INVALIDATION=version (по умолчанию) +PASS: whitespace-only password rejected with 400 (3 variants) +PASS: Redis ACL -incr: message visible on every next read (3 in history) +PASS: Redis ACL -incr -del -unlink -scan: message visible on every next read (4 in history) +-- CACHE_INVALIDATION=scan (реплики пересозданы) +PASS: whitespace-only password rejected with 400 (3 variants) +PASS: Redis ACL -incr: message visible on every next read (3 in history) +PASS: Redis ACL -incr -del -unlink -scan: message visible on every next read (4 in history) diff --git a/evidence/regressions_before_fix.txt b/evidence/regressions_before_fix.txt new file mode 100644 index 00000000..3c9f25c7 --- /dev/null +++ b/evidence/regressions_before_fix.txt @@ -0,0 +1,7 @@ +-- код commit 7cd5506 (до исправления), тест из текущего commit +-- --only cache +FAIL: read 0 after 201 misses confirmed message (denied: ['incr']) +exit=1 +-- --only password +FAIL: POST /api/v1/users: expected [400], received 201 +exit=1 diff --git a/evidence/rolling_update.txt b/evidence/rolling_update.txt index 1707a204..74a6c54c 100644 --- a/evidence/rolling_update.txt +++ b/evidence/rolling_update.txt @@ -1,25 +1,22 @@ -- до: -mtusi2026lab3-api-1 259a4143c86a Up About a minute (healthy) -mtusi2026lab3-api-2 904a0714df9b Up About a minute (healthy) +mtusi2026lab3-api-1 4f142660cef9 Up About a minute (healthy) +mtusi2026lab3-api-2 29c5ff8f740e Up About a minute (healthy) #1 [internal] load local bake definitions #1 reading from stdin 380B done #1 DONE 0.0s #2 [internal] load build definition from Dockerfile -#2 transferring dockerfile: 2.22kB 0.0s done +#2 transferring dockerfile: 2.36kB done #2 DONE 0.0s -#3 [internal] load metadata for docker.io/library/alpine:3.20 -#3 ... +#3 [internal] load metadata for docker.io/library/alpine:3.20@sha256:d9e853e87e55526f6b2917df91a2115c36dd7c696a35be12163d44e6e2a4b6bc +#3 DONE 0.0s -#4 [internal] load metadata for docker.io/library/golang:1.26-alpine -#4 DONE 0.2s - -#3 [internal] load metadata for docker.io/library/alpine:3.20 -#3 DONE 0.2s +#4 [internal] load metadata for docker.io/library/golang:1.26-alpine@sha256:27f2d3b83cfc5803c8078f8e730af0f7c431bf067afaec8f60a36fb763187cba +#4 DONE 0.0s #5 [internal] load .dockerignore -#5 transferring context: 212B 0.0s done +#5 transferring context: 212B done #5 DONE 0.0s #6 [builder 1/6] FROM docker.io/library/golang:1.26-alpine@sha256:27f2d3b83cfc5803c8078f8e730af0f7c431bf067afaec8f60a36fb763187cba @@ -29,31 +26,31 @@ mtusi2026lab3-api-2 904a0714df9b Up About a minute (healthy) #7 DONE 0.0s #8 [internal] load build context -#8 transferring context: 4.90kB 0.0s done +#8 transferring context: 5.11kB done #8 DONE 0.0s -#9 [stage-1 2/5] RUN apk --no-cache add ca-certificates tzdata +#9 [builder 4/6] RUN go mod download #9 CACHED -#10 [builder 3/6] COPY go.mod go.sum ./ +#10 [builder 2/6] WORKDIR /src #10 CACHED -#11 [builder 6/6] RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -trimpath -o /out/api ./cmd/api +#11 [builder 5/6] COPY . . #11 CACHED -#12 [builder 5/6] COPY . . +#12 [stage-1 4/5] WORKDIR /app #12 CACHED -#13 [stage-1 4/5] WORKDIR /app +#13 [stage-1 3/5] RUN addgroup -g 1001 -S appgroup && adduser -u 1001 -S appuser -G appgroup #13 CACHED -#14 [stage-1 3/5] RUN addgroup -g 1001 -S appgroup && adduser -u 1001 -S appuser -G appgroup +#14 [builder 6/6] RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -trimpath -o /out/api ./cmd/api #14 CACHED -#15 [builder 2/6] WORKDIR /src +#15 [builder 3/6] COPY go.mod go.sum ./ #15 CACHED -#16 [builder 4/6] RUN go mod download +#16 [stage-1 2/5] RUN apk --no-cache add ca-certificates tzdata #16 CACHED #17 [stage-1 5/5] COPY --from=builder --chown=appuser:appgroup /out/api /app/api @@ -61,7 +58,7 @@ mtusi2026lab3-api-2 904a0714df9b Up About a minute (healthy) #18 exporting to image #18 exporting layers done -#18 writing image sha256:7963c3b2693515ae76dcf3c09b301780531b7a8fb5b79635f635351694eb6a56 done +#18 writing image sha256:a05e93077326499dd896f095275ff581163237d2582b1e926f3f1da90df27f16 done #18 naming to docker.io/library/mtusi2026lab3-api:local done #18 DONE 0.0s @@ -84,6 +81,6 @@ replaced /mtusi2026lab3-api-1 Container mtusi2026lab3-api-4 Starting Container mtusi2026lab3-api-4 Started replaced /mtusi2026lab3-api-2 -mtusi2026lab3-api-3 22525ed8c455 mtusi2026lab3-api:local Up 22 seconds (healthy) -mtusi2026lab3-api-4 c20f2f6e88d4 mtusi2026lab3-api:local Up 10 seconds (healthy) +mtusi2026lab3-api-3 e9b14e16bd3c mtusi2026lab3-api:local Up 22 seconds (healthy) +mtusi2026lab3-api-4 48e2cdb41989 mtusi2026lab3-api:local Up 11 seconds (healthy) -- замена заняла 27 s (внутри 90 s нагрузки) diff --git a/evidence/rolling_update_load.json b/evidence/rolling_update_load.json index 8ba972f8..dde48271 100644 --- a/evidence/rolling_update_load.json +++ b/evidence/rolling_update_load.json @@ -2,16 +2,16 @@ "lab": 3, "workload": "closed-loop POST messages; no automatic retries", "requested_duration_seconds": 90.0, - "elapsed_seconds": 90.074, + "elapsed_seconds": 90.095, "concurrency": 4, - "successful_requests": 33461, + "successful_requests": 45591, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 371.484, + "successful_rps": 506.032, "successful_latency_ms": { - "p50": 9.922, - "p95": 17.746, - "p99": 27.682 + "p50": 7.307, + "p95": 12.793, + "p99": 19.902 }, "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." } diff --git a/evidence/runner.txt b/evidence/runner.txt index 80902415..13da9472 100644 --- a/evidence/runner.txt +++ b/evidence/runner.txt @@ -1,6 +1,6 @@ 2 total used free shared buff/cache available -Mem: 7938 1223 2825 93 4297 6715 +Mem: 7937 1241 2749 102 4362 6695 Swap: 3071 0 3071 28.0.4 Docker Compose version v2.38.2 diff --git a/evidence/track1/RUNS.txt b/evidence/track1/RUNS.txt new file mode 100644 index 00000000..a7d6e236 --- /dev/null +++ b/evidence/track1/RUNS.txt @@ -0,0 +1 @@ +run3=https://github.com/CharaWein/2026_lab3/actions/runs/40039513675 commit=bab82c7 series=A,B,C,D,E (after review fix); levels 3-4 + regression-before-fix from the same run diff --git a/evidence/track1/raw.jsonl b/evidence/track1/raw.jsonl new file mode 100644 index 00000000..e8c1657d --- /dev/null +++ b/evidence/track1/raw.jsonl @@ -0,0 +1,129 @@ +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2bdb0f2dfa21": 6144}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 61.703, "p50": 8.304, "p95": 28.829, "p99": 37.997}, "mode": "closed", "ok": 6144, "ok_read_rps": 209.6, "ok_rps": 409.6, "ok_write_rps": 200, "rate": 0, "read_ms": {"max": 27.959, "p50": 1.917, "p95": 4.561, "p99": 16.229}, "requests": 6144, "timestamp": "2026-10-23T23:26:25Z", "warmup_s": 3, "write_ms": {"max": 61.703, "p50": 14.536, "p95": 33.361, "p99": 41.523}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 61.5, "cpu_pct_max_per_container": 65.0, "cpu_utilization_of_limit": 0.615, "mem_max_mib": 72.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.5, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.09, "mem_max_mib": 8.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.5, "cpu_pct_max_per_container": 22.0, "cpu_utilization_of_limit": 0.205, "mem_max_mib": 39.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 51.2, "cpu_pct_max_per_container": 52.1, "cpu_utilization_of_limit": 1.025, "mem_max_mib": 11.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 4}}, "pool": {"acquires": 20596, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2bdb0f2dfa21": 5705}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 169.668, "p50": 10.703, "p95": 29.655, "p99": 39.126}, "mode": "closed", "ok": 5705, "ok_read_rps": 189.46666666666667, "ok_rps": 380.3333333333333, "ok_write_rps": 190.86666666666667, "rate": 0, "read_ms": {"max": 37.388, "p50": 2.011, "p95": 4.753, "p99": 15.915}, "requests": 5705, "timestamp": "2026-10-23T23:26:46Z", "warmup_s": 3, "write_ms": {"max": 169.668, "p50": 15.162, "p95": 34.605, "p99": 43.717}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 60.5, "cpu_pct_max_per_container": 64.6, "cpu_utilization_of_limit": 0.605, "mem_max_mib": 237.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.5, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.09, "mem_max_mib": 8.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.5, "cpu_pct_max_per_container": 20.9, "cpu_utilization_of_limit": 0.195, "mem_max_mib": 43.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.9, "cpu_pct_max_per_container": 51.8, "cpu_utilization_of_limit": 1.018, "mem_max_mib": 10.1}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 4}}, "pool": {"acquires": 19782, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2bdb0f2dfa21": 6000}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 86.15, "p50": 9.498, "p95": 29.003, "p99": 37.037}, "mode": "closed", "ok": 6000, "ok_read_rps": 202, "ok_rps": 400, "ok_write_rps": 198, "rate": 0, "read_ms": {"max": 29.958, "p50": 1.997, "p95": 4.416, "p99": 14.93}, "requests": 6000, "timestamp": "2026-10-23T23:27:06Z", "warmup_s": 3, "write_ms": {"max": 86.15, "p50": 14.84, "p95": 32.894, "p99": 42.727}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 59.7, "cpu_pct_max_per_container": 62.0, "cpu_utilization_of_limit": 0.597, "mem_max_mib": 231.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.5, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.091, "mem_max_mib": 8.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.4, "cpu_pct_max_per_container": 21.3, "cpu_utilization_of_limit": 0.194, "mem_max_mib": 46.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 51.5, "cpu_pct_max_per_container": 52.2, "cpu_utilization_of_limit": 1.03, "mem_max_mib": 10.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 4}}, "pool": {"acquires": 20096, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2bdb0f2dfa21": 6467}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 160.216, "p50": 31.989, "p95": 86.479, "p99": 114.583}, "mode": "closed", "ok": 6467, "ok_read_rps": 214.93333333333334, "ok_rps": 431.1333333333333, "ok_write_rps": 216.2, "rate": 0, "read_ms": {"max": 46.063, "p50": 4.433, "p95": 15.027, "p99": 28.14}, "requests": 6467, "timestamp": "2026-10-23T23:27:26Z", "warmup_s": 3, "write_ms": {"max": 160.216, "p50": 66.083, "p95": 98.467, "p99": 129.498}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 61.1, "cpu_pct_max_per_container": 64.7, "cpu_utilization_of_limit": 0.611, "mem_max_mib": 144.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.8, "cpu_pct_max_per_container": 23.9, "cpu_utilization_of_limit": 0.228, "mem_max_mib": 75.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.5, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 1.009, "mem_max_mib": 11.0}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 15}}, "pool": {"acquires": 22079, "empty_acquire_ratio": 0.0005, "avg_acquire_wait_ms": 0.017, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2bdb0f2dfa21": 6286}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 159.031, "p50": 39.763, "p95": 87.644, "p99": 112.418}, "mode": "closed", "ok": 6286, "ok_read_rps": 207.46666666666667, "ok_rps": 419.06666666666666, "ok_write_rps": 211.6, "rate": 0, "read_ms": {"max": 50.678, "p50": 4.415, "p95": 15.918, "p99": 27.518}, "requests": 6286, "timestamp": "2026-10-23T23:27:47Z", "warmup_s": 3, "write_ms": {"max": 159.031, "p50": 70.47, "p95": 96.172, "p99": 125.703}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 59.1, "cpu_pct_max_per_container": 63.0, "cpu_utilization_of_limit": 0.591, "mem_max_mib": 58.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.098, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.5, "cpu_pct_max_per_container": 21.9, "cpu_utilization_of_limit": 0.195, "mem_max_mib": 77.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 1.003, "mem_max_mib": 11.0}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 15}}, "pool": {"acquires": 21713, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2bdb0f2dfa21": 6527}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 229.894, "p50": 22.434, "p95": 89.27, "p99": 123.564}, "mode": "closed", "ok": 6527, "ok_read_rps": 221.93333333333334, "ok_rps": 435.1333333333333, "ok_write_rps": 213.2, "rate": 0, "read_ms": {"max": 38.923, "p50": 4.526, "p95": 15.642, "p99": 26.097}, "requests": 6527, "timestamp": "2026-10-23T23:28:07Z", "warmup_s": 3, "write_ms": {"max": 229.894, "p50": 66.231, "p95": 103.872, "p99": 150.153}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 59.1, "cpu_pct_max_per_container": 63.5, "cpu_utilization_of_limit": 0.591, "mem_max_mib": 60.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.1, "cpu_pct_max_per_container": 21.3, "cpu_utilization_of_limit": 0.201, "mem_max_mib": 83.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 1.0, "mem_max_mib": 10.9}, "postgres_connections": {"active_max": 2, "active_mean": 0.4, "total_max": 16}}, "pool": {"acquires": 22216, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2bdb0f2dfa21": 6904}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 467.739, "p50": 51.415, "p95": 323.757, "p99": 388.539}, "mode": "closed", "ok": 6904, "ok_read_rps": 230.6, "ok_rps": 460.26666666666665, "ok_write_rps": 229.66666666666666, "rate": 0, "read_ms": {"max": 61.216, "p50": 11.67, "p95": 30.987, "p99": 44.82}, "requests": 6904, "timestamp": "2026-10-23T23:28:27Z", "warmup_s": 3, "write_ms": {"max": 467.739, "p50": 252.357, "p95": 347.715, "p99": 423.179}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 64.9, "cpu_pct_max_per_container": 68.5, "cpu_utilization_of_limit": 0.649, "mem_max_mib": 83.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.102, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.8, "cpu_pct_max_per_container": 41.7, "cpu_utilization_of_limit": 0.238, "mem_max_mib": 95.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 0.992, "mem_max_mib": 11.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 20}}, "pool": {"acquires": 24096, "empty_acquire_ratio": 0.0095, "avg_acquire_wait_ms": 0.031, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2bdb0f2dfa21": 6990}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 394.658, "p50": 215.554, "p95": 302.967, "p99": 351.087}, "mode": "closed", "ok": 6990, "ok_read_rps": 229.93333333333334, "ok_rps": 466, "ok_write_rps": 236.06666666666666, "rate": 0, "read_ms": {"max": 79.833, "p50": 11.042, "p95": 28.267, "p99": 35.465}, "requests": 6990, "timestamp": "2026-10-23T23:28:47Z", "warmup_s": 3, "write_ms": {"max": 394.658, "p50": 250.237, "p95": 325.738, "p99": 358.774}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 67.0, "cpu_pct_max_per_container": 68.0, "cpu_utilization_of_limit": 0.67, "mem_max_mib": 85.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.102, "mem_max_mib": 9.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.4, "cpu_pct_max_per_container": 23.6, "cpu_utilization_of_limit": 0.204, "mem_max_mib": 97.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.4, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 1.007, "mem_max_mib": 11.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 20}}, "pool": {"acquires": 24467, "empty_acquire_ratio": 0.0154, "avg_acquire_wait_ms": 0.064, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "1x1.00", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "1.00", "API_MEMORY": "768M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2bdb0f2dfa21": 6592}, "label": "A_fixed_total/1x1.00", "latency_ms": {"max": 432.851, "p50": 203.617, "p95": 323.704, "p99": 364.453}, "mode": "closed", "ok": 6592, "ok_read_rps": 216.4, "ok_rps": 439.46666666666664, "ok_write_rps": 223.06666666666666, "rate": 0, "read_ms": {"max": 80.029, "p50": 13.468, "p95": 43.994, "p99": 62.087}, "requests": 6592, "timestamp": "2026-10-23T23:29:07Z", "warmup_s": 3, "write_ms": {"max": 432.851, "p50": 261.136, "p95": 343.466, "p99": 378.823}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 64.5, "cpu_pct_max_per_container": 66.5, "cpu_utilization_of_limit": 0.645, "mem_max_mib": 85.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.099, "mem_max_mib": 10.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.0, "cpu_pct_max_per_container": 23.5, "cpu_utilization_of_limit": 0.21, "mem_max_mib": 101.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.5, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.99, "mem_max_mib": 17.7}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 20}}, "pool": {"acquires": 23188, "empty_acquire_ratio": 0.0373, "avg_acquire_wait_ms": 0.132, "pool_max_conns_total": 20}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"04a91ade61d7": 2824, "e7168005d2da": 2826}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 76.064, "p50": 9.301, "p95": 28.504, "p99": 38.222}, "mode": "closed", "ok": 5650, "ok_read_rps": 187.93333333333334, "ok_rps": 376.6666666666667, "ok_write_rps": 188.73333333333332, "rate": 0, "read_ms": {"max": 33.734, "p50": 2.089, "p95": 5.546, "p99": 12.305}, "requests": 5650, "timestamp": "2026-10-23T23:29:39Z", "warmup_s": 3, "write_ms": {"max": 76.064, "p50": 16.076, "p95": 33.551, "p99": 43.223}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 35.0, "cpu_pct_max_per_container": 39.9, "cpu_utilization_of_limit": 0.7, "mem_max_mib": 138.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.4, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.088, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.4, "cpu_pct_max_per_container": 41.7, "cpu_utilization_of_limit": 0.204, "mem_max_mib": 73.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.3, "cpu_pct_max_per_container": 51.3, "cpu_utilization_of_limit": 1.007, "mem_max_mib": 11.8}, "postgres_connections": {"active_max": 2, "active_mean": 0.3, "total_max": 8}}, "pool": {"acquires": 19034, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"04a91ade61d7": 3106, "e7168005d2da": 3104}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 61.424, "p50": 8.53, "p95": 23.948, "p99": 33.349}, "mode": "closed", "ok": 6210, "ok_read_rps": 208.53333333333333, "ok_rps": 414, "ok_write_rps": 205.46666666666667, "rate": 0, "read_ms": {"max": 34.846, "p50": 2.068, "p95": 5.485, "p99": 13.905}, "requests": 6210, "timestamp": "2026-10-23T23:30:00Z", "warmup_s": 3, "write_ms": {"max": 61.424, "p50": 15.207, "p95": 27.623, "p99": 38.508}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 37.7, "cpu_pct_max_per_container": 40.9, "cpu_utilization_of_limit": 0.754, "mem_max_mib": 237.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.092, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 17.7, "cpu_pct_max_per_container": 19.3, "cpu_utilization_of_limit": 0.177, "mem_max_mib": 76.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 51.0, "cpu_pct_max_per_container": 52.7, "cpu_utilization_of_limit": 1.02, "mem_max_mib": 11.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 8}}, "pool": {"acquires": 20808, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"04a91ade61d7": 3122, "e7168005d2da": 3119}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 75.463, "p50": 7.162, "p95": 23.949, "p99": 34.558}, "mode": "closed", "ok": 6241, "ok_read_rps": 212.13333333333333, "ok_rps": 416.06666666666666, "ok_write_rps": 203.93333333333334, "rate": 0, "read_ms": {"max": 39.951, "p50": 2.009, "p95": 5.221, "p99": 10.288}, "requests": 6241, "timestamp": "2026-10-23T23:30:20Z", "warmup_s": 3, "write_ms": {"max": 75.463, "p50": 15.236, "p95": 28.796, "p99": 37.519}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 37.7, "cpu_pct_max_per_container": 41.0, "cpu_utilization_of_limit": 0.754, "mem_max_mib": 248.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.092, "mem_max_mib": 9.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 17.8, "cpu_pct_max_per_container": 19.8, "cpu_utilization_of_limit": 0.178, "mem_max_mib": 78.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 51.2, "cpu_pct_max_per_container": 51.8, "cpu_utilization_of_limit": 1.023, "mem_max_mib": 11.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 8}}, "pool": {"acquires": 21013, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"04a91ade61d7": 3270, "e7168005d2da": 3268}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 270.532, "p50": 20.541, "p95": 93.782, "p99": 124.307}, "mode": "closed", "ok": 6538, "ok_read_rps": 218.53333333333333, "ok_rps": 435.8666666666667, "ok_write_rps": 217.33333333333334, "rate": 0, "read_ms": {"max": 35.695, "p50": 4.746, "p95": 15.29, "p99": 24.223}, "requests": 6538, "timestamp": "2026-10-23T23:30:40Z", "warmup_s": 3, "write_ms": {"max": 270.532, "p50": 64.967, "p95": 104.629, "p99": 144.492}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 36.1, "cpu_pct_max_per_container": 38.1, "cpu_utilization_of_limit": 0.722, "mem_max_mib": 236.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.099, "mem_max_mib": 10.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.6, "cpu_pct_max_per_container": 36.1, "cpu_utilization_of_limit": 0.236, "mem_max_mib": 113.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 1.003, "mem_max_mib": 12.4}, "postgres_connections": {"active_max": 2, "active_mean": 0.3, "total_max": 21}}, "pool": {"acquires": 22158, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.027, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"04a91ade61d7": 3349, "e7168005d2da": 3347}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 158.003, "p50": 25.654, "p95": 88.569, "p99": 111.963}, "mode": "closed", "ok": 6696, "ok_read_rps": 223.13333333333333, "ok_rps": 446.4, "ok_write_rps": 223.26666666666668, "rate": 0, "read_ms": {"max": 53.08, "p50": 4.791, "p95": 17.067, "p99": 29.777}, "requests": 6696, "timestamp": "2026-10-23T23:31:01Z", "warmup_s": 3, "write_ms": {"max": 158.003, "p50": 64.129, "p95": 97.456, "p99": 126.787}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 36.0, "cpu_pct_max_per_container": 40.5, "cpu_utilization_of_limit": 0.72, "mem_max_mib": 247.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.098, "mem_max_mib": 10.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.1, "cpu_pct_max_per_container": 22.1, "cpu_utilization_of_limit": 0.211, "mem_max_mib": 116.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.4, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 1.008, "mem_max_mib": 12.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 21}}, "pool": {"acquires": 23154, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"04a91ade61d7": 3195, "e7168005d2da": 3200}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 172.047, "p50": 22.715, "p95": 94.101, "p99": 116.923}, "mode": "closed", "ok": 6395, "ok_read_rps": 216.53333333333333, "ok_rps": 426.3333333333333, "ok_write_rps": 209.8, "rate": 0, "read_ms": {"max": 53.872, "p50": 4.909, "p95": 18.025, "p99": 27.463}, "requests": 6395, "timestamp": "2026-10-23T23:31:21Z", "warmup_s": 3, "write_ms": {"max": 172.047, "p50": 69.311, "p95": 102.443, "p99": 129.019}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 35.0, "cpu_pct_max_per_container": 38.6, "cpu_utilization_of_limit": 0.7, "mem_max_mib": 238.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.098, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.9, "cpu_pct_max_per_container": 22.1, "cpu_utilization_of_limit": 0.209, "mem_max_mib": 118.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 1.005, "mem_max_mib": 12.4}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 21}}, "pool": {"acquires": 22044, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"04a91ade61d7": 2927, "e7168005d2da": 2925}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 648.445, "p50": 68.659, "p95": 452.444, "p99": 526.729}, "mode": "closed", "ok": 5852, "ok_read_rps": 195.53333333333333, "ok_rps": 390.1333333333333, "ok_write_rps": 194.6, "rate": 0, "read_ms": {"max": 93.021, "p50": 15.579, "p95": 46.569, "p99": 65.179}, "requests": 5852, "timestamp": "2026-10-23T23:31:41Z", "warmup_s": 3, "write_ms": {"max": 648.445, "p50": 315.487, "p95": 489.145, "p99": 552.23}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 32.9, "cpu_pct_max_per_container": 38.6, "cpu_utilization_of_limit": 0.658, "mem_max_mib": 259.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.094, "mem_max_mib": 10.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.0, "cpu_pct_max_per_container": 25.6, "cpu_utilization_of_limit": 0.22, "mem_max_mib": 166.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 1.0, "mem_max_mib": 12.7}, "postgres_connections": {"active_max": 3, "active_mean": 0.4, "total_max": 40}}, "pool": {"acquires": 19818, "empty_acquire_ratio": 0.0065, "avg_acquire_wait_ms": 0.258, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"04a91ade61d7": 3249, "e7168005d2da": 3232}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 518.905, "p50": 84.436, "p95": 411.811, "p99": 466.164}, "mode": "closed", "ok": 6481, "ok_read_rps": 209.73333333333332, "ok_rps": 432.06666666666666, "ok_write_rps": 222.33333333333334, "rate": 0, "read_ms": {"max": 75.552, "p50": 14.113, "p95": 37.928, "p99": 49.665}, "requests": 6481, "timestamp": "2026-10-23T23:32:01Z", "warmup_s": 3, "write_ms": {"max": 518.905, "p50": 275.737, "p95": 437.338, "p99": 477.451}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 36.1, "cpu_pct_max_per_container": 40.0, "cpu_utilization_of_limit": 0.721, "mem_max_mib": 89.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 10.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.1, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.221, "mem_max_mib": 170.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 12.8}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 40}}, "pool": {"acquires": 22480, "empty_acquire_ratio": 0.0029, "avg_acquire_wait_ms": 0.014, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "2x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "384M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"04a91ade61d7": 3351, "e7168005d2da": 3340}, "label": "A_fixed_total/2x0.50", "latency_ms": {"max": 549.853, "p50": 51.984, "p95": 409.978, "p99": 499.586}, "mode": "closed", "ok": 6691, "ok_read_rps": 222.46666666666667, "ok_rps": 446.06666666666666, "ok_write_rps": 223.6, "rate": 0, "read_ms": {"max": 82.8, "p50": 13.502, "p95": 35.965, "p99": 48.532}, "requests": 6691, "timestamp": "2026-10-23T23:32:22Z", "warmup_s": 3, "write_ms": {"max": 549.853, "p50": 266.972, "p95": 464.821, "p99": 517.93}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 36.3, "cpu_pct_max_per_container": 41.1, "cpu_utilization_of_limit": 0.726, "mem_max_mib": 89.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 10.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.5, "cpu_pct_max_per_container": 24.0, "cpu_utilization_of_limit": 0.225, "mem_max_mib": 172.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 1.003, "mem_max_mib": 12.8}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 40}}, "pool": {"acquires": 23330, "empty_acquire_ratio": 0.0009, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 40}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2ed0fb514bb9": 1486, "46218a455abf": 1483, "74810ab472fe": 1485, "faade19a718d": 1484}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 150.095, "p50": 9.152, "p95": 23.388, "p99": 36.464}, "mode": "closed", "ok": 5938, "ok_read_rps": 196.06666666666666, "ok_rps": 395.8666666666667, "ok_write_rps": 199.8, "rate": 0, "read_ms": {"max": 64.34, "p50": 2.188, "p95": 5.772, "p99": 12.585}, "requests": 5938, "timestamp": "2026-10-23T23:32:54Z", "warmup_s": 3, "write_ms": {"max": 150.095, "p50": 15.641, "p95": 28.634, "p99": 41.975}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.1, "cpu_pct_max_per_container": 24.5, "cpu_utilization_of_limit": 0.843, "mem_max_mib": 138.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.092, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.2, "cpu_pct_max_per_container": 22.4, "cpu_utilization_of_limit": 0.202, "mem_max_mib": 110.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.4, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 0.968, "mem_max_mib": 12.2}, "postgres_connections": {"active_max": 2, "active_mean": 0.3, "total_max": 15}}, "pool": {"acquires": 19922, "empty_acquire_ratio": 0.0004, "avg_acquire_wait_ms": 0.006, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2ed0fb514bb9": 1373, "46218a455abf": 1372, "74810ab472fe": 1372, "faade19a718d": 1372}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 249.313, "p50": 8.59, "p95": 24.961, "p99": 55.168}, "mode": "closed", "ok": 5489, "ok_read_rps": 183.46666666666667, "ok_rps": 365.93333333333334, "ok_write_rps": 182.46666666666667, "rate": 0, "read_ms": {"max": 130.45, "p50": 2.29, "p95": 6.155, "p99": 21.361}, "requests": 5489, "timestamp": "2026-10-23T23:33:16Z", "warmup_s": 3, "write_ms": {"max": 249.313, "p50": 15.718, "p95": 30.941, "p99": 80.808}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.4, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.814, "mem_max_mib": 192.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.2, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.084, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.3, "cpu_pct_max_per_container": 21.3, "cpu_utilization_of_limit": 0.183, "mem_max_mib": 115.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 46.3, "cpu_pct_max_per_container": 51.3, "cpu_utilization_of_limit": 0.926, "mem_max_mib": 11.9}, "postgres_connections": {"active_max": 2, "active_mean": 0.6, "total_max": 15}}, "pool": {"acquires": 18967, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2ed0fb514bb9": 1318, "46218a455abf": 1318, "74810ab472fe": 1320, "faade19a718d": 1317}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 502.986, "p50": 8.745, "p95": 28.272, "p99": 50.777}, "mode": "closed", "ok": 5273, "ok_read_rps": 178.13333333333333, "ok_rps": 351.53333333333336, "ok_write_rps": 173.4, "rate": 0, "read_ms": {"max": 502.986, "p50": 2.337, "p95": 7.571, "p99": 23.084}, "requests": 5273, "timestamp": "2026-10-23T23:33:38Z", "warmup_s": 3, "write_ms": {"max": 238.826, "p50": 16.31, "p95": 34.701, "p99": 63.069}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.8, "cpu_pct_max_per_container": 25.3, "cpu_utilization_of_limit": 0.833, "mem_max_mib": 192.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.4, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.088, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 18.7, "cpu_pct_max_per_container": 19.6, "cpu_utilization_of_limit": 0.187, "mem_max_mib": 120.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.4, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 0.947, "mem_max_mib": 12.0}, "postgres_connections": {"active_max": 3, "active_mean": 0.4, "total_max": 17}}, "pool": {"acquires": 18390, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2ed0fb514bb9": 1521, "46218a455abf": 1522, "74810ab472fe": 1519, "faade19a718d": 1521}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 570.474, "p50": 22.479, "p95": 97.942, "p99": 178.263}, "mode": "closed", "ok": 6083, "ok_read_rps": 205.46666666666667, "ok_rps": 405.53333333333336, "ok_write_rps": 200.06666666666666, "rate": 0, "read_ms": {"max": 460.363, "p50": 4.491, "p95": 17.829, "p99": 45.341}, "requests": 6083, "timestamp": "2026-10-23T23:34:00Z", "warmup_s": 3, "write_ms": {"max": 570.474, "p50": 65.886, "p95": 113.39, "p99": 325.157}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.1, "cpu_pct_max_per_container": 24.5, "cpu_utilization_of_limit": 0.843, "mem_max_mib": 191.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.093, "mem_max_mib": 10.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.0, "cpu_pct_max_per_container": 21.4, "cpu_utilization_of_limit": 0.2, "mem_max_mib": 143.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 46.5, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.93, "mem_max_mib": 12.8}, "postgres_connections": {"active_max": 3, "active_mean": 0.4, "total_max": 28}}, "pool": {"acquires": 20985, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.013, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2ed0fb514bb9": 1704, "46218a455abf": 1706, "74810ab472fe": 1705, "faade19a718d": 1704}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 337.948, "p50": 24.567, "p95": 86.133, "p99": 126.744}, "mode": "closed", "ok": 6819, "ok_read_rps": 227.13333333333333, "ok_rps": 454.6, "ok_write_rps": 227.46666666666667, "rate": 0, "read_ms": {"max": 86.807, "p50": 4.101, "p95": 14.328, "p99": 26.782}, "requests": 6819, "timestamp": "2026-10-23T23:34:23Z", "warmup_s": 3, "write_ms": {"max": 337.948, "p50": 61.131, "p95": 99.894, "p99": 148.774}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.3, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.89, "mem_max_mib": 192.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.094, "mem_max_mib": 10.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.2, "cpu_pct_max_per_container": 21.7, "cpu_utilization_of_limit": 0.202, "mem_max_mib": 160.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.2, "cpu_pct_max_per_container": 49.4, "cpu_utilization_of_limit": 0.944, "mem_max_mib": 16.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 30}}, "pool": {"acquires": 23733, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2ed0fb514bb9": 1613, "46218a455abf": 1616, "74810ab472fe": 1612, "faade19a718d": 1620}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 412.39, "p50": 28.206, "p95": 93.214, "p99": 141.179}, "mode": "closed", "ok": 6461, "ok_read_rps": 213.53333333333333, "ok_rps": 430.73333333333335, "ok_write_rps": 217.2, "rate": 0, "read_ms": {"max": 243.632, "p50": 4.315, "p95": 17.322, "p99": 32.961}, "requests": 6461, "timestamp": "2026-10-23T23:34:45Z", "warmup_s": 3, "write_ms": {"max": 412.39, "p50": 63.243, "p95": 108.469, "p99": 163.308}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.5, "cpu_pct_max_per_container": 24.2, "cpu_utilization_of_limit": 0.861, "mem_max_mib": 191.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.4, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.089, "mem_max_mib": 10.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.5, "cpu_pct_max_per_container": 21.6, "cpu_utilization_of_limit": 0.195, "mem_max_mib": 166.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 45.5, "cpu_pct_max_per_container": 49.9, "cpu_utilization_of_limit": 0.911, "mem_max_mib": 17.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 31}}, "pool": {"acquires": 22362, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.006, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2ed0fb514bb9": 1764, "46218a455abf": 1770, "74810ab472fe": 1759, "faade19a718d": 1756}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 1248.667, "p50": 53.353, "p95": 331.74, "p99": 590.91}, "mode": "closed", "ok": 7049, "ok_read_rps": 238.73333333333332, "ok_rps": 469.93333333333334, "ok_write_rps": 231.2, "rate": 0, "read_ms": {"max": 639.463, "p50": 10.993, "p95": 34.629, "p99": 91.25}, "requests": 7049, "timestamp": "2026-10-23T23:35:07Z", "warmup_s": 3, "write_ms": {"max": 1248.667, "p50": 245.767, "p95": 382.625, "p99": 722.652}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.6, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.823, "mem_max_mib": 191.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.094, "mem_max_mib": 10.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.9, "cpu_pct_max_per_container": 34.2, "cpu_utilization_of_limit": 0.239, "mem_max_mib": 247.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 45.6, "cpu_pct_max_per_container": 49.4, "cpu_utilization_of_limit": 0.913, "mem_max_mib": 21.2}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 64}}, "pool": {"acquires": 24461, "empty_acquire_ratio": 0.0026, "avg_acquire_wait_ms": 0.1, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2ed0fb514bb9": 1800, "46218a455abf": 1798, "74810ab472fe": 1794, "faade19a718d": 1793}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 508.337, "p50": 62.753, "p95": 326.687, "p99": 406.512}, "mode": "closed", "ok": 7185, "ok_read_rps": 241.26666666666668, "ok_rps": 479, "ok_write_rps": 237.73333333333332, "rate": 0, "read_ms": {"max": 138.679, "p50": 11.429, "p95": 33.183, "p99": 57.651}, "requests": 7185, "timestamp": "2026-10-23T23:35:38Z", "warmup_s": 3, "write_ms": {"max": 508.337, "p50": 245.431, "p95": 354.164, "p99": 451.095}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 13.2, "cpu_pct_max_per_container": 22.0, "cpu_utilization_of_limit": 0.527, "mem_max_mib": 192.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 2.4, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.048, "mem_max_mib": 10.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 13.2, "cpu_pct_max_per_container": 25.4, "cpu_utilization_of_limit": 0.132, "mem_max_mib": 277.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 22.7, "cpu_pct_max_per_container": 49.9, "cpu_utilization_of_limit": 0.454, "mem_max_mib": 17.1}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 77}}, "pool": {"acquires": 24860, "empty_acquire_ratio": 0.0014, "avg_acquire_wait_ms": 0.05, "pool_max_conns_total": 80}} +{"series": "A_fixed_total", "config": "4x0.25", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.25", "API_MEMORY": "192M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"2ed0fb514bb9": 1779, "46218a455abf": 1782, "74810ab472fe": 1776, "faade19a718d": 1781}, "label": "A_fixed_total/4x0.25", "latency_ms": {"max": 472.087, "p50": 34.27, "p95": 323.84, "p99": 382.344}, "mode": "closed", "ok": 7118, "ok_read_rps": 242.6, "ok_rps": 474.53333333333336, "ok_write_rps": 231.93333333333334, "rate": 0, "read_ms": {"max": 79.994, "p50": 11.697, "p95": 28.426, "p99": 45.041}, "requests": 7118, "timestamp": "2026-10-23T23:36:10Z", "warmup_s": 3, "write_ms": {"max": 472.087, "p50": 252.893, "p95": 349.602, "p99": 408.117}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 12.4, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.496, "mem_max_mib": 192.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 2.4, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.047, "mem_max_mib": 10.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 10.1, "cpu_pct_max_per_container": 23.3, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 284.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 19.3, "cpu_pct_max_per_container": 47.5, "cpu_utilization_of_limit": 0.386, "mem_max_mib": 14.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 76}}, "pool": {"acquires": 24889, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"50f741b03cfb": 5400}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 68.714, "p50": 10.399, "p95": 40.415, "p99": 45.861}, "mode": "closed", "ok": 5400, "ok_read_rps": 183, "ok_rps": 360, "ok_write_rps": 177, "rate": 0, "read_ms": {"max": 35.983, "p50": 2.033, "p95": 5.545, "p99": 30.135}, "requests": 5400, "timestamp": "2026-10-23T23:26:43Z", "warmup_s": 3, "write_ms": {"max": 68.714, "p50": 14.235, "p95": 43.272, "p99": 48.295}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.4, "cpu_pct_max_per_container": 51.4, "cpu_utilization_of_limit": 1.008, "mem_max_mib": 138.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.5, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.09, "mem_max_mib": 10.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.4, "cpu_pct_max_per_container": 22.6, "cpu_utilization_of_limit": 0.204, "mem_max_mib": 39.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 44.4, "cpu_pct_max_per_container": 46.3, "cpu_utilization_of_limit": 0.889, "mem_max_mib": 11.4}, "postgres_connections": {"active_max": 2, "active_mean": 0.4, "total_max": 4}}, "pool": {"acquires": 18429, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"50f741b03cfb": 5189}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 180.823, "p50": 10.663, "p95": 41.069, "p99": 47.769}, "mode": "closed", "ok": 5189, "ok_read_rps": 173.33333333333334, "ok_rps": 345.93333333333334, "ok_write_rps": 172.6, "rate": 0, "read_ms": {"max": 44.097, "p50": 2.075, "p95": 5.963, "p99": 29.715}, "requests": 5189, "timestamp": "2026-10-23T23:27:06Z", "warmup_s": 3, "write_ms": {"max": 180.823, "p50": 14.315, "p95": 43.656, "p99": 53.587}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 49.1, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 0.982, "mem_max_mib": 221.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.3, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.087, "mem_max_mib": 10.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.0, "cpu_pct_max_per_container": 22.4, "cpu_utilization_of_limit": 0.19, "mem_max_mib": 43.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 43.3, "cpu_pct_max_per_container": 49.6, "cpu_utilization_of_limit": 0.866, "mem_max_mib": 10.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 4}}, "pool": {"acquires": 17690, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"50f741b03cfb": 5308}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 77.252, "p50": 10.891, "p95": 39.693, "p99": 45.05}, "mode": "closed", "ok": 5308, "ok_read_rps": 173.86666666666667, "ok_rps": 353.8666666666667, "ok_write_rps": 180, "rate": 0, "read_ms": {"max": 50.952, "p50": 2.05, "p95": 5.698, "p99": 29.707}, "requests": 5308, "timestamp": "2026-10-23T23:27:28Z", "warmup_s": 3, "write_ms": {"max": 77.252, "p50": 14.233, "p95": 42.091, "p99": 48.972}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 1.002, "mem_max_mib": 215.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.3, "cpu_pct_max_per_container": 4.5, "cpu_utilization_of_limit": 0.087, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.0, "cpu_pct_max_per_container": 21.5, "cpu_utilization_of_limit": 0.19, "mem_max_mib": 46.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 43.7, "cpu_pct_max_per_container": 45.6, "cpu_utilization_of_limit": 0.874, "mem_max_mib": 10.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 4}}, "pool": {"acquires": 18163, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"50f741b03cfb": 6001}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 163.096, "p50": 32.886, "p95": 93.43, "p99": 109.341}, "mode": "closed", "ok": 6001, "ok_read_rps": 204.93333333333334, "ok_rps": 400.06666666666666, "ok_write_rps": 195.13333333333333, "rate": 0, "read_ms": {"max": 66.674, "p50": 4.238, "p95": 27.04, "p99": 38.548}, "requests": 6001, "timestamp": "2026-10-23T23:27:50Z", "warmup_s": 3, "write_ms": {"max": 163.096, "p50": 77.882, "p95": 100.473, "p99": 117.187}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.999, "mem_max_mib": 224.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.102, "mem_max_mib": 10.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.2, "cpu_pct_max_per_container": 25.5, "cpu_utilization_of_limit": 0.212, "mem_max_mib": 76.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 44.6, "cpu_pct_max_per_container": 47.9, "cpu_utilization_of_limit": 0.892, "mem_max_mib": 10.9}, "postgres_connections": {"active_max": 2, "active_mean": 0.6, "total_max": 16}}, "pool": {"acquires": 20672, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.036, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"50f741b03cfb": 5927}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 168.836, "p50": 39.813, "p95": 91.568, "p99": 116.109}, "mode": "closed", "ok": 5927, "ok_read_rps": 195.6, "ok_rps": 395.1333333333333, "ok_write_rps": 199.53333333333333, "rate": 0, "read_ms": {"max": 57.384, "p50": 4.066, "p95": 29.79, "p99": 39.287}, "requests": 5927, "timestamp": "2026-10-23T23:28:12Z", "warmup_s": 3, "write_ms": {"max": 168.836, "p50": 77.296, "p95": 99.413, "p99": 127.198}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.999, "mem_max_mib": 52.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.099, "mem_max_mib": 10.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.1, "cpu_pct_max_per_container": 21.8, "cpu_utilization_of_limit": 0.191, "mem_max_mib": 79.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 44.8, "cpu_pct_max_per_container": 47.6, "cpu_utilization_of_limit": 0.897, "mem_max_mib": 10.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 16}}, "pool": {"acquires": 20535, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"50f741b03cfb": 5708}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 217.981, "p50": 37.851, "p95": 97.279, "p99": 122.811}, "mode": "closed", "ok": 5708, "ok_read_rps": 190.33333333333334, "ok_rps": 380.53333333333336, "ok_write_rps": 190.2, "rate": 0, "read_ms": {"max": 68.341, "p50": 4.189, "p95": 28.23, "p99": 39.283}, "requests": 5708, "timestamp": "2026-10-23T23:28:34Z", "warmup_s": 3, "write_ms": {"max": 217.981, "p50": 79.663, "p95": 107.761, "p99": 134.988}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 49.0, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 0.979, "mem_max_mib": 53.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.099, "mem_max_mib": 10.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 21.1, "cpu_utilization_of_limit": 0.196, "mem_max_mib": 81.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 42.8, "cpu_pct_max_per_container": 45.6, "cpu_utilization_of_limit": 0.855, "mem_max_mib": 10.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 16}}, "pool": {"acquires": 19934, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"50f741b03cfb": 5330}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 442.501, "p50": 287.702, "p95": 378.478, "p99": 393.952}, "mode": "closed", "ok": 5330, "ok_read_rps": 176.46666666666667, "ok_rps": 355.3333333333333, "ok_write_rps": 178.86666666666667, "rate": 0, "read_ms": {"max": 68.612, "p50": 12.07, "p95": 46.756, "p99": 53.279}, "requests": 5330, "timestamp": "2026-10-23T23:28:57Z", "warmup_s": 3, "write_ms": {"max": 442.501, "p50": 334.986, "p95": 385.979, "p99": 404.231}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 49.5, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.991, "mem_max_mib": 79.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.092, "mem_max_mib": 11.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.2, "cpu_pct_max_per_container": 36.4, "cpu_utilization_of_limit": 0.212, "mem_max_mib": 100.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 41.8, "cpu_pct_max_per_container": 43.7, "cpu_utilization_of_limit": 0.836, "mem_max_mib": 17.7}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 20}}, "pool": {"acquires": 18893, "empty_acquire_ratio": 0.0137, "avg_acquire_wait_ms": 0.136, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"50f741b03cfb": 5523}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 451.808, "p50": 52.757, "p95": 381.455, "p99": 406.445}, "mode": "closed", "ok": 5523, "ok_read_rps": 187.6, "ok_rps": 368.2, "ok_write_rps": 180.6, "rate": 0, "read_ms": {"max": 68.866, "p50": 12.413, "p95": 47.057, "p99": 55.545}, "requests": 5523, "timestamp": "2026-10-23T23:29:21Z", "warmup_s": 3, "write_ms": {"max": 451.808, "p50": 326.209, "p95": 396.244, "p99": 412.435}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 49.5, "cpu_pct_max_per_container": 50.3, "cpu_utilization_of_limit": 0.989, "mem_max_mib": 68.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.092, "mem_max_mib": 11.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 22.7, "cpu_utilization_of_limit": 0.196, "mem_max_mib": 95.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 40.6, "cpu_pct_max_per_container": 43.9, "cpu_utilization_of_limit": 0.811, "mem_max_mib": 11.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 20}}, "pool": {"acquires": 19395, "empty_acquire_ratio": 0.0152, "avg_acquire_wait_ms": 0.048, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "1x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"50f741b03cfb": 5365}, "label": "B_scale_out/1x0.50", "latency_ms": {"max": 469.654, "p50": 61.605, "p95": 387.993, "p99": 431.668}, "mode": "closed", "ok": 5365, "ok_read_rps": 179.6, "ok_rps": 357.6666666666667, "ok_write_rps": 178.06666666666666, "rate": 0, "read_ms": {"max": 80.771, "p50": 12.049, "p95": 46.3, "p99": 55.295}, "requests": 5365, "timestamp": "2026-10-23T23:29:45Z", "warmup_s": 3, "write_ms": {"max": 469.654, "p50": 333.234, "p95": 409.909, "p99": 448.95}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.992, "mem_max_mib": 74.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.5, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.09, "mem_max_mib": 11.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.0, "cpu_pct_max_per_container": 48.4, "cpu_utilization_of_limit": 0.23, "mem_max_mib": 101.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 41.4, "cpu_pct_max_per_container": 44.4, "cpu_utilization_of_limit": 0.828, "mem_max_mib": 11.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 20}}, "pool": {"acquires": 18989, "empty_acquire_ratio": 0.0151, "avg_acquire_wait_ms": 0.079, "pool_max_conns_total": 20}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 2902, "f5d97f666c30": 2904}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 180.043, "p50": 10.152, "p95": 26.343, "p99": 34.548}, "mode": "closed", "ok": 5806, "ok_read_rps": 193.8, "ok_rps": 387.06666666666666, "ok_write_rps": 193.26666666666668, "rate": 0, "read_ms": {"max": 39.13, "p50": 2.396, "p95": 5.911, "p99": 15.612}, "requests": 5806, "timestamp": "2026-10-23T23:30:19Z", "warmup_s": 3, "write_ms": {"max": 180.043, "p50": 15.379, "p95": 30.656, "p99": 40.742}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 34.5, "cpu_pct_max_per_container": 39.0, "cpu_utilization_of_limit": 0.689, "mem_max_mib": 138.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 11.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.8, "cpu_pct_max_per_container": 23.2, "cpu_utilization_of_limit": 0.218, "mem_max_mib": 66.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.7, "cpu_pct_max_per_container": 51.6, "cpu_utilization_of_limit": 1.014, "mem_max_mib": 11.6}, "postgres_connections": {"active_max": 4, "active_mean": 0.9, "total_max": 6}}, "pool": {"acquires": 19847, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 2894, "f5d97f666c30": 2894}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 48.881, "p50": 10.538, "p95": 25.852, "p99": 33.053}, "mode": "closed", "ok": 5788, "ok_read_rps": 191.66666666666666, "ok_rps": 385.8666666666667, "ok_write_rps": 194.2, "rate": 0, "read_ms": {"max": 22.338, "p50": 2.524, "p95": 6.485, "p99": 13.38}, "requests": 5788, "timestamp": "2026-10-23T23:30:42Z", "warmup_s": 3, "write_ms": {"max": 48.881, "p50": 15.609, "p95": 29.054, "p99": 37.378}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 34.3, "cpu_pct_max_per_container": 36.8, "cpu_utilization_of_limit": 0.685, "mem_max_mib": 239.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 11.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.8, "cpu_pct_max_per_container": 23.9, "cpu_utilization_of_limit": 0.218, "mem_max_mib": 68.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.7, "cpu_pct_max_per_container": 51.4, "cpu_utilization_of_limit": 1.014, "mem_max_mib": 11.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 6}}, "pool": {"acquires": 19541, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 2917, "f5d97f666c30": 2917}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 71.529, "p50": 10.029, "p95": 26.372, "p99": 35.122}, "mode": "closed", "ok": 5834, "ok_read_rps": 193.33333333333334, "ok_rps": 388.93333333333334, "ok_write_rps": 195.6, "rate": 0, "read_ms": {"max": 39.066, "p50": 2.469, "p95": 6.499, "p99": 15.209}, "requests": 5834, "timestamp": "2026-10-23T23:31:05Z", "warmup_s": 3, "write_ms": {"max": 71.529, "p50": 15.157, "p95": 29.928, "p99": 41.165}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 34.3, "cpu_pct_max_per_container": 38.3, "cpu_utilization_of_limit": 0.685, "mem_max_mib": 233.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 11.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.8, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.218, "mem_max_mib": 70.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 51.0, "cpu_pct_max_per_container": 51.9, "cpu_utilization_of_limit": 1.019, "mem_max_mib": 11.4}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 7}}, "pool": {"acquires": 19843, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 3163, "f5d97f666c30": 3162}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 207.253, "p50": 26.273, "p95": 89.355, "p99": 117.631}, "mode": "closed", "ok": 6325, "ok_read_rps": 212.6, "ok_rps": 421.6666666666667, "ok_write_rps": 209.06666666666666, "rate": 0, "read_ms": {"max": 152.746, "p50": 5.249, "p95": 17.289, "p99": 26.802}, "requests": 6325, "timestamp": "2026-10-23T23:31:27Z", "warmup_s": 3, "write_ms": {"max": 207.253, "p50": 67.707, "p95": 100.523, "p99": 129.026}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 33.7, "cpu_pct_max_per_container": 35.7, "cpu_utilization_of_limit": 0.674, "mem_max_mib": 230.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.4, "cpu_pct_max_per_container": 5.8, "cpu_utilization_of_limit": 0.108, "mem_max_mib": 11.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 26.0, "cpu_pct_max_per_container": 27.5, "cpu_utilization_of_limit": 0.26, "mem_max_mib": 104.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.3, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 1.006, "mem_max_mib": 12.3}, "postgres_connections": {"active_max": 4, "active_mean": 0.7, "total_max": 19}}, "pool": {"acquires": 21615, "empty_acquire_ratio": 0.0007, "avg_acquire_wait_ms": 0.04, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 3120, "f5d97f666c30": 3121}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 198.299, "p50": 24.274, "p95": 93.587, "p99": 118.239}, "mode": "closed", "ok": 6241, "ok_read_rps": 211.66666666666666, "ok_rps": 416.06666666666666, "ok_write_rps": 204.4, "rate": 0, "read_ms": {"max": 56.695, "p50": 5.536, "p95": 18.035, "p99": 27.534}, "requests": 6241, "timestamp": "2026-10-23T23:31:49Z", "warmup_s": 3, "write_ms": {"max": 198.299, "p50": 69.012, "p95": 104.244, "p99": 134.311}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 33.2, "cpu_pct_max_per_container": 35.6, "cpu_utilization_of_limit": 0.665, "mem_max_mib": 225.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.4, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.108, "mem_max_mib": 11.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 28.4, "cpu_pct_max_per_container": 42.2, "cpu_utilization_of_limit": 0.284, "mem_max_mib": 117.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 0.991, "mem_max_mib": 12.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 24}}, "pool": {"acquires": 21427, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 3207, "f5d97f666c30": 3218}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 141.794, "p50": 25.013, "p95": 90.252, "p99": 107.778}, "mode": "closed", "ok": 6425, "ok_read_rps": 216.8, "ok_rps": 428.3333333333333, "ok_write_rps": 211.53333333333333, "rate": 0, "read_ms": {"max": 43.931, "p50": 5.255, "p95": 17.822, "p99": 26.862}, "requests": 6425, "timestamp": "2026-10-23T23:32:12Z", "warmup_s": 3, "write_ms": {"max": 141.794, "p50": 67.228, "p95": 98.96, "p99": 113.695}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 33.7, "cpu_pct_max_per_container": 35.9, "cpu_utilization_of_limit": 0.674, "mem_max_mib": 246.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.6, "cpu_pct_max_per_container": 5.8, "cpu_utilization_of_limit": 0.111, "mem_max_mib": 11.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 26.2, "cpu_pct_max_per_container": 28.7, "cpu_utilization_of_limit": 0.262, "mem_max_mib": 120.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.4, "cpu_pct_max_per_container": 51.3, "cpu_utilization_of_limit": 1.007, "mem_max_mib": 19.0}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 23}}, "pool": {"acquires": 22119, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 3238, "f5d97f666c30": 3221}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 494.173, "p50": 39.119, "p95": 396.877, "p99": 445.119}, "mode": "closed", "ok": 6459, "ok_read_rps": 220.6, "ok_rps": 430.6, "ok_write_rps": 210, "rate": 0, "read_ms": {"max": 71.45, "p50": 14.481, "p95": 33.865, "p99": 45.592}, "requests": 6459, "timestamp": "2026-10-23T23:32:34Z", "warmup_s": 3, "write_ms": {"max": 494.173, "p50": 299.598, "p95": 423.066, "p99": 455.633}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 34.7, "cpu_pct_max_per_container": 37.2, "cpu_utilization_of_limit": 0.694, "mem_max_mib": 252.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.5, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.11, "mem_max_mib": 12.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 26.9, "cpu_pct_max_per_container": 31.9, "cpu_utilization_of_limit": 0.269, "mem_max_mib": 170.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.8, "cpu_pct_max_per_container": 51.3, "cpu_utilization_of_limit": 0.997, "mem_max_mib": 12.7}, "postgres_connections": {"active_max": 2, "active_mean": 0.4, "total_max": 40}}, "pool": {"acquires": 22118, "empty_acquire_ratio": 0.0061, "avg_acquire_wait_ms": 0.153, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 3118, "f5d97f666c30": 3121}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 558.482, "p50": 76.174, "p95": 430.115, "p99": 482.707}, "mode": "closed", "ok": 6239, "ok_read_rps": 206.2, "ok_rps": 415.93333333333334, "ok_write_rps": 209.73333333333332, "rate": 0, "read_ms": {"max": 83.538, "p50": 14.476, "p95": 35.692, "p99": 52.487}, "requests": 6239, "timestamp": "2026-10-23T23:32:58Z", "warmup_s": 3, "write_ms": {"max": 558.482, "p50": 281.434, "p95": 458.037, "p99": 496.359}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 33.6, "cpu_pct_max_per_container": 36.8, "cpu_utilization_of_limit": 0.671, "mem_max_mib": 180.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 26.1, "cpu_pct_max_per_container": 28.8, "cpu_utilization_of_limit": 0.261, "mem_max_mib": 171.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 44.5, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.89, "mem_max_mib": 12.9}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 40}}, "pool": {"acquires": 21526, "empty_acquire_ratio": 0.0093, "avg_acquire_wait_ms": 0.08, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "2x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 3199, "f5d97f666c30": 3201}, "label": "B_scale_out/2x0.50", "latency_ms": {"max": 505.32, "p50": 115.005, "p95": 404.134, "p99": 457.296}, "mode": "closed", "ok": 6400, "ok_read_rps": 208.66666666666666, "ok_rps": 426.6666666666667, "ok_write_rps": 218, "rate": 0, "read_ms": {"max": 58.945, "p50": 14.059, "p95": 33.298, "p99": 42.729}, "requests": 6400, "timestamp": "2026-10-23T23:33:20Z", "warmup_s": 3, "write_ms": {"max": 505.32, "p50": 288.042, "p95": 435.532, "p99": 469.112}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 33.4, "cpu_pct_max_per_container": 37.4, "cpu_utilization_of_limit": 0.669, "mem_max_mib": 58.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.2, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.105, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 26.5, "cpu_pct_max_per_container": 28.5, "cpu_utilization_of_limit": 0.265, "mem_max_mib": 169.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 1.002, "mem_max_mib": 13.0}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 40}}, "pool": {"acquires": 22059, "empty_acquire_ratio": 0.0037, "avg_acquire_wait_ms": 0.007, "pool_max_conns_total": 40}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 1487, "8759eb8c2e05": 1487, "e59a806e8df9": 1489, "f5d97f666c30": 1488}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 79.651, "p50": 8.182, "p95": 24.871, "p99": 33.282}, "mode": "closed", "ok": 5951, "ok_read_rps": 205.26666666666668, "ok_rps": 396.73333333333335, "ok_write_rps": 191.46666666666667, "rate": 0, "read_ms": {"max": 28.181, "p50": 2.524, "p95": 6.714, "p99": 14.278}, "requests": 5951, "timestamp": "2026-10-23T23:33:49Z", "warmup_s": 3, "write_ms": {"max": 79.651, "p50": 15.69, "p95": 28.951, "p99": 39.636}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.3, "cpu_pct_max_per_container": 22.0, "cpu_utilization_of_limit": 0.385, "mem_max_mib": 137.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.2, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.103, "mem_max_mib": 11.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 26.5, "cpu_pct_max_per_container": 44.3, "cpu_utilization_of_limit": 0.265, "mem_max_mib": 181.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.4, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.988, "mem_max_mib": 12.7}, "postgres_connections": {"active_max": 3, "active_mean": 0.7, "total_max": 45}}, "pool": {"acquires": 20009, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 1454, "8759eb8c2e05": 1452, "e59a806e8df9": 1453, "f5d97f666c30": 1451}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 60.622, "p50": 10.136, "p95": 24.515, "p99": 33.898}, "mode": "closed", "ok": 5810, "ok_read_rps": 191.2, "ok_rps": 387.3333333333333, "ok_write_rps": 196.13333333333333, "rate": 0, "read_ms": {"max": 49.383, "p50": 2.636, "p95": 6.896, "p99": 13.675}, "requests": 5810, "timestamp": "2026-10-23T23:34:11Z", "warmup_s": 3, "write_ms": {"max": 60.622, "p50": 15.567, "p95": 27.602, "p99": 37.545}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.5, "cpu_pct_max_per_container": 22.8, "cpu_utilization_of_limit": 0.389, "mem_max_mib": 237.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 11.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.9, "cpu_pct_max_per_container": 24.7, "cpu_utilization_of_limit": 0.229, "mem_max_mib": 184.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 1.005, "mem_max_mib": 12.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.6, "total_max": 45}}, "pool": {"acquires": 19882, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 1392, "8759eb8c2e05": 1392, "e59a806e8df9": 1392, "f5d97f666c30": 1392}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 190.526, "p50": 10.141, "p95": 25.166, "p99": 34.3}, "mode": "closed", "ok": 5568, "ok_read_rps": 183.53333333333333, "ok_rps": 371.2, "ok_write_rps": 187.66666666666666, "rate": 0, "read_ms": {"max": 38.463, "p50": 2.699, "p95": 6.824, "p99": 12.912}, "requests": 5568, "timestamp": "2026-10-23T23:34:33Z", "warmup_s": 3, "write_ms": {"max": 190.526, "p50": 16.308, "p95": 28.848, "p99": 40.556}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.2, "cpu_pct_max_per_container": 22.3, "cpu_utilization_of_limit": 0.383, "mem_max_mib": 224.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 11.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.4, "cpu_pct_max_per_container": 25.7, "cpu_utilization_of_limit": 0.234, "mem_max_mib": 189.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.3, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.005, "mem_max_mib": 12.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 45}}, "pool": {"acquires": 19160, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 1508, "8759eb8c2e05": 1514, "e59a806e8df9": 1510, "f5d97f666c30": 1509}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 169.688, "p50": 32.256, "p95": 95.638, "p99": 115.969}, "mode": "closed", "ok": 6041, "ok_read_rps": 201, "ok_rps": 402.73333333333335, "ok_write_rps": 201.73333333333332, "rate": 0, "read_ms": {"max": 60.947, "p50": 5.259, "p95": 16.129, "p99": 25.537}, "requests": 6041, "timestamp": "2026-10-23T23:34:56Z", "warmup_s": 3, "write_ms": {"max": 169.688, "p50": 70.01, "p95": 104.504, "p99": 125.368}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.0, "cpu_pct_max_per_container": 21.8, "cpu_utilization_of_limit": 0.38, "mem_max_mib": 238.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.2, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.104, "mem_max_mib": 11.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 29.8, "cpu_pct_max_per_container": 55.8, "cpu_utilization_of_limit": 0.298, "mem_max_mib": 221.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.0, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.981, "mem_max_mib": 12.8}, "postgres_connections": {"active_max": 3, "active_mean": 0.6, "total_max": 54}}, "pool": {"acquires": 20515, "empty_acquire_ratio": 0.0004, "avg_acquire_wait_ms": 0.034, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 1523, "8759eb8c2e05": 1523, "e59a806e8df9": 1520, "f5d97f666c30": 1520}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 162.421, "p50": 21.655, "p95": 94.406, "p99": 119.368}, "mode": "closed", "ok": 6086, "ok_read_rps": 205.66666666666666, "ok_rps": 405.73333333333335, "ok_write_rps": 200.06666666666666, "rate": 0, "read_ms": {"max": 38.154, "p50": 5.349, "p95": 15.744, "p99": 23.184}, "requests": 6086, "timestamp": "2026-10-23T23:35:17Z", "warmup_s": 3, "write_ms": {"max": 162.421, "p50": 70.72, "p95": 105.389, "p99": 127.78}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.4, "cpu_pct_max_per_container": 21.9, "cpu_utilization_of_limit": 0.389, "mem_max_mib": 246.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.4, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.107, "mem_max_mib": 11.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 26.1, "cpu_pct_max_per_container": 27.3, "cpu_utilization_of_limit": 0.261, "mem_max_mib": 216.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 19.4}, "postgres_connections": {"active_max": 1, "active_mean": 0.6, "total_max": 54}}, "pool": {"acquires": 20878, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 1466, "8759eb8c2e05": 1466, "e59a806e8df9": 1471, "f5d97f666c30": 1466}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 197.333, "p50": 39.991, "p95": 96.041, "p99": 124.966}, "mode": "closed", "ok": 5869, "ok_read_rps": 194.26666666666668, "ok_rps": 391.26666666666665, "ok_write_rps": 197, "rate": 0, "read_ms": {"max": 73.476, "p50": 5.324, "p95": 15.54, "p99": 26.028}, "requests": 5869, "timestamp": "2026-10-23T23:35:40Z", "warmup_s": 3, "write_ms": {"max": 197.333, "p50": 71.331, "p95": 107.21, "p99": 136.099}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.1, "cpu_pct_max_per_container": 21.6, "cpu_utilization_of_limit": 0.381, "mem_max_mib": 242.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.3, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.107, "mem_max_mib": 11.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 25.6, "cpu_pct_max_per_container": 27.2, "cpu_utilization_of_limit": 0.256, "mem_max_mib": 223.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.9, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 0.999, "mem_max_mib": 12.9}, "postgres_connections": {"active_max": 3, "active_mean": 0.4, "total_max": 54}}, "pool": {"acquires": 20414, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 1574, "8759eb8c2e05": 1563, "e59a806e8df9": 1572, "f5d97f666c30": 1576}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 421.671, "p50": 229.027, "p95": 341.03, "p99": 371.812}, "mode": "closed", "ok": 6285, "ok_read_rps": 206.53333333333333, "ok_rps": 419, "ok_write_rps": 212.46666666666667, "rate": 0, "read_ms": {"max": 82.262, "p50": 12.85, "p95": 26.722, "p99": 37.439}, "requests": 6285, "timestamp": "2026-10-23T23:36:02Z", "warmup_s": 3, "write_ms": {"max": 421.671, "p50": 280.329, "p95": 358.21, "p99": 383.369}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.4, "cpu_pct_max_per_container": 21.0, "cpu_utilization_of_limit": 0.368, "mem_max_mib": 242.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.6, "cpu_pct_max_per_container": 6.0, "cpu_utilization_of_limit": 0.113, "mem_max_mib": 12.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 28.1, "cpu_pct_max_per_container": 30.9, "cpu_utilization_of_limit": 0.281, "mem_max_mib": 282.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 14.1}, "postgres_connections": {"active_max": 3, "active_mean": 0.7, "total_max": 80}}, "pool": {"acquires": 21527, "empty_acquire_ratio": 0.0065, "avg_acquire_wait_ms": 0.469, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 1571, "8759eb8c2e05": 1574, "e59a806e8df9": 1574, "f5d97f666c30": 1584}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 434.235, "p50": 182.649, "p95": 343.641, "p99": 390.485}, "mode": "closed", "ok": 6303, "ok_read_rps": 209.93333333333334, "ok_rps": 420.2, "ok_write_rps": 210.26666666666668, "rate": 0, "read_ms": {"max": 97.706, "p50": 13.273, "p95": 30.757, "p99": 46}, "requests": 6303, "timestamp": "2026-10-23T23:36:24Z", "warmup_s": 3, "write_ms": {"max": 434.235, "p50": 282.753, "p95": 364.367, "p99": 404.991}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.3, "cpu_pct_max_per_container": 21.9, "cpu_utilization_of_limit": 0.367, "mem_max_mib": 63.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.4, "cpu_pct_max_per_container": 5.8, "cpu_utilization_of_limit": 0.108, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 27.3, "cpu_pct_max_per_container": 30.7, "cpu_utilization_of_limit": 0.273, "mem_max_mib": 287.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.6, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.971, "mem_max_mib": 14.0}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 80}}, "pool": {"acquires": 21777, "empty_acquire_ratio": 0.0004, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "B_scale_out", "config": "4x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 1523, "8759eb8c2e05": 1536, "e59a806e8df9": 1528, "f5d97f666c30": 1527}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 462.871, "p50": 213.437, "p95": 357.106, "p99": 416.866}, "mode": "closed", "ok": 6114, "ok_read_rps": 203.13333333333333, "ok_rps": 407.6, "ok_write_rps": 204.46666666666667, "rate": 0, "read_ms": {"max": 52.386, "p50": 13.066, "p95": 26.731, "p99": 34.753}, "requests": 6114, "timestamp": "2026-10-23T23:36:47Z", "warmup_s": 3, "write_ms": {"max": 462.871, "p50": 288.351, "p95": 379.333, "p99": 427.916}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.4, "cpu_pct_max_per_container": 21.4, "cpu_utilization_of_limit": 0.367, "mem_max_mib": 61.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.3, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.106, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 29.9, "cpu_pct_max_per_container": 48.2, "cpu_utilization_of_limit": 0.299, "mem_max_mib": 291.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.7, "cpu_pct_max_per_container": 52.3, "cpu_utilization_of_limit": 0.973, "mem_max_mib": 14.3}, "postgres_connections": {"active_max": 3, "active_mean": 0.9, "total_max": 81}}, "pool": {"acquires": 21361, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1243, "2ef3d3401cb2": 1242, "533549b432a8": 1242, "8f4056cc3ff4": 1241}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 206.674, "p50": 22.165, "p95": 118.795, "p99": 150.913}, "mode": "closed", "ok": 4968, "ok_read_rps": 168.6, "ok_rps": 331.2, "ok_write_rps": 162.6, "rate": 0, "read_ms": {"max": 44.795, "p50": 5.456, "p95": 16.323, "p99": 25.96}, "requests": 4968, "timestamp": "2026-10-23T23:26:29Z", "warmup_s": 3, "write_ms": {"max": 206.674, "p50": 89.332, "p95": 132.244, "p99": 171.409}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.7, "cpu_pct_max_per_container": 21.1, "cpu_utilization_of_limit": 0.354, "mem_max_mib": 138.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.094, "mem_max_mib": 8.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.6, "cpu_pct_max_per_container": 22.5, "cpu_utilization_of_limit": 0.206, "mem_max_mib": 80.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.4, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.008, "mem_max_mib": 11.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 21}}, "pool": {"acquires": 17106, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.034, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1306, "2ef3d3401cb2": 1308, "533549b432a8": 1310, "8f4056cc3ff4": 1310}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 242.967, "p50": 36.927, "p95": 116.484, "p99": 143.198}, "mode": "closed", "ok": 5234, "ok_read_rps": 172.46666666666667, "ok_rps": 348.93333333333334, "ok_write_rps": 176.46666666666667, "rate": 0, "read_ms": {"max": 61.356, "p50": 5.422, "p95": 16.465, "p99": 25.069}, "requests": 5234, "timestamp": "2026-10-23T23:26:49Z", "warmup_s": 3, "write_ms": {"max": 242.967, "p50": 78.066, "p95": 126.752, "p99": 157.955}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.2, "cpu_pct_max_per_container": 23.7, "cpu_utilization_of_limit": 0.384, "mem_max_mib": 255.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 8.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.4, "cpu_pct_max_per_container": 23.6, "cpu_utilization_of_limit": 0.214, "mem_max_mib": 84.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.991, "mem_max_mib": 11.2}, "postgres_connections": {"active_max": 16, "active_mean": 2.3, "total_max": 22}}, "pool": {"acquires": 18183, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1104, "2ef3d3401cb2": 1100, "533549b432a8": 1099, "8f4056cc3ff4": 1101}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 224.267, "p50": 38.097, "p95": 134.642, "p99": 171.335}, "mode": "closed", "ok": 4404, "ok_read_rps": 145.73333333333332, "ok_rps": 293.6, "ok_write_rps": 147.86666666666667, "rate": 0, "read_ms": {"max": 41.9, "p50": 6.18, "p95": 19.781, "p99": 29.134}, "requests": 4404, "timestamp": "2026-10-23T23:27:10Z", "warmup_s": 3, "write_ms": {"max": 224.267, "p50": 97.02, "p95": 152.977, "p99": 184.371}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 16.9, "cpu_pct_max_per_container": 19.3, "cpu_utilization_of_limit": 0.338, "mem_max_mib": 251.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.0, "cpu_pct_max_per_container": 22.3, "cpu_utilization_of_limit": 0.2, "mem_max_mib": 88.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.7, "cpu_pct_max_per_container": 51.8, "cpu_utilization_of_limit": 1.014, "mem_max_mib": 11.4}, "postgres_connections": {"active_max": 3, "active_mean": 0.4, "total_max": 22}}, "pool": {"acquires": 15996, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1217, "2ef3d3401cb2": 1206, "533549b432a8": 1209, "8f4056cc3ff4": 1208}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 672.9, "p50": 262.164, "p95": 460.581, "p99": 550.176}, "mode": "closed", "ok": 4840, "ok_read_rps": 158.2, "ok_rps": 322.6666666666667, "ok_write_rps": 164.46666666666667, "rate": 0, "read_ms": {"max": 215.547, "p50": 16.362, "p95": 43.832, "p99": 86.781}, "requests": 4840, "timestamp": "2026-10-23T23:27:31Z", "warmup_s": 3, "write_ms": {"max": 672.9, "p50": 358.675, "p95": 500.928, "p99": 564.241}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.6, "cpu_pct_max_per_container": 20.8, "cpu_utilization_of_limit": 0.352, "mem_max_mib": 247.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.095, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.6, "cpu_pct_max_per_container": 23.2, "cpu_utilization_of_limit": 0.216, "mem_max_mib": 216.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.3, "cpu_pct_max_per_container": 52.1, "cpu_utilization_of_limit": 1.007, "mem_max_mib": 18.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.2, "total_max": 76}}, "pool": {"acquires": 16507, "empty_acquire_ratio": 0.0041, "avg_acquire_wait_ms": 1.279, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1097, "2ef3d3401cb2": 1103, "533549b432a8": 1098, "8f4056cc3ff4": 1095}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 652.544, "p50": 53.271, "p95": 511.157, "p99": 579.698}, "mode": "closed", "ok": 4393, "ok_read_rps": 147.4, "ok_rps": 292.8666666666667, "ok_write_rps": 145.46666666666667, "rate": 0, "read_ms": {"max": 80.131, "p50": 17.482, "p95": 39.376, "p99": 51.011}, "requests": 4393, "timestamp": "2026-10-23T23:27:55Z", "warmup_s": 3, "write_ms": {"max": 652.544, "p50": 413.179, "p95": 542.831, "p99": 600.759}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 16.7, "cpu_pct_max_per_container": 20.1, "cpu_utilization_of_limit": 0.335, "mem_max_mib": 190.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.5, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.09, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.5, "cpu_pct_max_per_container": 25.6, "cpu_utilization_of_limit": 0.195, "mem_max_mib": 218.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 77}}, "pool": {"acquires": 15765, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.013, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1245, "2ef3d3401cb2": 1255, "533549b432a8": 1236, "8f4056cc3ff4": 1246}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 583.385, "p50": 42.372, "p95": 463.752, "p99": 516.875}, "mode": "closed", "ok": 4982, "ok_read_rps": 170.13333333333333, "ok_rps": 332.1333333333333, "ok_write_rps": 162, "rate": 0, "read_ms": {"max": 74.941, "p50": 15.823, "p95": 36.224, "p99": 51.606}, "requests": 4982, "timestamp": "2026-10-23T23:28:15Z", "warmup_s": 3, "write_ms": {"max": 583.385, "p50": 365.728, "p95": 490.161, "p99": 529.503}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.6, "cpu_pct_max_per_container": 20.5, "cpu_utilization_of_limit": 0.353, "mem_max_mib": 63.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 10.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.7, "cpu_pct_max_per_container": 20.8, "cpu_utilization_of_limit": 0.197, "mem_max_mib": 223.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 12.7}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 77}}, "pool": {"acquires": 17370, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1144, "3a27245eecd3": 1146, "9cafee3d15ce": 1145, "beb91c4b6792": 1146}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 217.825, "p50": 26.601, "p95": 126.088, "p99": 148.151}, "mode": "closed", "ok": 4581, "ok_read_rps": 154.33333333333334, "ok_rps": 305.4, "ok_write_rps": 151.06666666666666, "rate": 0, "read_ms": {"max": 51.025, "p50": 5.996, "p95": 16.906, "p99": 26.735}, "requests": 4581, "timestamp": "2026-10-23T23:28:53Z", "warmup_s": 3, "write_ms": {"max": 217.825, "p50": 95.541, "p95": 138.411, "p99": 155.259}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.1, "cpu_pct_max_per_container": 19.5, "cpu_utilization_of_limit": 0.342, "mem_max_mib": 144.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.098, "mem_max_mib": 10.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.1, "cpu_pct_max_per_container": 23.3, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 82.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.7, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.014, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 24}}, "pool": {"acquires": 16085, "empty_acquire_ratio": 0.0009, "avg_acquire_wait_ms": 0.056, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1203, "3a27245eecd3": 1204, "9cafee3d15ce": 1196, "beb91c4b6792": 1205}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 226.511, "p50": 36.263, "p95": 126.913, "p99": 157.702}, "mode": "closed", "ok": 4808, "ok_read_rps": 160.4, "ok_rps": 320.53333333333336, "ok_write_rps": 160.13333333333333, "rate": 0, "read_ms": {"max": 113.381, "p50": 5.595, "p95": 19.559, "p99": 33.333}, "requests": 4808, "timestamp": "2026-10-23T23:29:13Z", "warmup_s": 3, "write_ms": {"max": 226.511, "p50": 90.369, "p95": 139.819, "p99": 169.703}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.7, "cpu_pct_max_per_container": 22.3, "cpu_utilization_of_limit": 0.353, "mem_max_mib": 239.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.094, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.1, "cpu_pct_max_per_container": 42.4, "cpu_utilization_of_limit": 0.115, "mem_max_mib": 86.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.7, "cpu_utilization_of_limit": 1.0, "mem_max_mib": 12.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 24}}, "pool": {"acquires": 16066, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1487, "3a27245eecd3": 1486, "9cafee3d15ce": 1487, "beb91c4b6792": 1492}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 169.105, "p50": 38.702, "p95": 98.134, "p99": 128.479}, "mode": "closed", "ok": 5952, "ok_read_rps": 194.26666666666668, "ok_rps": 396.8, "ok_write_rps": 202.53333333333333, "rate": 0, "read_ms": {"max": 51.566, "p50": 5.052, "p95": 15.519, "p99": 26.623}, "requests": 5952, "timestamp": "2026-10-23T23:29:33Z", "warmup_s": 3, "write_ms": {"max": 169.105, "p50": 69.4, "p95": 109.211, "p99": 143.721}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.427, "mem_max_mib": 248.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.0, "cpu_pct_max_per_container": 28.5, "cpu_utilization_of_limit": 0.115, "mem_max_mib": 98.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.5, "cpu_pct_max_per_container": 50.3, "cpu_utilization_of_limit": 0.949, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 28}}, "pool": {"acquires": 20655, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1372, "3a27245eecd3": 1369, "9cafee3d15ce": 1379, "beb91c4b6792": 1387}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 602.217, "p50": 186.508, "p95": 419.726, "p99": 479.103}, "mode": "closed", "ok": 5507, "ok_read_rps": 183.06666666666666, "ok_rps": 367.1333333333333, "ok_write_rps": 184.06666666666666, "rate": 0, "read_ms": {"max": 128.965, "p50": 13.859, "p95": 31.074, "p99": 50.59}, "requests": 5507, "timestamp": "2026-10-23T23:29:54Z", "warmup_s": 3, "write_ms": {"max": 602.217, "p50": 318.012, "p95": 444.494, "p99": 498.412}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.7, "cpu_pct_max_per_container": 23.6, "cpu_utilization_of_limit": 0.373, "mem_max_mib": 253.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 10.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.111, "mem_max_mib": 111.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.1, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 0.982, "mem_max_mib": 13.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 32}}, "pool": {"acquires": 19667, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.013, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1436, "3a27245eecd3": 1436, "9cafee3d15ce": 1433, "beb91c4b6792": 1446}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 843.954, "p50": 69.707, "p95": 395.186, "p99": 555.551}, "mode": "closed", "ok": 5751, "ok_read_rps": 193.8, "ok_rps": 383.4, "ok_write_rps": 189.6, "rate": 0, "read_ms": {"max": 266.917, "p50": 15, "p95": 42.392, "p99": 71.437}, "requests": 5751, "timestamp": "2026-10-23T23:30:14Z", "warmup_s": 3, "write_ms": {"max": 843.954, "p50": 306.984, "p95": 446.034, "p99": 600.955}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.3, "cpu_pct_max_per_container": 21.9, "cpu_utilization_of_limit": 0.387, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.099, "mem_max_mib": 11.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 26.9, "cpu_pct_max_per_container": 40.8, "cpu_utilization_of_limit": 0.134, "mem_max_mib": 216.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.1, "cpu_pct_max_per_container": 49.1, "cpu_utilization_of_limit": 0.961, "mem_max_mib": 14.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 76}}, "pool": {"acquires": 19510, "empty_acquire_ratio": 0.0055, "avg_acquire_wait_ms": 1.044, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1563, "3a27245eecd3": 1554, "9cafee3d15ce": 1561, "beb91c4b6792": 1564}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 458.763, "p50": 209.95, "p95": 352.224, "p99": 410.267}, "mode": "closed", "ok": 6242, "ok_read_rps": 203.33333333333334, "ok_rps": 416.1333333333333, "ok_write_rps": 212.8, "rate": 0, "read_ms": {"max": 95.05, "p50": 12.742, "p95": 28.693, "p99": 44.209}, "requests": 6242, "timestamp": "2026-10-23T23:30:36Z", "warmup_s": 3, "write_ms": {"max": 458.763, "p50": 279.547, "p95": 380.263, "p99": 424.66}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.2, "cpu_pct_max_per_container": 22.8, "cpu_utilization_of_limit": 0.405, "mem_max_mib": 73.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 11.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.2, "cpu_pct_max_per_container": 25.3, "cpu_utilization_of_limit": 0.116, "mem_max_mib": 220.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.2, "cpu_pct_max_per_container": 48.8, "cpu_utilization_of_limit": 0.944, "mem_max_mib": 13.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 76}}, "pool": {"acquires": 22017, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1323, "3a27245eecd3": 1325, "9cafee3d15ce": 1324, "beb91c4b6792": 1327}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 178.939, "p50": 21.992, "p95": 112.786, "p99": 145.393}, "mode": "closed", "ok": 5299, "ok_read_rps": 180.13333333333333, "ok_rps": 353.26666666666665, "ok_write_rps": 173.13333333333333, "rate": 0, "read_ms": {"max": 66.646, "p50": 5.555, "p95": 16.14, "p99": 28.82}, "requests": 5299, "timestamp": "2026-10-23T23:31:05Z", "warmup_s": 3, "write_ms": {"max": 178.939, "p50": 81.652, "p95": 127.798, "p99": 153.186}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.2, "cpu_pct_max_per_container": 24.0, "cpu_utilization_of_limit": 0.384, "mem_max_mib": 237.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.049, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 24.8, "cpu_utilization_of_limit": 0.222, "mem_max_mib": 78.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.1, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 0.982, "mem_max_mib": 13.2}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 21}}, "pool": {"acquires": 18455, "empty_acquire_ratio": 0.0009, "avg_acquire_wait_ms": 0.051, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1338, "3a27245eecd3": 1336, "9cafee3d15ce": 1335, "beb91c4b6792": 1338}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 677.896, "p50": 37.685, "p95": 105.769, "p99": 149.759}, "mode": "closed", "ok": 5347, "ok_read_rps": 176.26666666666668, "ok_rps": 356.46666666666664, "ok_write_rps": 180.2, "rate": 0, "read_ms": {"max": 211.976, "p50": 5.14, "p95": 15.21, "p99": 31.815}, "requests": 5347, "timestamp": "2026-10-23T23:31:24Z", "warmup_s": 3, "write_ms": {"max": 677.896, "p50": 75.583, "p95": 125.406, "p99": 164.102}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.4, "cpu_pct_max_per_container": 23.5, "cpu_utilization_of_limit": 0.388, "mem_max_mib": 253.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.047, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 25.0, "cpu_pct_max_per_container": 41.4, "cpu_utilization_of_limit": 0.25, "mem_max_mib": 88.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 46.7, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.934, "mem_max_mib": 13.1}, "postgres_connections": {"active_max": 3, "active_mean": 0.7, "total_max": 24}}, "pool": {"acquires": 19004, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.004, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1336, "3a27245eecd3": 1338, "9cafee3d15ce": 1335, "beb91c4b6792": 1335}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 348.508, "p50": 25.447, "p95": 114.883, "p99": 151.644}, "mode": "closed", "ok": 5344, "ok_read_rps": 180.33333333333334, "ok_rps": 356.26666666666665, "ok_write_rps": 175.93333333333334, "rate": 0, "read_ms": {"max": 140.733, "p50": 5.614, "p95": 17.077, "p99": 30.139}, "requests": 5344, "timestamp": "2026-10-23T23:31:44Z", "warmup_s": 3, "write_ms": {"max": 348.508, "p50": 79.14, "p95": 130.817, "p99": 173.595}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.1, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.382, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.049, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.7, "cpu_pct_max_per_container": 25.3, "cpu_utilization_of_limit": 0.217, "mem_max_mib": 96.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.3, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.965, "mem_max_mib": 13.1}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 26}}, "pool": {"acquires": 18631, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.008, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1404, "3a27245eecd3": 1405, "9cafee3d15ce": 1403, "beb91c4b6792": 1410}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 570.539, "p50": 53.112, "p95": 405.753, "p99": 489.61}, "mode": "closed", "ok": 5622, "ok_read_rps": 189.8, "ok_rps": 374.8, "ok_write_rps": 185, "rate": 0, "read_ms": {"max": 297.745, "p50": 13.542, "p95": 34.88, "p99": 60.6}, "requests": 5622, "timestamp": "2026-10-23T23:32:04Z", "warmup_s": 3, "write_ms": {"max": 570.539, "p50": 318.817, "p95": 443.588, "p99": 521.066}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.3, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.385, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.05, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.7, "cpu_pct_max_per_container": 38.8, "cpu_utilization_of_limit": 0.247, "mem_max_mib": 154.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.0, "cpu_pct_max_per_container": 49.9, "cpu_utilization_of_limit": 0.98, "mem_max_mib": 14.1}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 50}}, "pool": {"acquires": 19762, "empty_acquire_ratio": 0.0012, "avg_acquire_wait_ms": 0.106, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1541, "3a27245eecd3": 1542, "9cafee3d15ce": 1544, "beb91c4b6792": 1537}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 571.122, "p50": 41.571, "p95": 379.461, "p99": 477.927}, "mode": "closed", "ok": 6164, "ok_read_rps": 208.13333333333333, "ok_rps": 410.93333333333334, "ok_write_rps": 202.8, "rate": 0, "read_ms": {"max": 102.403, "p50": 12.731, "p95": 29.276, "p99": 43.524}, "requests": 6164, "timestamp": "2026-10-23T23:32:25Z", "warmup_s": 3, "write_ms": {"max": 571.122, "p50": 289.583, "p95": 429.936, "p99": 506.316}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.8, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.396, "mem_max_mib": 234.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.05, "mem_max_mib": 9.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.4, "cpu_pct_max_per_container": 37.2, "cpu_utilization_of_limit": 0.244, "mem_max_mib": 210.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.1, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 0.962, "mem_max_mib": 14.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 74}}, "pool": {"acquires": 20688, "empty_acquire_ratio": 0.0013, "avg_acquire_wait_ms": 0.366, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1588, "3a27245eecd3": 1582, "9cafee3d15ce": 1585, "beb91c4b6792": 1590}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 495.795, "p50": 38.123, "p95": 369.645, "p99": 427.292}, "mode": "closed", "ok": 6345, "ok_read_rps": 216.2, "ok_rps": 423, "ok_write_rps": 206.8, "rate": 0, "read_ms": {"max": 82.119, "p50": 13.025, "p95": 30.114, "p99": 45.098}, "requests": 6345, "timestamp": "2026-10-23T23:32:46Z", "warmup_s": 3, "write_ms": {"max": 495.795, "p50": 285.975, "p95": 395.812, "p99": 452.116}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.3, "cpu_pct_max_per_container": 22.1, "cpu_utilization_of_limit": 0.406, "mem_max_mib": 54.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.3, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.053, "mem_max_mib": 10.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.1, "cpu_pct_max_per_container": 26.4, "cpu_utilization_of_limit": 0.231, "mem_max_mib": 220.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.3, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 0.966, "mem_max_mib": 14.3}, "postgres_connections": {"active_max": 3, "active_mean": 0.6, "total_max": 75}}, "pool": {"acquires": 22178, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.013, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1492, "3a27245eecd3": 1493, "9cafee3d15ce": 1495, "beb91c4b6792": 1492}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 205.369, "p50": 29.384, "p95": 98.163, "p99": 131.51}, "mode": "closed", "ok": 5972, "ok_read_rps": 198.66666666666666, "ok_rps": 398.1333333333333, "ok_write_rps": 199.46666666666667, "rate": 0, "read_ms": {"max": 52.092, "p50": 4.895, "p95": 13.789, "p99": 22.055}, "requests": 5972, "timestamp": "2026-10-23T23:33:14Z", "warmup_s": 3, "write_ms": {"max": 205.369, "p50": 70.699, "p95": 109.915, "p99": 144.848}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.5, "cpu_pct_max_per_container": 23.4, "cpu_utilization_of_limit": 0.429, "mem_max_mib": 60.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.5, "cpu_pct_max_per_container": 24.2, "cpu_utilization_of_limit": 0.225, "mem_max_mib": 224.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.0, "cpu_pct_max_per_container": 51.7, "cpu_utilization_of_limit": 0.49, "mem_max_mib": 11.7}, "postgres_connections": {"active_max": 2, "active_mean": 0.6, "total_max": 75}}, "pool": {"acquires": 20615, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1469, "3a27245eecd3": 1471, "9cafee3d15ce": 1472, "beb91c4b6792": 1468}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 228.462, "p50": 28.229, "p95": 104.603, "p99": 138.431}, "mode": "closed", "ok": 5880, "ok_read_rps": 198.2, "ok_rps": 392, "ok_write_rps": 193.8, "rate": 0, "read_ms": {"max": 131.703, "p50": 5.345, "p95": 17.621, "p99": 37.853}, "requests": 5880, "timestamp": "2026-10-23T23:33:33Z", "warmup_s": 3, "write_ms": {"max": 228.462, "p50": 72.192, "p95": 119.751, "p99": 149.268}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.426, "mem_max_mib": 54.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 25.0, "cpu_pct_max_per_container": 33.8, "cpu_utilization_of_limit": 0.25, "mem_max_mib": 227.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.4, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 0.494, "mem_max_mib": 11.8}, "postgres_connections": {"active_max": 3, "active_mean": 0.7, "total_max": 75}}, "pool": {"acquires": 20550, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1393, "3a27245eecd3": 1396, "9cafee3d15ce": 1398, "beb91c4b6792": 1395}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 184.833, "p50": 32.112, "p95": 104.052, "p99": 131.39}, "mode": "closed", "ok": 5582, "ok_read_rps": 185.4, "ok_rps": 372.1333333333333, "ok_write_rps": 186.73333333333332, "rate": 0, "read_ms": {"max": 52.035, "p50": 5.195, "p95": 14.777, "p99": 26.574}, "requests": 5582, "timestamp": "2026-10-23T23:33:53Z", "warmup_s": 3, "write_ms": {"max": 184.833, "p50": 75.98, "p95": 117.102, "p99": 140.782}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 23.3, "cpu_utilization_of_limit": 0.425, "mem_max_mib": 54.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.4, "cpu_pct_max_per_container": 24.6, "cpu_utilization_of_limit": 0.224, "mem_max_mib": 229.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.8, "cpu_pct_max_per_container": 52.2, "cpu_utilization_of_limit": 0.498, "mem_max_mib": 12.3}, "postgres_connections": {"active_max": 4, "active_mean": 0.6, "total_max": 75}}, "pool": {"acquires": 19306, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1538, "3a27245eecd3": 1554, "9cafee3d15ce": 1547, "beb91c4b6792": 1548}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 549.094, "p50": 47.098, "p95": 375.082, "p99": 428.764}, "mode": "closed", "ok": 6187, "ok_read_rps": 208.2, "ok_rps": 412.46666666666664, "ok_write_rps": 204.26666666666668, "rate": 0, "read_ms": {"max": 82.73, "p50": 13.073, "p95": 31.862, "p99": 46.73}, "requests": 6187, "timestamp": "2026-10-23T23:34:14Z", "warmup_s": 3, "write_ms": {"max": 549.094, "p50": 288.439, "p95": 396.509, "p99": 460.481}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.9, "cpu_pct_max_per_container": 23.6, "cpu_utilization_of_limit": 0.418, "mem_max_mib": 54.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.4, "cpu_pct_max_per_container": 5.9, "cpu_utilization_of_limit": 0.107, "mem_max_mib": 10.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.6, "cpu_pct_max_per_container": 24.8, "cpu_utilization_of_limit": 0.236, "mem_max_mib": 236.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 54.2, "cpu_utilization_of_limit": 0.502, "mem_max_mib": 13.5}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 76}}, "pool": {"acquires": 20793, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.008, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1403, "3a27245eecd3": 1401, "9cafee3d15ce": 1405, "beb91c4b6792": 1406}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 678.797, "p50": 58.303, "p95": 426.689, "p99": 536.919}, "mode": "closed", "ok": 5615, "ok_read_rps": 188.53333333333333, "ok_rps": 374.3333333333333, "ok_write_rps": 185.8, "rate": 0, "read_ms": {"max": 87.435, "p50": 13.931, "p95": 33.561, "p99": 55.567}, "requests": 5615, "timestamp": "2026-10-23T23:34:34Z", "warmup_s": 3, "write_ms": {"max": 678.797, "p50": 320.861, "p95": 470.893, "p99": 576.676}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.5, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.409, "mem_max_mib": 60.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.2, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.104, "mem_max_mib": 10.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.0, "cpu_pct_max_per_container": 27.2, "cpu_utilization_of_limit": 0.24, "mem_max_mib": 244.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.9, "cpu_pct_max_per_container": 55.9, "cpu_utilization_of_limit": 0.509, "mem_max_mib": 13.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 78}}, "pool": {"acquires": 19003, "empty_acquire_ratio": 0.0017, "avg_acquire_wait_ms": 0.016, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1515, "3a27245eecd3": 1521, "9cafee3d15ce": 1513, "beb91c4b6792": 1520}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 554.522, "p50": 43.666, "p95": 405.322, "p99": 468.326}, "mode": "closed", "ok": 6069, "ok_read_rps": 205.26666666666668, "ok_rps": 404.6, "ok_write_rps": 199.33333333333334, "rate": 0, "read_ms": {"max": 62.349, "p50": 13.646, "p95": 32.06, "p99": 46.229}, "requests": 6069, "timestamp": "2026-10-23T23:34:56Z", "warmup_s": 3, "write_ms": {"max": 554.522, "p50": 291.584, "p95": 441.414, "p99": 488.015}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.0, "cpu_pct_max_per_container": 23.9, "cpu_utilization_of_limit": 0.42, "mem_max_mib": 55.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.4, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.108, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.9, "cpu_pct_max_per_container": 25.1, "cpu_utilization_of_limit": 0.239, "mem_max_mib": 246.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 55.3, "cpu_utilization_of_limit": 0.501, "mem_max_mib": 13.7}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 78}}, "pool": {"acquires": 20929, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "baseline_scan", "concurrency": 32, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"246a774804a5": 1402, "93921a38e28e": 1401, "bbaee9b7f361": 1407, "ea9e7f87bfdf": 1410}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 302.086, "p50": 36.286, "p95": 210.733, "p99": 248.858}, "mode": "closed", "ok": 5620, "ok_read_rps": 188.86666666666667, "ok_rps": 374.6666666666667, "ok_write_rps": 185.8, "rate": 0, "read_ms": {"max": 62.957, "p50": 7.994, "p95": 23.126, "p99": 35.378}, "requests": 5620, "timestamp": "2026-10-23T23:26:32Z", "warmup_s": 3, "write_ms": {"max": 302.086, "p50": 155.989, "p95": 223.864, "p99": 259.623}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.6, "cpu_pct_max_per_container": 21.6, "cpu_utilization_of_limit": 0.372, "mem_max_mib": 138.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.099, "mem_max_mib": 9.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.5, "cpu_pct_max_per_container": 26.1, "cpu_utilization_of_limit": 0.225, "mem_max_mib": 120.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 51.3, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 12.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 41}}, "pool": {"acquires": 18869, "empty_acquire_ratio": 0.0016, "avg_acquire_wait_ms": 0.29, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "baseline_scan", "concurrency": 32, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"246a774804a5": 1402, "93921a38e28e": 1404, "bbaee9b7f361": 1406, "ea9e7f87bfdf": 1405}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 336.422, "p50": 55.124, "p95": 205.601, "p99": 259.884}, "mode": "closed", "ok": 5617, "ok_read_rps": 187.46666666666667, "ok_rps": 374.46666666666664, "ok_write_rps": 187, "rate": 0, "read_ms": {"max": 80.088, "p50": 8.012, "p95": 22.44, "p99": 35.849}, "requests": 5617, "timestamp": "2026-10-23T23:26:52Z", "warmup_s": 3, "write_ms": {"max": 336.422, "p50": 155.144, "p95": 223.114, "p99": 282.964}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.0, "cpu_pct_max_per_container": 21.7, "cpu_utilization_of_limit": 0.381, "mem_max_mib": 255.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 9.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 24.2, "cpu_utilization_of_limit": 0.222, "mem_max_mib": 129.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.992, "mem_max_mib": 11.9}, "postgres_connections": {"active_max": 2, "active_mean": 0.3, "total_max": 41}}, "pool": {"acquires": 19794, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "baseline_scan", "concurrency": 32, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"246a774804a5": 1380, "93921a38e28e": 1375, "bbaee9b7f361": 1380, "ea9e7f87bfdf": 1375}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 599.673, "p50": 49.481, "p95": 213.452, "p99": 298.072}, "mode": "closed", "ok": 5510, "ok_read_rps": 184.8, "ok_rps": 367.3333333333333, "ok_write_rps": 182.53333333333333, "rate": 0, "read_ms": {"max": 154.643, "p50": 8.303, "p95": 25.956, "p99": 46.017}, "requests": 5510, "timestamp": "2026-10-23T23:27:13Z", "warmup_s": 3, "write_ms": {"max": 599.673, "p50": 155.995, "p95": 240.127, "p99": 365.087}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.3, "cpu_pct_max_per_container": 23.7, "cpu_utilization_of_limit": 0.366, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.094, "mem_max_mib": 9.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 23.9, "cpu_utilization_of_limit": 0.222, "mem_max_mib": 135.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.1, "cpu_pct_max_per_container": 50.4, "cpu_utilization_of_limit": 0.961, "mem_max_mib": 12.2}, "postgres_connections": {"active_max": 14, "active_mean": 2.6, "total_max": 43}}, "pool": {"acquires": 18983, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.007, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "baseline_scan", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"246a774804a5": 1348, "93921a38e28e": 1340, "bbaee9b7f361": 1342, "ea9e7f87bfdf": 1337}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 1107.76, "p50": 110.411, "p95": 421.487, "p99": 692.871}, "mode": "closed", "ok": 5367, "ok_read_rps": 179.6, "ok_rps": 357.8, "ok_write_rps": 178.2, "rate": 0, "read_ms": {"max": 807.257, "p50": 14.719, "p95": 47.359, "p99": 91.516}, "requests": 5367, "timestamp": "2026-10-23T23:27:35Z", "warmup_s": 3, "write_ms": {"max": 1107.76, "p50": 317.647, "p95": 472.362, "p99": 848.881}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.4, "cpu_pct_max_per_container": 22.3, "cpu_utilization_of_limit": 0.368, "mem_max_mib": 256.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.098, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.3, "cpu_pct_max_per_container": 32.9, "cpu_utilization_of_limit": 0.243, "mem_max_mib": 183.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.0, "cpu_pct_max_per_container": 50.0, "cpu_utilization_of_limit": 0.979, "mem_max_mib": 13.0}, "postgres_connections": {"active_max": 43, "active_mean": 7.7, "total_max": 60}}, "pool": {"acquires": 18669, "empty_acquire_ratio": 0.0031, "avg_acquire_wait_ms": 0.249, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "baseline_scan", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"246a774804a5": 1470, "93921a38e28e": 1463, "bbaee9b7f361": 1471, "ea9e7f87bfdf": 1462}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 526.331, "p50": 43.477, "p95": 396.462, "p99": 468.433}, "mode": "closed", "ok": 5866, "ok_read_rps": 197.8, "ok_rps": 391.06666666666666, "ok_write_rps": 193.26666666666668, "rate": 0, "read_ms": {"max": 88.199, "p50": 12.985, "p95": 31.93, "p99": 46.515}, "requests": 5866, "timestamp": "2026-10-23T23:27:58Z", "warmup_s": 3, "write_ms": {"max": 526.331, "p50": 305.625, "p95": 432.142, "p99": 483.419}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.4, "cpu_pct_max_per_container": 22.1, "cpu_utilization_of_limit": 0.389, "mem_max_mib": 68.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 10.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.1, "cpu_pct_max_per_container": 24.1, "cpu_utilization_of_limit": 0.211, "mem_max_mib": 214.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 0.992, "mem_max_mib": 13.2}, "postgres_connections": {"active_max": 2, "active_mean": 0.6, "total_max": 74}}, "pool": {"acquires": 20399, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.006, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "baseline_scan", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"246a774804a5": 1364, "93921a38e28e": 1360, "bbaee9b7f361": 1355, "ea9e7f87bfdf": 1353}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 601.478, "p50": 49.473, "p95": 433.559, "p99": 490.886}, "mode": "closed", "ok": 5432, "ok_read_rps": 182.66666666666666, "ok_rps": 362.1333333333333, "ok_write_rps": 179.46666666666667, "rate": 0, "read_ms": {"max": 90.19, "p50": 14.644, "p95": 34.661, "p99": 49.016}, "requests": 5432, "timestamp": "2026-10-23T23:28:19Z", "warmup_s": 3, "write_ms": {"max": 601.478, "p50": 328.059, "p95": 465.772, "p99": 505.811}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.0, "cpu_pct_max_per_container": 21.4, "cpu_utilization_of_limit": 0.379, "mem_max_mib": 68.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.5, "cpu_pct_max_per_container": 22.6, "cpu_utilization_of_limit": 0.205, "mem_max_mib": 219.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 1.002, "mem_max_mib": 13.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 74}}, "pool": {"acquires": 18774, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "cache_version", "concurrency": 32, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"428537b11184": 2966, "7187213e9b99": 2964, "c09929f7107c": 2966, "cab6dec08ada": 2963}, "label": "D_improvement/cache_version", "latency_ms": {"max": 744.391, "p50": 26.321, "p95": 115.976, "p99": 190.683}, "mode": "closed", "ok": 11859, "ok_read_rps": 398.73333333333335, "ok_rps": 790.6, "ok_write_rps": 391.8666666666667, "rate": 0, "read_ms": {"max": 115.569, "p50": 13.996, "p95": 38.832, "p99": 62.13}, "requests": 11859, "timestamp": "2026-10-23T23:28:50Z", "warmup_s": 3, "write_ms": {"max": 744.391, "p50": 54.4, "p95": 145.392, "p99": 232.427}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 15.3, "cpu_pct_max_per_container": 17.0, "cpu_utilization_of_limit": 0.307, "mem_max_mib": 138.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.2, "cpu_pct_max_per_container": 10.0, "cpu_utilization_of_limit": 0.184, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 82.0, "cpu_pct_max_per_container": 87.0, "cpu_utilization_of_limit": 0.82, "mem_max_mib": 203.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 7.7, "cpu_pct_max_per_container": 8.4, "cpu_utilization_of_limit": 0.154, "mem_max_mib": 52.2}, "postgres_connections": {"active_max": 32, "active_mean": 27, "total_max": 65}}, "pool": {"acquires": 39274, "empty_acquire_ratio": 0.0014, "avg_acquire_wait_ms": 0.19, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "cache_version", "concurrency": 32, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"428537b11184": 2703, "7187213e9b99": 2707, "c09929f7107c": 2708, "cab6dec08ada": 2706}, "label": "D_improvement/cache_version", "latency_ms": {"max": 686.948, "p50": 28.887, "p95": 131.657, "p99": 234.129}, "mode": "closed", "ok": 10824, "ok_read_rps": 364.2, "ok_rps": 721.6, "ok_write_rps": 357.4, "rate": 0, "read_ms": {"max": 128.215, "p50": 16.159, "p95": 49.947, "p99": 72.079}, "requests": 10824, "timestamp": "2026-10-23T23:29:11Z", "warmup_s": 3, "write_ms": {"max": 686.948, "p50": 56.882, "p95": 165.896, "p99": 287.158}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 14.3, "cpu_pct_max_per_container": 16.3, "cpu_utilization_of_limit": 0.286, "mem_max_mib": 247.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.3, "cpu_pct_max_per_container": 8.9, "cpu_utilization_of_limit": 0.166, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 84.0, "cpu_pct_max_per_container": 89.0, "cpu_utilization_of_limit": 0.84, "mem_max_mib": 211.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 9.9, "cpu_pct_max_per_container": 21.8, "cpu_utilization_of_limit": 0.199, "mem_max_mib": 91.1}, "postgres_connections": {"active_max": 31, "active_mean": 27.7, "total_max": 66}}, "pool": {"acquires": 36225, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "cache_version", "concurrency": 32, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"428537b11184": 2513, "7187213e9b99": 2518, "c09929f7107c": 2513, "cab6dec08ada": 2516}, "label": "D_improvement/cache_version", "latency_ms": {"max": 1099.589, "p50": 29.911, "p95": 139.355, "p99": 261.349}, "mode": "closed", "ok": 10060, "ok_read_rps": 335.8666666666667, "ok_rps": 670.6666666666666, "ok_write_rps": 334.8, "rate": 0, "read_ms": {"max": 1099.589, "p50": 17.213, "p95": 56.016, "p99": 99.049}, "requests": 10060, "timestamp": "2026-10-23T23:29:33Z", "warmup_s": 3, "write_ms": {"max": 561.888, "p50": 59.025, "p95": 172.256, "p99": 358.26}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 13.6, "cpu_pct_max_per_container": 16.9, "cpu_utilization_of_limit": 0.271, "mem_max_mib": 251.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 7.6, "cpu_pct_max_per_container": 8.8, "cpu_utilization_of_limit": 0.151, "mem_max_mib": 10.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 78.2, "cpu_pct_max_per_container": 91.0, "cpu_utilization_of_limit": 0.782, "mem_max_mib": 227.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 7.6, "cpu_pct_max_per_container": 9.6, "cpu_utilization_of_limit": 0.152, "mem_max_mib": 98.4}, "postgres_connections": {"active_max": 31, "active_mean": 27.4, "total_max": 71}}, "pool": {"acquires": 34208, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.009, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "cache_version", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"428537b11184": 3266, "7187213e9b99": 3262, "c09929f7107c": 3255, "cab6dec08ada": 3267}, "label": "D_improvement/cache_version", "latency_ms": {"max": 2049.753, "p50": 47.272, "p95": 221.983, "p99": 430.405}, "mode": "closed", "ok": 13050, "ok_read_rps": 442.1333333333333, "ok_rps": 870, "ok_write_rps": 427.8666666666667, "rate": 0, "read_ms": {"max": 276.051, "p50": 26.979, "p95": 84.669, "p99": 126.884}, "requests": 13050, "timestamp": "2026-10-23T23:29:52Z", "warmup_s": 3, "write_ms": {"max": 2049.753, "p50": 83.373, "p95": 308.725, "p99": 568.07}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 16.0, "cpu_pct_max_per_container": 17.6, "cpu_utilization_of_limit": 0.319, "mem_max_mib": 53.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.0, "cpu_pct_max_per_container": 9.5, "cpu_utilization_of_limit": 0.18, "mem_max_mib": 11.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 75.9, "cpu_pct_max_per_container": 86.1, "cpu_utilization_of_limit": 0.759, "mem_max_mib": 258.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 9.8, "cpu_pct_max_per_container": 17.9, "cpu_utilization_of_limit": 0.196, "mem_max_mib": 102.2}, "postgres_connections": {"active_max": 60, "active_mean": 40.2, "total_max": 80}}, "pool": {"acquires": 44444, "empty_acquire_ratio": 0.0951, "avg_acquire_wait_ms": 0.648, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "cache_version", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"428537b11184": 2938, "7187213e9b99": 2939, "c09929f7107c": 2914, "cab6dec08ada": 2937}, "label": "D_improvement/cache_version", "latency_ms": {"max": 1485.643, "p50": 47.196, "p95": 270.487, "p99": 590.271}, "mode": "closed", "ok": 11728, "ok_read_rps": 385.1333333333333, "ok_rps": 781.8666666666667, "ok_write_rps": 396.73333333333335, "rate": 0, "read_ms": {"max": 186.462, "p50": 25.617, "p95": 80.043, "p99": 119.486}, "requests": 11728, "timestamp": "2026-10-23T23:30:12Z", "warmup_s": 3, "write_ms": {"max": 1485.643, "p50": 87.528, "p95": 381.763, "p99": 706.928}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 15.2, "cpu_pct_max_per_container": 17.4, "cpu_utilization_of_limit": 0.305, "mem_max_mib": 53.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.9, "cpu_pct_max_per_container": 9.2, "cpu_utilization_of_limit": 0.177, "mem_max_mib": 11.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 81.7, "cpu_pct_max_per_container": 86.7, "cpu_utilization_of_limit": 0.817, "mem_max_mib": 264.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 14.0, "cpu_pct_max_per_container": 30.4, "cpu_utilization_of_limit": 0.28, "mem_max_mib": 110.1}, "postgres_connections": {"active_max": 58, "active_mean": 32.6, "total_max": 80}}, "pool": {"acquires": 40469, "empty_acquire_ratio": 0.103, "avg_acquire_wait_ms": 0.51, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "cache_version", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"428537b11184": 3062, "7187213e9b99": 3073, "c09929f7107c": 3057, "cab6dec08ada": 3072}, "label": "D_improvement/cache_version", "latency_ms": {"max": 1545.36, "p50": 47.117, "p95": 243.844, "p99": 516.492}, "mode": "closed", "ok": 12264, "ok_read_rps": 407.1333333333333, "ok_rps": 817.6, "ok_write_rps": 410.46666666666664, "rate": 0, "read_ms": {"max": 203.555, "p50": 25.81, "p95": 76.594, "p99": 110.172}, "requests": 12264, "timestamp": "2026-10-23T23:30:32Z", "warmup_s": 3, "write_ms": {"max": 1545.36, "p50": 89.252, "p95": 329.909, "p99": 655.903}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 15.5, "cpu_pct_max_per_container": 17.8, "cpu_utilization_of_limit": 0.31, "mem_max_mib": 53.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.9, "cpu_pct_max_per_container": 9.8, "cpu_utilization_of_limit": 0.179, "mem_max_mib": 11.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 75.5, "cpu_pct_max_per_container": 79.6, "cpu_utilization_of_limit": 0.755, "mem_max_mib": 271.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 10.4, "cpu_pct_max_per_container": 22.9, "cpu_utilization_of_limit": 0.208, "mem_max_mib": 116.7}, "postgres_connections": {"active_max": 50, "active_mean": 38.3, "total_max": 81}}, "pool": {"acquires": 42107, "empty_acquire_ratio": 0.1256, "avg_acquire_wait_ms": 0.808, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "pool_8", "concurrency": 32, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "8", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"30c85b39688f": 1018, "4d86bd3e9c23": 1017, "76d56c4549ec": 1013, "d141ddf0e379": 1011}, "label": "D_improvement/pool_8", "latency_ms": {"max": 364.351, "p50": 138.221, "p95": 286.686, "p99": 322.528}, "mode": "closed", "ok": 4059, "ok_read_rps": 130.26666666666668, "ok_rps": 270.6, "ok_write_rps": 140.33333333333334, "rate": 0, "read_ms": {"max": 59.328, "p50": 7.996, "p95": 32.602, "p99": 44.096}, "requests": 4059, "timestamp": "2026-10-23T23:31:04Z", "warmup_s": 3, "write_ms": {"max": 364.351, "p50": 211.217, "p95": 301.366, "p99": 330.586}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 15.3, "cpu_pct_max_per_container": 18.3, "cpu_utilization_of_limit": 0.307, "mem_max_mib": 138.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 3.4, "cpu_pct_max_per_container": 4.0, "cpu_utilization_of_limit": 0.068, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 16.4, "cpu_pct_max_per_container": 19.2, "cpu_utilization_of_limit": 0.164, "mem_max_mib": 148.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.3, "cpu_pct_max_per_container": 51.3, "cpu_utilization_of_limit": 1.006, "mem_max_mib": 74.8}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 32}}, "pool": {"acquires": 14012, "empty_acquire_ratio": 0.0059, "avg_acquire_wait_ms": 0.188, "pool_max_conns_total": 32}} +{"series": "D_improvement", "config": "pool_8", "concurrency": 32, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "8", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"30c85b39688f": 1482, "4d86bd3e9c23": 1486, "76d56c4549ec": 1486, "d141ddf0e379": 1483}, "label": "D_improvement/pool_8", "latency_ms": {"max": 299.786, "p50": 22.91, "p95": 192.729, "p99": 234.821}, "mode": "closed", "ok": 5937, "ok_read_rps": 202.66666666666666, "ok_rps": 395.8, "ok_write_rps": 193.13333333333333, "rate": 0, "read_ms": {"max": 50.611, "p50": 7.514, "p95": 19.18, "p99": 27.928}, "requests": 5937, "timestamp": "2026-10-23T23:31:25Z", "warmup_s": 3, "write_ms": {"max": 299.786, "p50": 151.569, "p95": 209.709, "p99": 248.708}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.0, "cpu_pct_max_per_container": 21.6, "cpu_utilization_of_limit": 0.38, "mem_max_mib": 243.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.093, "mem_max_mib": 10.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.7, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.217, "mem_max_mib": 152.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.6, "cpu_pct_max_per_container": 51.3, "cpu_utilization_of_limit": 1.011, "mem_max_mib": 27.9}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 32}}, "pool": {"acquires": 20161, "empty_acquire_ratio": 0.0013, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 32}} +{"series": "D_improvement", "config": "pool_8", "concurrency": 32, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "8", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"30c85b39688f": 1358, "4d86bd3e9c23": 1354, "76d56c4549ec": 1354, "d141ddf0e379": 1356}, "label": "D_improvement/pool_8", "latency_ms": {"max": 378.782, "p50": 80.974, "p95": 213.577, "p99": 259.733}, "mode": "closed", "ok": 5422, "ok_read_rps": 179.93333333333334, "ok_rps": 361.46666666666664, "ok_write_rps": 181.53333333333333, "rate": 0, "read_ms": {"max": 167.642, "p50": 8.073, "p95": 26.129, "p99": 53.264}, "requests": 5422, "timestamp": "2026-10-23T23:31:45Z", "warmup_s": 3, "write_ms": {"max": 378.782, "p50": 159.76, "p95": 234.277, "p99": 277.891}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.5, "cpu_pct_max_per_container": 20.7, "cpu_utilization_of_limit": 0.37, "mem_max_mib": 251.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.092, "mem_max_mib": 10.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.7, "cpu_pct_max_per_container": 42.5, "cpu_utilization_of_limit": 0.247, "mem_max_mib": 155.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 51.3, "cpu_utilization_of_limit": 0.991, "mem_max_mib": 18.4}, "postgres_connections": {"active_max": 4, "active_mean": 1.1, "total_max": 33}}, "pool": {"acquires": 18964, "empty_acquire_ratio": 0.0045, "avg_acquire_wait_ms": 0.019, "pool_max_conns_total": 32}} +{"series": "D_improvement", "config": "pool_8", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "8", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"30c85b39688f": 1355, "4d86bd3e9c23": 1356, "76d56c4549ec": 1355, "d141ddf0e379": 1360}, "label": "D_improvement/pool_8", "latency_ms": {"max": 794.795, "p50": 111.065, "p95": 412.926, "p99": 635.536}, "mode": "closed", "ok": 5426, "ok_read_rps": 181.2, "ok_rps": 361.73333333333335, "ok_write_rps": 180.53333333333333, "rate": 0, "read_ms": {"max": 385.817, "p50": 13.784, "p95": 40.731, "p99": 114.547}, "requests": 5426, "timestamp": "2026-10-23T23:32:06Z", "warmup_s": 3, "write_ms": {"max": 794.795, "p50": 316.539, "p95": 473.567, "p99": 686.024}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.2, "cpu_pct_max_per_container": 22.2, "cpu_utilization_of_limit": 0.363, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.4, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.089, "mem_max_mib": 11.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.1, "cpu_pct_max_per_container": 23.0, "cpu_utilization_of_limit": 0.211, "mem_max_mib": 158.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.4, "cpu_pct_max_per_container": 51.9, "cpu_utilization_of_limit": 0.967, "mem_max_mib": 16.8}, "postgres_connections": {"active_max": 3, "active_mean": 0.7, "total_max": 32}}, "pool": {"acquires": 18998, "empty_acquire_ratio": 0.0213, "avg_acquire_wait_ms": 0.679, "pool_max_conns_total": 32}} +{"series": "D_improvement", "config": "pool_8", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "8", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"30c85b39688f": 1164, "4d86bd3e9c23": 1161, "76d56c4549ec": 1153, "d141ddf0e379": 1153}, "label": "D_improvement/pool_8", "latency_ms": {"max": 951.325, "p50": 252.074, "p95": 500.405, "p99": 782.185}, "mode": "closed", "ok": 4631, "ok_read_rps": 150.93333333333334, "ok_rps": 308.73333333333335, "ok_write_rps": 157.8, "rate": 0, "read_ms": {"max": 390.382, "p50": 15.392, "p95": 48.441, "p99": 90.087}, "requests": 4631, "timestamp": "2026-10-23T23:32:29Z", "warmup_s": 3, "write_ms": {"max": 951.325, "p50": 361.283, "p95": 556.197, "p99": 819.489}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 16.8, "cpu_pct_max_per_container": 21.1, "cpu_utilization_of_limit": 0.337, "mem_max_mib": 250.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.2, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.083, "mem_max_mib": 11.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 23.2, "cpu_utilization_of_limit": 0.196, "mem_max_mib": 160.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 44.1, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.882, "mem_max_mib": 18.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 32}}, "pool": {"acquires": 16717, "empty_acquire_ratio": 0.0104, "avg_acquire_wait_ms": 0.379, "pool_max_conns_total": 32}} +{"series": "D_improvement", "config": "pool_8", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "8", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"30c85b39688f": 1463, "4d86bd3e9c23": 1464, "76d56c4549ec": 1456, "d141ddf0e379": 1449}, "label": "D_improvement/pool_8", "latency_ms": {"max": 561.249, "p50": 52.64, "p95": 369.575, "p99": 454.476}, "mode": "closed", "ok": 5832, "ok_read_rps": 195.73333333333332, "ok_rps": 388.8, "ok_write_rps": 193.06666666666666, "rate": 0, "read_ms": {"max": 82.144, "p50": 13.292, "p95": 33.206, "p99": 45.908}, "requests": 5832, "timestamp": "2026-10-23T23:32:53Z", "warmup_s": 3, "write_ms": {"max": 561.249, "p50": 306.825, "p95": 402.113, "p99": 474.122}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.2, "cpu_pct_max_per_container": 23.2, "cpu_utilization_of_limit": 0.365, "mem_max_mib": 211.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.5, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.09, "mem_max_mib": 11.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 23.0, "cpu_utilization_of_limit": 0.222, "mem_max_mib": 162.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 1.002, "mem_max_mib": 16.8}, "postgres_connections": {"active_max": 3, "active_mean": 0.4, "total_max": 32}}, "pool": {"acquires": 19983, "empty_acquire_ratio": 0.0124, "avg_acquire_wait_ms": 0.386, "pool_max_conns_total": 32}} +{"series": "D_improvement", "config": "leastconn", "concurrency": 32, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4e589ba93674": 1416, "8fbb159ab159": 1266, "b4157b77454d": 1372, "c4ff6f12a0a5": 1375}, "label": "D_improvement/leastconn", "latency_ms": {"max": 281.083, "p50": 104.036, "p95": 201.805, "p99": 236.503}, "mode": "closed", "ok": 5429, "ok_read_rps": 180.33333333333334, "ok_rps": 361.93333333333334, "ok_write_rps": 181.6, "rate": 0, "read_ms": {"max": 51.905, "p50": 8.011, "p95": 22.278, "p99": 33.844}, "requests": 5429, "timestamp": "2026-10-23T23:33:25Z", "warmup_s": 3, "write_ms": {"max": 281.083, "p50": 162.403, "p95": 218.781, "p99": 244.802}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.3, "cpu_pct_max_per_container": 20.9, "cpu_utilization_of_limit": 0.346, "mem_max_mib": 144.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.3, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.086, "mem_max_mib": 9.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.6, "cpu_pct_max_per_container": 24.0, "cpu_utilization_of_limit": 0.206, "mem_max_mib": 170.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.9, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 0.999, "mem_max_mib": 16.6}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 36}}, "pool": {"acquires": 19041, "empty_acquire_ratio": 0.0015, "avg_acquire_wait_ms": 0.267, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "leastconn", "concurrency": 32, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4e589ba93674": 1403, "8fbb159ab159": 1350, "b4157b77454d": 1336, "c4ff6f12a0a5": 1391}, "label": "D_improvement/leastconn", "latency_ms": {"max": 308.394, "p50": 49.282, "p95": 206.082, "p99": 245.422}, "mode": "closed", "ok": 5480, "ok_read_rps": 183.46666666666667, "ok_rps": 365.3333333333333, "ok_write_rps": 181.86666666666667, "rate": 0, "read_ms": {"max": 80.678, "p50": 8.726, "p95": 28.778, "p99": 44.354}, "requests": 5480, "timestamp": "2026-10-23T23:33:47Z", "warmup_s": 3, "write_ms": {"max": 308.394, "p50": 161.079, "p95": 221.142, "p99": 259.791}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.9, "cpu_pct_max_per_container": 20.4, "cpu_utilization_of_limit": 0.358, "mem_max_mib": 256.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.3, "cpu_pct_max_per_container": 4.5, "cpu_utilization_of_limit": 0.085, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.5, "cpu_pct_max_per_container": 25.3, "cpu_utilization_of_limit": 0.215, "mem_max_mib": 176.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.7, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.993, "mem_max_mib": 16.0}, "postgres_connections": {"active_max": 2, "active_mean": 0.4, "total_max": 36}}, "pool": {"acquires": 19181, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "leastconn", "concurrency": 32, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4e589ba93674": 1372, "8fbb159ab159": 1384, "b4157b77454d": 1379, "c4ff6f12a0a5": 1359}, "label": "D_improvement/leastconn", "latency_ms": {"max": 883.076, "p50": 37.059, "p95": 204.721, "p99": 250.118}, "mode": "closed", "ok": 5494, "ok_read_rps": 185.73333333333332, "ok_rps": 366.26666666666665, "ok_write_rps": 180.53333333333333, "rate": 0, "read_ms": {"max": 575.431, "p50": 8.028, "p95": 21.577, "p99": 50.281}, "requests": 5494, "timestamp": "2026-10-23T23:34:07Z", "warmup_s": 3, "write_ms": {"max": 883.076, "p50": 155.416, "p95": 221.738, "p99": 371.78}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.6, "cpu_pct_max_per_container": 22.7, "cpu_utilization_of_limit": 0.371, "mem_max_mib": 256.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.3, "cpu_pct_max_per_container": 4.6, "cpu_utilization_of_limit": 0.085, "mem_max_mib": 9.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.0, "cpu_pct_max_per_container": 23.2, "cpu_utilization_of_limit": 0.21, "mem_max_mib": 179.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.3, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.007, "mem_max_mib": 15.8}, "postgres_connections": {"active_max": 22, "active_mean": 3.7, "total_max": 36}}, "pool": {"acquires": 19167, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "leastconn", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4e589ba93674": 1284, "8fbb159ab159": 1266, "b4157b77454d": 1276, "c4ff6f12a0a5": 1230}, "label": "D_improvement/leastconn", "latency_ms": {"max": 830.594, "p50": 221.255, "p95": 439.631, "p99": 512.514}, "mode": "closed", "ok": 5056, "ok_read_rps": 166.73333333333332, "ok_rps": 337.06666666666666, "ok_write_rps": 170.33333333333334, "rate": 0, "read_ms": {"max": 289.098, "p50": 15.302, "p95": 44.715, "p99": 72.308}, "requests": 5056, "timestamp": "2026-10-23T23:34:27Z", "warmup_s": 3, "write_ms": {"max": 830.594, "p50": 348.692, "p95": 470.917, "p99": 557.561}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 16.5, "cpu_pct_max_per_container": 17.8, "cpu_utilization_of_limit": 0.331, "mem_max_mib": 256.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.2, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.084, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.1, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.201, "mem_max_mib": 249.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.0, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.981, "mem_max_mib": 16.9}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 64}}, "pool": {"acquires": 17717, "empty_acquire_ratio": 0.0016, "avg_acquire_wait_ms": 0.487, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "leastconn", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4e589ba93674": 1159, "8fbb159ab159": 1163, "b4157b77454d": 1211, "c4ff6f12a0a5": 1162}, "label": "D_improvement/leastconn", "latency_ms": {"max": 645.194, "p50": 245.687, "p95": 473.641, "p99": 566.287}, "mode": "closed", "ok": 4695, "ok_read_rps": 156.06666666666666, "ok_rps": 313, "ok_write_rps": 156.93333333333334, "rate": 0, "read_ms": {"max": 76.356, "p50": 16.37, "p95": 40.968, "p99": 58.011}, "requests": 4695, "timestamp": "2026-10-23T23:34:50Z", "warmup_s": 3, "write_ms": {"max": 645.194, "p50": 381.552, "p95": 506.161, "p99": 593.9}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 16.1, "cpu_pct_max_per_container": 18.8, "cpu_utilization_of_limit": 0.322, "mem_max_mib": 183.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.3, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.085, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.3, "cpu_pct_max_per_container": 20.6, "cpu_utilization_of_limit": 0.193, "mem_max_mib": 253.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.6, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.012, "mem_max_mib": 16.8}, "postgres_connections": {"active_max": 3, "active_mean": 0.4, "total_max": 64}}, "pool": {"acquires": 16465, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "D_improvement", "config": "leastconn", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "leastconn"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4e589ba93674": 1184, "8fbb159ab159": 1183, "b4157b77454d": 1200, "c4ff6f12a0a5": 1159}, "label": "D_improvement/leastconn", "latency_ms": {"max": 557.767, "p50": 73.89, "p95": 450.899, "p99": 487.279}, "mode": "closed", "ok": 4726, "ok_read_rps": 157.6, "ok_rps": 315.06666666666666, "ok_write_rps": 157.46666666666667, "rate": 0, "read_ms": {"max": 86.353, "p50": 16.396, "p95": 40.774, "p99": 55.758}, "requests": 4726, "timestamp": "2026-10-23T23:35:10Z", "warmup_s": 3, "write_ms": {"max": 557.767, "p50": 388.942, "p95": 467.561, "p99": 496.498}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 16.2, "cpu_pct_max_per_container": 18.9, "cpu_utilization_of_limit": 0.324, "mem_max_mib": 65.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.3, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.086, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.1, "cpu_pct_max_per_container": 21.9, "cpu_utilization_of_limit": 0.201, "mem_max_mib": 256.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 1.003, "mem_max_mib": 23.2}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 64}}, "pool": {"acquires": 16541, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"7b54f5789fac": 7319}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 53.453, "p50": 5.758, "p95": 28.408, "p99": 37.908}, "mode": "closed", "ok": 7319, "ok_read_rps": 239.93333333333334, "ok_rps": 487.93333333333334, "ok_write_rps": 248, "rate": 0, "read_ms": {"max": 53.453, "p50": 4.787, "p95": 25.453, "p99": 35.933}, "requests": 7319, "timestamp": "2026-10-23T23:26:41Z", "warmup_s": 3, "write_ms": {"max": 52.951, "p50": 6.721, "p95": 30.726, "p99": 38.617}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 138.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.8, "cpu_pct_max_per_container": 9.3, "cpu_utilization_of_limit": 0.176, "mem_max_mib": 8.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 43.4, "cpu_pct_max_per_container": 45.9, "cpu_utilization_of_limit": 0.434, "mem_max_mib": 42.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 8.9, "cpu_pct_max_per_container": 11.6, "cpu_utilization_of_limit": 0.178, "mem_max_mib": 32.1}, "postgres_connections": {"active_max": 2, "active_mean": 0.6, "total_max": 5}}, "pool": {"acquires": 25342, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"7b54f5789fac": 7439}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 60.289, "p50": 5.581, "p95": 28.384, "p99": 38.241}, "mode": "closed", "ok": 7439, "ok_read_rps": 246.73333333333332, "ok_rps": 495.93333333333334, "ok_write_rps": 249.2, "rate": 0, "read_ms": {"max": 57.37, "p50": 4.825, "p95": 23.217, "p99": 36.877}, "requests": 7439, "timestamp": "2026-10-23T23:27:04Z", "warmup_s": 3, "write_ms": {"max": 60.289, "p50": 6.424, "p95": 30.87, "p99": 39.144}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.7, "cpu_pct_max_per_container": 52.1, "cpu_utilization_of_limit": 1.014, "mem_max_mib": 231.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.0, "cpu_pct_max_per_container": 9.7, "cpu_utilization_of_limit": 0.181, "mem_max_mib": 8.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 42.2, "cpu_pct_max_per_container": 49.3, "cpu_utilization_of_limit": 0.422, "mem_max_mib": 49.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 9.1, "cpu_pct_max_per_container": 12.4, "cpu_utilization_of_limit": 0.182, "mem_max_mib": 57.6}, "postgres_connections": {"active_max": 2, "active_mean": 0.4, "total_max": 5}}, "pool": {"acquires": 25411, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"7b54f5789fac": 7313}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 69.505, "p50": 5.635, "p95": 29.339, "p99": 38.347}, "mode": "closed", "ok": 7313, "ok_read_rps": 243.4, "ok_rps": 487.53333333333336, "ok_write_rps": 244.13333333333333, "rate": 0, "read_ms": {"max": 67.899, "p50": 4.758, "p95": 26.287, "p99": 37.821}, "requests": 7313, "timestamp": "2026-10-23T23:27:26Z", "warmup_s": 3, "write_ms": {"max": 69.505, "p50": 6.522, "p95": 31.253, "p99": 39.233}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 49.7, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.994, "mem_max_mib": 234.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.8, "cpu_pct_max_per_container": 9.3, "cpu_utilization_of_limit": 0.175, "mem_max_mib": 8.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 39.4, "cpu_pct_max_per_container": 44.3, "cpu_utilization_of_limit": 0.394, "mem_max_mib": 51.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 11.5, "cpu_pct_max_per_container": 29.2, "cpu_utilization_of_limit": 0.229, "mem_max_mib": 68.2}, "postgres_connections": {"active_max": 3, "active_mean": 1, "total_max": 5}}, "pool": {"acquires": 24979, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"7b54f5789fac": 7909}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 149.51, "p50": 24.083, "p95": 65.489, "p99": 82.249}, "mode": "closed", "ok": 7909, "ok_read_rps": 260.73333333333335, "ok_rps": 527.2666666666667, "ok_write_rps": 266.53333333333336, "rate": 0, "read_ms": {"max": 86.098, "p50": 17.866, "p95": 52.277, "p99": 65.949}, "requests": 7909, "timestamp": "2026-10-23T23:27:48Z", "warmup_s": 3, "write_ms": {"max": 149.51, "p50": 32.059, "p95": 71.924, "p99": 92.494}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.7, "cpu_pct_max_per_container": 51.9, "cpu_utilization_of_limit": 1.014, "mem_max_mib": 188.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.1, "cpu_pct_max_per_container": 10.5, "cpu_utilization_of_limit": 0.183, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 46.8, "cpu_pct_max_per_container": 58.0, "cpu_utilization_of_limit": 0.468, "mem_max_mib": 82.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 8.0, "cpu_pct_max_per_container": 8.7, "cpu_utilization_of_limit": 0.16, "mem_max_mib": 67.4}, "postgres_connections": {"active_max": 7, "active_mean": 1.3, "total_max": 18}}, "pool": {"acquires": 26614, "empty_acquire_ratio": 0.0005, "avg_acquire_wait_ms": 0.047, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"7b54f5789fac": 7890}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 123.633, "p50": 24.379, "p95": 66.32, "p99": 83.148}, "mode": "closed", "ok": 7890, "ok_read_rps": 267.46666666666664, "ok_rps": 526, "ok_write_rps": 258.53333333333336, "rate": 0, "read_ms": {"max": 91.355, "p50": 17.746, "p95": 52.324, "p99": 65.273}, "requests": 7890, "timestamp": "2026-10-23T23:28:11Z", "warmup_s": 3, "write_ms": {"max": 123.633, "p50": 32.72, "p95": 72.485, "p99": 90.085}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.3, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 1.006, "mem_max_mib": 50.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.5, "cpu_pct_max_per_container": 9.2, "cpu_utilization_of_limit": 0.17, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 43.0, "cpu_pct_max_per_container": 46.5, "cpu_utilization_of_limit": 0.43, "mem_max_mib": 86.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 8.1, "cpu_pct_max_per_container": 11.5, "cpu_utilization_of_limit": 0.163, "mem_max_mib": 68.3}, "postgres_connections": {"active_max": 3, "active_mean": 0.9, "total_max": 17}}, "pool": {"acquires": 26873, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"7b54f5789fac": 7959}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 120.387, "p50": 24.535, "p95": 64.332, "p99": 82.527}, "mode": "closed", "ok": 7959, "ok_read_rps": 265.8666666666667, "ok_rps": 530.6, "ok_write_rps": 264.73333333333335, "rate": 0, "read_ms": {"max": 120.387, "p50": 18.953, "p95": 54.113, "p99": 67.276}, "requests": 7959, "timestamp": "2026-10-23T23:28:33Z", "warmup_s": 3, "write_ms": {"max": 107.608, "p50": 30.913, "p95": 70.332, "p99": 87.025}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 1.002, "mem_max_mib": 51.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.7, "cpu_pct_max_per_container": 9.5, "cpu_utilization_of_limit": 0.175, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 41.1, "cpu_pct_max_per_container": 46.1, "cpu_utilization_of_limit": 0.411, "mem_max_mib": 88.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 11.0, "cpu_pct_max_per_container": 22.8, "cpu_utilization_of_limit": 0.219, "mem_max_mib": 69.7}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 17}}, "pool": {"acquires": 27011, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"7b54f5789fac": 7886}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 295.234, "p50": 118.386, "p95": 179.628, "p99": 207.684}, "mode": "closed", "ok": 7886, "ok_read_rps": 266.2, "ok_rps": 525.7333333333333, "ok_write_rps": 259.53333333333336, "rate": 0, "read_ms": {"max": 225.095, "p50": 108.399, "p95": 163.152, "p99": 189.987}, "requests": 7886, "timestamp": "2026-10-23T23:28:55Z", "warmup_s": 3, "write_ms": {"max": 295.234, "p50": 130.144, "p95": 188.658, "p99": 216.929}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.7, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.013, "mem_max_mib": 56.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.1, "cpu_pct_max_per_container": 9.9, "cpu_utilization_of_limit": 0.181, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 53.8, "cpu_pct_max_per_container": 79.6, "cpu_utilization_of_limit": 0.538, "mem_max_mib": 106.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 9.1, "cpu_pct_max_per_container": 11.9, "cpu_utilization_of_limit": 0.182, "mem_max_mib": 70.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 20}}, "pool": {"acquires": 27760, "empty_acquire_ratio": 0.9801, "avg_acquire_wait_ms": 22.359, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"7b54f5789fac": 8249}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 295.268, "p50": 111.951, "p95": 175.29, "p99": 205.629}, "mode": "closed", "ok": 8249, "ok_read_rps": 275.6, "ok_rps": 549.9333333333333, "ok_write_rps": 274.3333333333333, "rate": 0, "read_ms": {"max": 230.832, "p50": 102.149, "p95": 154.202, "p99": 178.405}, "requests": 8249, "timestamp": "2026-10-23T23:29:19Z", "warmup_s": 3, "write_ms": {"max": 295.268, "p50": 124.507, "p95": 187.922, "p99": 214.422}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 1.002, "mem_max_mib": 55.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.4, "cpu_pct_max_per_container": 10.8, "cpu_utilization_of_limit": 0.189, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 44.4, "cpu_pct_max_per_container": 49.0, "cpu_utilization_of_limit": 0.444, "mem_max_mib": 102.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 9.2, "cpu_pct_max_per_container": 11.8, "cpu_utilization_of_limit": 0.183, "mem_max_mib": 69.0}, "postgres_connections": {"active_max": 3, "active_mean": 0.6, "total_max": 20}}, "pool": {"acquires": 29479, "empty_acquire_ratio": 0.9766, "avg_acquire_wait_ms": 19.911, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "1x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "1", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"7b54f5789fac": 7888}, "label": "E_scale_out_after_fix/1x0.50", "latency_ms": {"max": 294.755, "p50": 116.35, "p95": 181.856, "p99": 213.165}, "mode": "closed", "ok": 7888, "ok_read_rps": 269.26666666666665, "ok_rps": 525.8666666666667, "ok_write_rps": 256.6, "rate": 0, "read_ms": {"max": 261.128, "p50": 105.354, "p95": 160.336, "p99": 192.541}, "requests": 7888, "timestamp": "2026-10-23T23:29:41Z", "warmup_s": 3, "write_ms": {"max": 294.755, "p50": 131.095, "p95": 194.06, "p99": 229.481}, "write_ratio": 0.5}, "resources": {"api": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 1.0, "mem_max_mib": 60.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.0, "cpu_pct_max_per_container": 10.0, "cpu_utilization_of_limit": 0.181, "mem_max_mib": 10.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 49.0, "cpu_pct_max_per_container": 74.2, "cpu_utilization_of_limit": 0.49, "mem_max_mib": 106.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 12.8, "cpu_pct_max_per_container": 38.9, "cpu_utilization_of_limit": 0.256, "mem_max_mib": 72.1}, "postgres_connections": {"active_max": 7, "active_mean": 2, "total_max": 20}}, "pool": {"acquires": 27943, "empty_acquire_ratio": 0.966, "avg_acquire_wait_ms": 20.57, "pool_max_conns_total": 20}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4770041f3a94": 4754, "8e63a84dfe7b": 4756}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 41.294, "p50": 5.53, "p95": 11.509, "p99": 17.976}, "mode": "closed", "ok": 9510, "ok_read_rps": 309.46666666666664, "ok_rps": 634, "ok_write_rps": 324.53333333333336, "rate": 0, "read_ms": {"max": 41.04, "p50": 4.785, "p95": 9.95, "p99": 15.825}, "requests": 9510, "timestamp": "2026-10-23T23:30:13Z", "warmup_s": 3, "write_ms": {"max": 41.294, "p50": 6.305, "p95": 12.384, "p99": 19.187}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.4, "cpu_pct_max_per_container": 40.7, "cpu_utilization_of_limit": 0.769, "mem_max_mib": 138.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 10.3, "cpu_pct_max_per_container": 11.0, "cpu_utilization_of_limit": 0.205, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 51.2, "cpu_pct_max_per_container": 54.8, "cpu_utilization_of_limit": 0.512, "mem_max_mib": 80.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 14.2, "cpu_pct_max_per_container": 32.5, "cpu_utilization_of_limit": 0.283, "mem_max_mib": 62.1}, "postgres_connections": {"active_max": 2, "active_mean": 1.1, "total_max": 8}}, "pool": {"acquires": 32148, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4770041f3a94": 4448, "8e63a84dfe7b": 4447}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 52.077, "p50": 5.756, "p95": 13.001, "p99": 21.726}, "mode": "closed", "ok": 8895, "ok_read_rps": 298.46666666666664, "ok_rps": 593, "ok_write_rps": 294.53333333333336, "rate": 0, "read_ms": {"max": 52.077, "p50": 4.969, "p95": 11.088, "p99": 19.014}, "requests": 8895, "timestamp": "2026-10-23T23:30:34Z", "warmup_s": 3, "write_ms": {"max": 50.777, "p50": 6.573, "p95": 14.57, "p99": 23.149}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.8, "cpu_pct_max_per_container": 40.5, "cpu_utilization_of_limit": 0.777, "mem_max_mib": 244.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 10.4, "cpu_pct_max_per_container": 11.1, "cpu_utilization_of_limit": 0.208, "mem_max_mib": 10.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 50.7, "cpu_pct_max_per_container": 55.6, "cpu_utilization_of_limit": 0.507, "mem_max_mib": 83.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 13.6, "cpu_pct_max_per_container": 31.9, "cpu_utilization_of_limit": 0.273, "mem_max_mib": 80.7}, "postgres_connections": {"active_max": 2, "active_mean": 0.9, "total_max": 8}}, "pool": {"acquires": 30524, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4770041f3a94": 4491, "8e63a84dfe7b": 4492}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 63.595, "p50": 5.905, "p95": 11.884, "p99": 20.146}, "mode": "closed", "ok": 8983, "ok_read_rps": 294.1333333333333, "ok_rps": 598.8666666666667, "ok_write_rps": 304.73333333333335, "rate": 0, "read_ms": {"max": 52.817, "p50": 5.232, "p95": 10.729, "p99": 17.27}, "requests": 8983, "timestamp": "2026-10-23T23:30:54Z", "warmup_s": 3, "write_ms": {"max": 63.595, "p50": 6.578, "p95": 12.625, "p99": 21.518}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.3, "cpu_pct_max_per_container": 39.7, "cpu_utilization_of_limit": 0.767, "mem_max_mib": 243.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 10.2, "cpu_pct_max_per_container": 10.6, "cpu_utilization_of_limit": 0.204, "mem_max_mib": 10.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 55.7, "cpu_pct_max_per_container": 58.0, "cpu_utilization_of_limit": 0.557, "mem_max_mib": 89.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 10.7, "cpu_pct_max_per_container": 13.2, "cpu_utilization_of_limit": 0.214, "mem_max_mib": 82.9}, "postgres_connections": {"active_max": 2, "active_mean": 1, "total_max": 9}}, "pool": {"acquires": 30225, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4770041f3a94": 4213, "8e63a84dfe7b": 4211}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 275.654, "p50": 24.837, "p95": 60.239, "p99": 83.512}, "mode": "closed", "ok": 8424, "ok_read_rps": 280.26666666666665, "ok_rps": 561.6, "ok_write_rps": 281.3333333333333, "rate": 0, "read_ms": {"max": 275.654, "p50": 15.789, "p95": 36.916, "p99": 56.379}, "requests": 8424, "timestamp": "2026-10-23T23:31:17Z", "warmup_s": 3, "write_ms": {"max": 201.217, "p50": 36.213, "p95": 68.131, "p99": 94.114}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.2, "cpu_pct_max_per_container": 39.6, "cpu_utilization_of_limit": 0.763, "mem_max_mib": 214.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.6, "cpu_pct_max_per_container": 10.5, "cpu_utilization_of_limit": 0.192, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 58.0, "cpu_pct_max_per_container": 60.5, "cpu_utilization_of_limit": 0.58, "mem_max_mib": 141.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 18.1, "cpu_pct_max_per_container": 40.6, "cpu_utilization_of_limit": 0.362, "mem_max_mib": 80.6}, "postgres_connections": {"active_max": 8, "active_mean": 5.5, "total_max": 29}}, "pool": {"acquires": 28615, "empty_acquire_ratio": 0.0007, "avg_acquire_wait_ms": 0.05, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4770041f3a94": 4449, "8e63a84dfe7b": 4450}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 141.209, "p50": 23.477, "p95": 57.357, "p99": 81.291}, "mode": "closed", "ok": 8899, "ok_read_rps": 296.8, "ok_rps": 593.2666666666667, "ok_write_rps": 296.46666666666664, "rate": 0, "read_ms": {"max": 133.369, "p50": 15.226, "p95": 38.128, "p99": 61.251}, "requests": 8899, "timestamp": "2026-10-23T23:31:38Z", "warmup_s": 3, "write_ms": {"max": 141.209, "p50": 33.69, "p95": 64.981, "p99": 88.71}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.0, "cpu_pct_max_per_container": 40.5, "cpu_utilization_of_limit": 0.76, "mem_max_mib": 221.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.6, "cpu_pct_max_per_container": 10.2, "cpu_utilization_of_limit": 0.192, "mem_max_mib": 10.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 57.0, "cpu_pct_max_per_container": 61.6, "cpu_utilization_of_limit": 0.57, "mem_max_mib": 145.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 18.5, "cpu_pct_max_per_container": 39.5, "cpu_utilization_of_limit": 0.37, "mem_max_mib": 81.2}, "postgres_connections": {"active_max": 7, "active_mean": 2, "total_max": 30}}, "pool": {"acquires": 30142, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4770041f3a94": 4769, "8e63a84dfe7b": 4787}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 156.089, "p50": 22.309, "p95": 51.574, "p99": 72.74}, "mode": "closed", "ok": 9556, "ok_read_rps": 321.6, "ok_rps": 637.0666666666667, "ok_write_rps": 315.46666666666664, "rate": 0, "read_ms": {"max": 143.737, "p50": 14.571, "p95": 31.699, "p99": 47.916}, "requests": 9556, "timestamp": "2026-10-23T23:31:59Z", "warmup_s": 3, "write_ms": {"max": 156.089, "p50": 32.035, "p95": 58.856, "p99": 80.75}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.7, "cpu_pct_max_per_container": 40.8, "cpu_utilization_of_limit": 0.774, "mem_max_mib": 253.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.6, "cpu_pct_max_per_container": 10.2, "cpu_utilization_of_limit": 0.192, "mem_max_mib": 10.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 56.7, "cpu_pct_max_per_container": 59.1, "cpu_utilization_of_limit": 0.567, "mem_max_mib": 151.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 10.4, "cpu_pct_max_per_container": 13.3, "cpu_utilization_of_limit": 0.207, "mem_max_mib": 81.1}, "postgres_connections": {"active_max": 9, "active_mean": 3.4, "total_max": 29}}, "pool": {"acquires": 32127, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4770041f3a94": 4468, "8e63a84dfe7b": 4463}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 657.6, "p50": 94.256, "p95": 227.57, "p99": 320.038}, "mode": "closed", "ok": 8931, "ok_read_rps": 296.2, "ok_rps": 595.4, "ok_write_rps": 299.2, "rate": 0, "read_ms": {"max": 222.967, "p50": 62.766, "p95": 120.906, "p99": 147.901}, "requests": 8931, "timestamp": "2026-10-23T23:32:19Z", "warmup_s": 3, "write_ms": {"max": 657.6, "p50": 139.036, "p95": 264.804, "p99": 363.753}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 38.1, "cpu_pct_max_per_container": 41.4, "cpu_utilization_of_limit": 0.762, "mem_max_mib": 228.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.4, "cpu_pct_max_per_container": 9.9, "cpu_utilization_of_limit": 0.188, "mem_max_mib": 11.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 62.5, "cpu_pct_max_per_container": 64.2, "cpu_utilization_of_limit": 0.625, "mem_max_mib": 184.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 9.0, "cpu_pct_max_per_container": 9.5, "cpu_utilization_of_limit": 0.18, "mem_max_mib": 87.4}, "postgres_connections": {"active_max": 33, "active_mean": 20.2, "total_max": 40}}, "pool": {"acquires": 31019, "empty_acquire_ratio": 0.8676, "avg_acquire_wait_ms": 11.664, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4770041f3a94": 4012, "8e63a84dfe7b": 3958}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 578.529, "p50": 108.088, "p95": 253.719, "p99": 335.723}, "mode": "closed", "ok": 7970, "ok_read_rps": 258.93333333333334, "ok_rps": 531.3333333333334, "ok_write_rps": 272.4, "rate": 0, "read_ms": {"max": 346.61, "p50": 73.863, "p95": 151.663, "p99": 203.327}, "requests": 7970, "timestamp": "2026-10-23T23:32:40Z", "warmup_s": 3, "write_ms": {"max": 578.529, "p50": 152.376, "p95": 288.866, "p99": 367.895}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 36.3, "cpu_pct_max_per_container": 39.8, "cpu_utilization_of_limit": 0.726, "mem_max_mib": 61.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.9, "cpu_pct_max_per_container": 9.4, "cpu_utilization_of_limit": 0.179, "mem_max_mib": 11.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 63.1, "cpu_pct_max_per_container": 68.2, "cpu_utilization_of_limit": 0.631, "mem_max_mib": 191.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 13.8, "cpu_pct_max_per_container": 28.8, "cpu_utilization_of_limit": 0.276, "mem_max_mib": 91.5}, "postgres_connections": {"active_max": 36, "active_mean": 27.2, "total_max": 41}}, "pool": {"acquires": 27961, "empty_acquire_ratio": 0.7527, "avg_acquire_wait_ms": 12.451, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "2x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "2", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"4770041f3a94": 4205, "8e63a84dfe7b": 4210}, "label": "E_scale_out_after_fix/2x0.50", "latency_ms": {"max": 1089.417, "p50": 101.03, "p95": 244.149, "p99": 350.464}, "mode": "closed", "ok": 8415, "ok_read_rps": 282.26666666666665, "ok_rps": 561, "ok_write_rps": 278.73333333333335, "rate": 0, "read_ms": {"max": 268.063, "p50": 70.274, "p95": 143.144, "p99": 180.151}, "requests": 8415, "timestamp": "2026-10-23T23:33:02Z", "warmup_s": 3, "write_ms": {"max": 1089.417, "p50": 144.38, "p95": 283.093, "p99": 411.113}, "write_ratio": 0.5}, "resources": {"api": {"containers": 2, "cpu_pct_mean_per_container": 36.1, "cpu_pct_max_per_container": 40.5, "cpu_utilization_of_limit": 0.722, "mem_max_mib": 60.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.9, "cpu_pct_max_per_container": 10.0, "cpu_utilization_of_limit": 0.179, "mem_max_mib": 11.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 61.3, "cpu_pct_max_per_container": 63.6, "cpu_utilization_of_limit": 0.613, "mem_max_mib": 196.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 14.1, "cpu_pct_max_per_container": 21.1, "cpu_utilization_of_limit": 0.281, "mem_max_mib": 82.8}, "postgres_connections": {"active_max": 35, "active_mean": 29.5, "total_max": 40}}, "pool": {"acquires": 29213, "empty_acquire_ratio": 0.7529, "avg_acquire_wait_ms": 12.089, "pool_max_conns_total": 40}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 4, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"341f1c584d37": 2056, "45a6a0e6d809": 2056, "4770041f3a94": 2056, "8e63a84dfe7b": 2055}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 49.692, "p50": 6.272, "p95": 14.252, "p99": 22.445}, "mode": "closed", "ok": 8223, "ok_read_rps": 267.26666666666665, "ok_rps": 548.2, "ok_write_rps": 280.93333333333334, "rate": 0, "read_ms": {"max": 49.302, "p50": 5.106, "p95": 11.888, "p99": 17.97}, "requests": 8223, "timestamp": "2026-10-23T23:33:32Z", "warmup_s": 3, "write_ms": {"max": 49.692, "p50": 7.498, "p95": 15.702, "p99": 24.357}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.6, "cpu_pct_max_per_container": 22.5, "cpu_utilization_of_limit": 0.392, "mem_max_mib": 138.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.9, "cpu_pct_max_per_container": 10.5, "cpu_utilization_of_limit": 0.198, "mem_max_mib": 10.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 53.0, "cpu_pct_max_per_container": 54.3, "cpu_utilization_of_limit": 0.53, "mem_max_mib": 207.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 11.3, "cpu_pct_max_per_container": 20.0, "cpu_utilization_of_limit": 0.226, "mem_max_mib": 67.3}, "postgres_connections": {"active_max": 3, "active_mean": 1.5, "total_max": 46}}, "pool": {"acquires": 27832, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 4, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"341f1c584d37": 2075, "45a6a0e6d809": 2073, "4770041f3a94": 2074, "8e63a84dfe7b": 2073}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 115.844, "p50": 6.196, "p95": 14.155, "p99": 22.003}, "mode": "closed", "ok": 8295, "ok_read_rps": 274, "ok_rps": 553, "ok_write_rps": 279, "rate": 0, "read_ms": {"max": 57.283, "p50": 5.139, "p95": 10.773, "p99": 19.496}, "requests": 8295, "timestamp": "2026-10-23T23:33:55Z", "warmup_s": 3, "write_ms": {"max": 115.844, "p50": 7.432, "p95": 15.777, "p99": 23.74}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.3, "cpu_pct_max_per_container": 23.2, "cpu_utilization_of_limit": 0.406, "mem_max_mib": 238.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.9, "cpu_pct_max_per_container": 10.4, "cpu_utilization_of_limit": 0.199, "mem_max_mib": 10.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 52.8, "cpu_pct_max_per_container": 54.6, "cpu_utilization_of_limit": 0.528, "mem_max_mib": 215.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 10.1, "cpu_pct_max_per_container": 13.4, "cpu_utilization_of_limit": 0.203, "mem_max_mib": 70.2}, "postgres_connections": {"active_max": 2, "active_mean": 0.8, "total_max": 48}}, "pool": {"acquires": 27749, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 4, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 4, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"341f1c584d37": 2065, "45a6a0e6d809": 2064, "4770041f3a94": 2063, "8e63a84dfe7b": 2062}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 51.851, "p50": 6.211, "p95": 14.038, "p99": 23.232}, "mode": "closed", "ok": 8254, "ok_read_rps": 273.3333333333333, "ok_rps": 550.2666666666667, "ok_write_rps": 276.93333333333334, "rate": 0, "read_ms": {"max": 50.14, "p50": 5.106, "p95": 10.931, "p99": 18.232}, "requests": 8254, "timestamp": "2026-10-23T23:34:15Z", "warmup_s": 3, "write_ms": {"max": 51.851, "p50": 7.502, "p95": 16.46, "p99": 25.971}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.7, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.414, "mem_max_mib": 254.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 10.2, "cpu_pct_max_per_container": 10.6, "cpu_utilization_of_limit": 0.203, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 51.3, "cpu_pct_max_per_container": 53.9, "cpu_utilization_of_limit": 0.513, "mem_max_mib": 219.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 10.7, "cpu_pct_max_per_container": 13.6, "cpu_utilization_of_limit": 0.214, "mem_max_mib": 81.1}, "postgres_connections": {"active_max": 4, "active_mean": 1.6, "total_max": 48}}, "pool": {"acquires": 28129, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"341f1c584d37": 2022, "45a6a0e6d809": 2020, "4770041f3a94": 2019, "8e63a84dfe7b": 2019}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 229.304, "p50": 24.739, "p95": 64.572, "p99": 96.194}, "mode": "closed", "ok": 8080, "ok_read_rps": 272.26666666666665, "ok_rps": 538.6666666666666, "ok_write_rps": 266.4, "rate": 0, "read_ms": {"max": 126.018, "p50": 14.585, "p95": 34.612, "p99": 54.485}, "requests": 8080, "timestamp": "2026-10-23T23:34:37Z", "warmup_s": 3, "write_ms": {"max": 229.304, "p50": 40.284, "p95": 76.532, "p99": 111.785}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.2, "cpu_pct_max_per_container": 24.3, "cpu_utilization_of_limit": 0.403, "mem_max_mib": 242.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 10.0, "cpu_pct_max_per_container": 10.3, "cpu_utilization_of_limit": 0.2, "mem_max_mib": 10.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 54.5, "cpu_pct_max_per_container": 57.9, "cpu_utilization_of_limit": 0.545, "mem_max_mib": 242.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 9.3, "cpu_pct_max_per_container": 10.3, "cpu_utilization_of_limit": 0.186, "mem_max_mib": 80.2}, "postgres_connections": {"active_max": 8, "active_mean": 5.8, "total_max": 56}}, "pool": {"acquires": 27521, "empty_acquire_ratio": 0.0003, "avg_acquire_wait_ms": 0.03, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"341f1c584d37": 2045, "45a6a0e6d809": 2045, "4770041f3a94": 2044, "8e63a84dfe7b": 2043}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 145.118, "p50": 24.948, "p95": 63.378, "p99": 82.525}, "mode": "closed", "ok": 8177, "ok_read_rps": 272.8, "ok_rps": 545.1333333333333, "ok_write_rps": 272.3333333333333, "rate": 0, "read_ms": {"max": 113.257, "p50": 14.488, "p95": 32.73, "p99": 51.358}, "requests": 8177, "timestamp": "2026-10-23T23:34:58Z", "warmup_s": 3, "write_ms": {"max": 145.118, "p50": 40.016, "p95": 71.036, "p99": 92.125}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.2, "cpu_pct_max_per_container": 24.7, "cpu_utilization_of_limit": 0.404, "mem_max_mib": 242.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.9, "cpu_pct_max_per_container": 10.4, "cpu_utilization_of_limit": 0.198, "mem_max_mib": 10.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 56.9, "cpu_pct_max_per_container": 60.2, "cpu_utilization_of_limit": 0.569, "mem_max_mib": 245.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 10.4, "cpu_pct_max_per_container": 13.2, "cpu_utilization_of_limit": 0.208, "mem_max_mib": 78.0}, "postgres_connections": {"active_max": 8, "active_mean": 6.8, "total_max": 56}}, "pool": {"acquires": 27999, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"341f1c584d37": 2009, "45a6a0e6d809": 2011, "4770041f3a94": 2007, "8e63a84dfe7b": 2010}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 202.52, "p50": 25.359, "p95": 64.903, "p99": 96.41}, "mode": "closed", "ok": 8037, "ok_read_rps": 269.93333333333334, "ok_rps": 535.8, "ok_write_rps": 265.8666666666667, "rate": 0, "read_ms": {"max": 121.647, "p50": 14.558, "p95": 35.117, "p99": 53.197}, "requests": 8037, "timestamp": "2026-10-23T23:35:19Z", "warmup_s": 3, "write_ms": {"max": 202.52, "p50": 40.332, "p95": 75.625, "p99": 110.349}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.3, "cpu_pct_max_per_container": 21.8, "cpu_utilization_of_limit": 0.386, "mem_max_mib": 243.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 9.3, "cpu_pct_max_per_container": 10.1, "cpu_utilization_of_limit": 0.185, "mem_max_mib": 10.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 50.9, "cpu_pct_max_per_container": 55.8, "cpu_utilization_of_limit": 0.509, "mem_max_mib": 248.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 12.4, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.248, "mem_max_mib": 83.5}, "postgres_connections": {"active_max": 16, "active_mean": 5.4, "total_max": 56}}, "pool": {"acquires": 27346, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"341f1c584d37": 1755, "45a6a0e6d809": 1750, "4770041f3a94": 1737, "8e63a84dfe7b": 1738}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 2110.687, "p50": 83.303, "p95": 456.482, "p99": 829.035}, "mode": "closed", "ok": 6980, "ok_read_rps": 232.4, "ok_rps": 465.3333333333333, "ok_write_rps": 232.93333333333334, "rate": 0, "read_ms": {"max": 273.397, "p50": 40.272, "p95": 118.648, "p99": 176.984}, "requests": 6980, "timestamp": "2026-10-23T23:35:43Z", "warmup_s": 3, "write_ms": {"max": 2110.687, "p50": 162.575, "p95": 629.875, "p99": 986.418}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.8, "cpu_pct_max_per_container": 21.5, "cpu_utilization_of_limit": 0.357, "mem_max_mib": 246.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.4, "cpu_pct_max_per_container": 8.7, "cpu_utilization_of_limit": 0.168, "mem_max_mib": 11.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 68.0, "cpu_pct_max_per_container": 74.2, "cpu_utilization_of_limit": 0.68, "mem_max_mib": 317.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 9.1, "cpu_pct_max_per_container": 11.9, "cpu_utilization_of_limit": 0.183, "mem_max_mib": 76.0}, "postgres_connections": {"active_max": 62, "active_mean": 52.5, "total_max": 81}}, "pool": {"acquires": 23727, "empty_acquire_ratio": 0.12, "avg_acquire_wait_ms": 1.869, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"341f1c584d37": 1928, "45a6a0e6d809": 1916, "4770041f3a94": 1921, "8e63a84dfe7b": 1934}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 2593.861, "p50": 74.531, "p95": 392.002, "p99": 848.891}, "mode": "closed", "ok": 7699, "ok_read_rps": 252.66666666666666, "ok_rps": 513.2666666666667, "ok_write_rps": 260.6, "rate": 0, "read_ms": {"max": 246.963, "p50": 37.216, "p95": 109.495, "p99": 151.743}, "requests": 7699, "timestamp": "2026-10-23T23:36:04Z", "warmup_s": 3, "write_ms": {"max": 2593.861, "p50": 139.415, "p95": 572.154, "p99": 1031.392}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.0, "cpu_pct_max_per_container": 22.2, "cpu_utilization_of_limit": 0.38, "mem_max_mib": 66.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.6, "cpu_pct_max_per_container": 9.2, "cpu_utilization_of_limit": 0.173, "mem_max_mib": 11.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 62.8, "cpu_pct_max_per_container": 67.9, "cpu_utilization_of_limit": 0.628, "mem_max_mib": 316.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 9.3, "cpu_pct_max_per_container": 12.2, "cpu_utilization_of_limit": 0.186, "mem_max_mib": 71.6}, "postgres_connections": {"active_max": 53, "active_mean": 44.8, "total_max": 80}}, "pool": {"acquires": 25939, "empty_acquire_ratio": 0.1466, "avg_acquire_wait_ms": 1.574, "pool_max_conns_total": 80}} +{"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"341f1c584d37": 1980, "45a6a0e6d809": 1979, "4770041f3a94": 1979, "8e63a84dfe7b": 1975}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 1989.892, "p50": 78.118, "p95": 375.37, "p99": 652.649}, "mode": "closed", "ok": 7913, "ok_read_rps": 265.6, "ok_rps": 527.5333333333333, "ok_write_rps": 261.93333333333334, "rate": 0, "read_ms": {"max": 338.686, "p50": 40.634, "p95": 121.587, "p99": 171.549}, "requests": 7913, "timestamp": "2026-10-23T23:36:25Z", "warmup_s": 3, "write_ms": {"max": 1989.892, "p50": 145.256, "p95": 493.903, "p99": 829.45}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.7, "cpu_pct_max_per_container": 22.0, "cpu_utilization_of_limit": 0.373, "mem_max_mib": 66.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.6, "cpu_pct_max_per_container": 9.0, "cpu_utilization_of_limit": 0.171, "mem_max_mib": 11.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 60.7, "cpu_pct_max_per_container": 62.4, "cpu_utilization_of_limit": 0.607, "mem_max_mib": 319.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 13.8, "cpu_pct_max_per_container": 25.9, "cpu_utilization_of_limit": 0.277, "mem_max_mib": 74.8}, "postgres_connections": {"active_max": 59, "active_mean": 37, "total_max": 80}}, "pool": {"acquires": 27161, "empty_acquire_ratio": 0.0764, "avg_acquire_wait_ms": 0.568, "pool_max_conns_total": 80}} diff --git a/evidence/track1/report.html b/evidence/track1/report.html new file mode 100644 index 00000000..cac3f910 --- /dev/null +++ b/evidence/track1/report.html @@ -0,0 +1,33 @@ +Трек 1 отчёт

Трек 1 — цена масштабирования

Медианы по повторам. Наведите на точку — значение. Полные данные — таблицы под графиками и summary.csv.

A_fixed_total — Фиксированный суммарный бюджет API: 1.0 CPU / 768M

Гипотеза: При фиксированном суммарном CPU рост числа реплик не увеличивает пиковый RPS (тот же бюджет) и немного ухудшает p95 из-за накладных расходов на процесс и пул соединений; выигрыш реплик — только отказоустойчивость.

Успешные RPS
1x1.002x0.504x0.25
010020030040050041664параллелизм (closed-loop воркеры)ok RPS1x1.002x0.504x0.25
p95 задержки, мс
1x1.002x0.504x0.25
010020030040041664параллелизм (closed-loop воркеры)мс1x1.002x0.504x0.25
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
1x1.00460.31.00×6416redis (1.00) — насыщена67%0.000 / 0.00
2x0.50435.90.95×1616redis (1.00) — насыщена74%0.000 / 0.00
4x0.25474.51.03×6464api (0.53)46%0.001 / 0.05
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
1x1.0043400.0380.3409.6198.0202.09.5029.0038.000.00000.600.201.020.091.35/20.0000.001
1x1.00163431.1419.1435.1213.2214.931.9987.64114.580.00000.590.201.000.101.34/20.0000.001
1x1.00643460.3439.5466.0229.7229.9203.62323.70364.450.00000.650.210.990.101.43/20.0150.061
2x0.5043414.0376.7416.1203.9208.58.5323.9534.560.00000.750.181.020.091.49/20.0000.001
2x0.50163435.9426.3446.4217.3218.522.7193.78116.920.00000.720.211.000.101.48/20.0000.001
2x0.50643432.1390.1446.1222.3209.768.66411.81499.590.00000.720.221.000.101.49/20.0030.010
4x0.2543365.9351.5395.9182.5183.58.7424.9650.780.00000.830.190.950.091.54/20.0000.002
4x0.25163430.7405.5454.6217.2213.524.5793.21141.180.00000.860.200.930.091.56/20.0000.011
4x0.25643474.5469.9479.0231.9241.353.35326.69406.510.00000.530.130.450.050.91/20.0010.051

B_scale_out — Рост ресурсов: реплики по 0.5 CPU, БД 1.0 CPU, LB 0.5 CPU

Гипотеза: Пиковый RPS растёт почти линейно, пока узкое место — CPU API; затем рост останавливается на общей зависимости (PostgreSQL, Redis или LB), чья утилизация CPU приближается к лимиту.

Успешные RPS
1x0.502x0.504x0.50
010020030040041664параллелизм (closed-loop воркеры)ok RPS1x0.502x0.504x0.50
p95 задержки, мс
1x0.502x0.504x0.50
010020030040041664параллелизм (closed-loop воркеры)мс1x0.502x0.504x0.50
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
1x0.50395.11.00×1664api (0.99) — насыщена59%0.015 / 0.08
2x0.50426.71.08×6416redis (1.01) — насыщена75%0.000 / 0.00
4x0.50419.01.06×6416redis (1.00) — насыщена80%0.000 / 0.00
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
1x0.5043353.9345.9360.0177.0173.910.6640.4145.860.00001.000.190.870.091.17/20.0000.001
1x0.50163395.1380.5400.1195.1195.637.8593.43116.110.00001.000.200.890.101.19/20.0000.001
1x0.50643357.7355.3368.2178.9179.661.60381.45406.440.00000.990.210.830.091.17/20.0150.081
2x0.5043387.1385.9388.9194.2193.310.1526.3434.550.00000.690.221.010.101.46/20.0000.001
2x0.50163421.7416.1428.3209.1212.625.0190.25117.630.00000.670.261.010.111.50/20.0000.001
2x0.50643426.7415.9430.6210.0208.776.17404.13457.300.00000.670.271.000.101.49/20.0060.080
4x0.5043387.3371.2396.7191.5191.210.1424.8733.900.00000.390.231.000.101.56/20.0000.001
4x0.50163402.7391.3405.7200.1201.032.2695.64119.370.00000.380.261.000.111.59/20.0000.003
4x0.50643419.0407.6420.2210.3206.5213.44343.64390.490.00000.370.280.970.111.57/20.0000.003

C_shared_resources — 4×0.5 CPU API, меняем ресурсы общих зависимостей

Гипотеза: Если насыщение B вызвано общей зависимостью, увеличение её CPU поднимает пиковый RPS, а увеличение CPU других зависимостей — нет.

Успешные RPS
pg1_lb0.5_redis0.5pg2lb1redis1
01002003004001664параллелизм (closed-loop воркеры)ok RPSpg1_lb0.5_redis0.5pg2lb1redis1
p95 задержки, мс
pg1_lb0.5_redis0.5pg2lb1redis1
01002003004005001664параллелизм (closed-loop воркеры)мсpg1_lb0.5_redis0.5pg2lb1redis1
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
pg1_lb0.5_redis0.5331.21.00×1664redis (1.00) — насыщена73%0.000 / 0.01
pg2383.41.16×6464redis (0.96) — насыщена78%0.000 / 0.01
lb1410.91.24×6464redis (0.97) — насыщена78%0.001 / 0.11
redis1404.61.22×6464redis (0.50)81%0.000 / 0.01
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
pg1_lb0.5_redis0.5163331.2293.6348.9162.6168.636.93118.80150.910.00000.350.211.010.101.46/20.0000.003
pg1_lb0.5_redis0.5643322.7292.9332.1162.0158.253.27463.75550.180.00000.350.201.000.101.45/20.0000.011
pg2163320.5305.4396.8160.1160.436.26126.09148.150.00000.350.121.000.101.48/20.0000.000
pg2643383.4367.1416.1189.6193.8186.51395.19479.100.00000.390.120.960.101.56/20.0000.011
lb1163356.3353.3356.5175.9180.125.45112.79149.760.00000.380.220.960.051.53/20.0000.010
lb1643410.9374.8423.0202.8208.141.57379.46477.930.00000.400.240.970.051.57/20.0010.111
redis1163392.0372.1398.1193.8198.229.38104.05131.510.00000.430.230.490.101.62/20.0000.003
redis1643404.6374.3412.5199.3205.347.10405.32468.330.00000.420.240.500.111.63/20.0000.011

D_improvement — Кандидаты улучшения на 4×0.5 CPU

Гипотеза: Инвалидация кэша истории через SCAN (lab2) делает O(keyspace/100) запросов к Redis на каждую запись; ключ с версией чата (CACHE_INVALIDATION=version) делает 1 INCR и поднимает RPS записи при большом keyspace. Альтернативы: меньший пул на реплику, leastconn.

Успешные RPS
baseline_scancache_versionpool_8leastconn
02004006008003264параллелизм (closed-loop воркеры)ok RPSbaseline_scancache_versionpool_8leastconn
p95 задержки, мс
baseline_scancache_versionpool_8leastconn
01002003004003264параллелизм (closed-loop воркеры)мсbaseline_scancache_versionpool_8leastconn
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
baseline_scan374.51.00×3264redis (0.99) — насыщена76%0.000 / 0.01
cache_version817.62.18×6464postgres (0.76)79%0.103 / 0.65
pool_8361.70.97×6464redis (0.97) — насыщена73%0.012 / 0.39
leastconn365.30.98×3264redis (1.00) — насыщена70%0.000 / 0.00

Кандидаты против baseline_scan

кандидатcΔRPS %Δp95 %повторы b/cподтверждено
cache_version64125.8-42.13/3да
pool_864-0.1-2.03/3нет
leastconn64-13.07.03/3нет
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
baseline_scan323374.5367.3374.7185.8187.549.48210.73259.880.00000.370.220.990.101.52/20.0000.012
baseline_scan643362.1357.8391.1179.5182.749.47421.49490.890.00000.380.210.990.101.52/20.0000.012
cache_version323721.6670.7790.6357.4364.228.89131.66234.130.00000.290.820.150.171.59/20.0010.0131
cache_version643817.6781.9870.0410.5407.147.20243.84516.490.00000.310.760.210.181.59/20.1030.6558
pool_8323361.5270.6395.8181.5179.980.97213.58259.730.00000.370.221.010.091.53/20.0040.020
pool_8643361.7308.7388.8180.5181.2111.06412.93635.540.00000.360.210.970.091.46/20.0120.393
leastconn323365.3361.9366.3181.6183.549.28204.72245.420.00000.360.211.000.091.47/20.0000.002
leastconn643315.1313.0337.1157.5157.6221.25450.90512.510.00000.320.201.000.091.39/20.0000.000

E_scale_out_after_fix — Рост реплик после улучшения (CACHE_INVALIDATION=version), реплики по 0.5 CPU

Гипотеза: После снятия упора в Redis рост реплик снова увеличивает RPS, пока не насытится следующая общая зависимость (ожидаем PostgreSQL) или CPU хоста.

Успешные RPS
1x0.502x0.504x0.50
020040060041664параллелизм (closed-loop воркеры)ok RPS1x0.502x0.504x0.50
p95 задержки, мс
1x0.502x0.504x0.50
010020030040041664параллелизм (closed-loop воркеры)мс1x0.502x0.504x0.50
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
1x0.50527.31.00×1616api (1.01) — насыщена55%0.000 / 0.00
2x0.50598.91.14×416api (0.76)81%0.000 / 0.00
4x0.50550.31.04×416postgres (0.55)77%0.000 / 0.00
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
1x0.5043487.9487.5495.9248.0243.45.6328.4138.240.00001.000.420.180.181.11/20.0000.002
1x0.50163527.3526.0530.6264.7265.924.3865.4982.530.00001.010.430.160.171.11/20.0000.003
1x0.50643525.9525.7549.9259.5269.3116.35179.63207.680.00001.000.490.180.181.21/20.97720.573
2x0.5043598.9593.0634.0304.7298.55.7611.8820.150.00000.770.510.270.201.53/20.0000.002
2x0.50163593.3561.6637.1296.5296.823.4857.3681.290.00000.760.570.360.191.61/20.0000.008
2x0.50643561.0531.3595.4278.7282.3101.03244.15335.720.00000.730.620.280.181.57/20.75312.0935
4x0.5043550.3548.2553.0279.0273.36.2114.1522.450.00000.410.530.210.201.54/20.0000.003
4x0.50163538.7535.8545.1266.4272.324.9564.5796.190.00000.400.550.210.201.54/20.0000.008
4x0.50643513.3465.3527.5260.6252.778.12392.00829.030.00000.370.630.190.171.57/20.1201.5759
\ No newline at end of file diff --git a/evidence/track1/runner_A_fixed_total.txt b/evidence/track1/runner_A_fixed_total.txt new file mode 100644 index 00000000..cfeaf460 --- /dev/null +++ b/evidence/track1/runner_A_fixed_total.txt @@ -0,0 +1,6 @@ +2 + total used free shared buff/cache available +Mem: 7938 1463 1957 130 4967 6474 +Swap: 3071 40 3031 +CPU(s): 2 +Model name: AMD EPYC 9V45 96-Core Processor diff --git a/evidence/track1/runner_B_scale_out.txt b/evidence/track1/runner_B_scale_out.txt new file mode 100644 index 00000000..0f9fe7b7 --- /dev/null +++ b/evidence/track1/runner_B_scale_out.txt @@ -0,0 +1,7 @@ +2 + total used free shared buff/cache available +Mem: 7937 1587 1828 126 4962 6349 +Swap: 3071 11 3060 +CPU(s): 2 +Model name: INTEL(R) XEON(R) PLATINUM 8573C +CPU(s) scaling MHz: 152% diff --git a/evidence/track1/runner_C_shared_resources.txt b/evidence/track1/runner_C_shared_resources.txt new file mode 100644 index 00000000..ebe5fbd0 --- /dev/null +++ b/evidence/track1/runner_C_shared_resources.txt @@ -0,0 +1,6 @@ +2 + total used free shared buff/cache available +Mem: 7938 1466 2050 98 4834 6471 +Swap: 3071 21 3050 +CPU(s): 2 +Model name: AMD EPYC 9V45 96-Core Processor diff --git a/evidence/track1/runner_D_improvement.txt b/evidence/track1/runner_D_improvement.txt new file mode 100644 index 00000000..465dd092 --- /dev/null +++ b/evidence/track1/runner_D_improvement.txt @@ -0,0 +1,6 @@ +2 + total used free shared buff/cache available +Mem: 7938 1506 1911 130 4965 6431 +Swap: 3071 22 3049 +CPU(s): 2 +Model name: AMD EPYC 9V45 96-Core Processor diff --git a/evidence/track1/runner_E_scale_out_after_fix.txt b/evidence/track1/runner_E_scale_out_after_fix.txt new file mode 100644 index 00000000..26bf28ab --- /dev/null +++ b/evidence/track1/runner_E_scale_out_after_fix.txt @@ -0,0 +1,6 @@ +2 + total used free shared buff/cache available +Mem: 7938 1725 1666 146 5006 6212 +Swap: 3071 12 3059 +CPU(s): 2 +Model name: AMD EPYC 7763 64-Core Processor diff --git a/evidence/track1/summary.csv b/evidence/track1/summary.csv new file mode 100644 index 00000000..0e5af936 --- /dev/null +++ b/evidence/track1/summary.csv @@ -0,0 +1,44 @@ +series,config,c,repeats,ok_rps,rps_min,rps_max,write_rps,read_rps,p50_ms,p95_ms,p99_ms,err,util_api,util_pg,util_redis,util_lb,host_cores,pool_empty,pool_wait_ms,pg_active +A_fixed_total,1x1.00,4,3,400.0,380.3,409.6,198.0,202.0,9.50,29.00,38.00,0.0000,0.60,0.20,1.02,0.09,1.35/2,0.000,0.00,1 +A_fixed_total,1x1.00,16,3,431.1,419.1,435.1,213.2,214.9,31.99,87.64,114.58,0.0000,0.59,0.20,1.00,0.10,1.34/2,0.000,0.00,1 +A_fixed_total,1x1.00,64,3,460.3,439.5,466.0,229.7,229.9,203.62,323.70,364.45,0.0000,0.65,0.21,0.99,0.10,1.43/2,0.015,0.06,1 +A_fixed_total,2x0.50,4,3,414.0,376.7,416.1,203.9,208.5,8.53,23.95,34.56,0.0000,0.75,0.18,1.02,0.09,1.49/2,0.000,0.00,1 +A_fixed_total,2x0.50,16,3,435.9,426.3,446.4,217.3,218.5,22.71,93.78,116.92,0.0000,0.72,0.21,1.00,0.10,1.48/2,0.000,0.00,1 +A_fixed_total,2x0.50,64,3,432.1,390.1,446.1,222.3,209.7,68.66,411.81,499.59,0.0000,0.72,0.22,1.00,0.10,1.49/2,0.003,0.01,0 +A_fixed_total,4x0.25,4,3,365.9,351.5,395.9,182.5,183.5,8.74,24.96,50.78,0.0000,0.83,0.19,0.95,0.09,1.54/2,0.000,0.00,2 +A_fixed_total,4x0.25,16,3,430.7,405.5,454.6,217.2,213.5,24.57,93.21,141.18,0.0000,0.86,0.20,0.93,0.09,1.56/2,0.000,0.01,1 +A_fixed_total,4x0.25,64,3,474.5,469.9,479.0,231.9,241.3,53.35,326.69,406.51,0.0000,0.53,0.13,0.45,0.05,0.91/2,0.001,0.05,1 +B_scale_out,1x0.50,4,3,353.9,345.9,360.0,177.0,173.9,10.66,40.41,45.86,0.0000,1.00,0.19,0.87,0.09,1.17/2,0.000,0.00,1 +B_scale_out,1x0.50,16,3,395.1,380.5,400.1,195.1,195.6,37.85,93.43,116.11,0.0000,1.00,0.20,0.89,0.10,1.19/2,0.000,0.00,1 +B_scale_out,1x0.50,64,3,357.7,355.3,368.2,178.9,179.6,61.60,381.45,406.44,0.0000,0.99,0.21,0.83,0.09,1.17/2,0.015,0.08,1 +B_scale_out,2x0.50,4,3,387.1,385.9,388.9,194.2,193.3,10.15,26.34,34.55,0.0000,0.69,0.22,1.01,0.10,1.46/2,0.000,0.00,1 +B_scale_out,2x0.50,16,3,421.7,416.1,428.3,209.1,212.6,25.01,90.25,117.63,0.0000,0.67,0.26,1.01,0.11,1.50/2,0.000,0.00,1 +B_scale_out,2x0.50,64,3,426.7,415.9,430.6,210.0,208.7,76.17,404.13,457.30,0.0000,0.67,0.27,1.00,0.10,1.49/2,0.006,0.08,0 +B_scale_out,4x0.50,4,3,387.3,371.2,396.7,191.5,191.2,10.14,24.87,33.90,0.0000,0.39,0.23,1.00,0.10,1.56/2,0.000,0.00,1 +B_scale_out,4x0.50,16,3,402.7,391.3,405.7,200.1,201.0,32.26,95.64,119.37,0.0000,0.38,0.26,1.00,0.11,1.59/2,0.000,0.00,3 +B_scale_out,4x0.50,64,3,419.0,407.6,420.2,210.3,206.5,213.44,343.64,390.49,0.0000,0.37,0.28,0.97,0.11,1.57/2,0.000,0.00,3 +C_shared_resources,pg1_lb0.5_redis0.5,16,3,331.2,293.6,348.9,162.6,168.6,36.93,118.80,150.91,0.0000,0.35,0.21,1.01,0.10,1.46/2,0.000,0.00,3 +C_shared_resources,pg1_lb0.5_redis0.5,64,3,322.7,292.9,332.1,162.0,158.2,53.27,463.75,550.18,0.0000,0.35,0.20,1.00,0.10,1.45/2,0.000,0.01,1 +C_shared_resources,pg2,16,3,320.5,305.4,396.8,160.1,160.4,36.26,126.09,148.15,0.0000,0.35,0.12,1.00,0.10,1.48/2,0.000,0.00,0 +C_shared_resources,pg2,64,3,383.4,367.1,416.1,189.6,193.8,186.51,395.19,479.10,0.0000,0.39,0.12,0.96,0.10,1.56/2,0.000,0.01,1 +C_shared_resources,lb1,16,3,356.3,353.3,356.5,175.9,180.1,25.45,112.79,149.76,0.0000,0.38,0.22,0.96,0.05,1.53/2,0.000,0.01,0 +C_shared_resources,lb1,64,3,410.9,374.8,423.0,202.8,208.1,41.57,379.46,477.93,0.0000,0.40,0.24,0.97,0.05,1.57/2,0.001,0.11,1 +C_shared_resources,redis1,16,3,392.0,372.1,398.1,193.8,198.2,29.38,104.05,131.51,0.0000,0.43,0.23,0.49,0.10,1.62/2,0.000,0.00,3 +C_shared_resources,redis1,64,3,404.6,374.3,412.5,199.3,205.3,47.10,405.32,468.33,0.0000,0.42,0.24,0.50,0.11,1.63/2,0.000,0.01,1 +D_improvement,baseline_scan,32,3,374.5,367.3,374.7,185.8,187.5,49.48,210.73,259.88,0.0000,0.37,0.22,0.99,0.10,1.52/2,0.000,0.01,2 +D_improvement,baseline_scan,64,3,362.1,357.8,391.1,179.5,182.7,49.47,421.49,490.89,0.0000,0.38,0.21,0.99,0.10,1.52/2,0.000,0.01,2 +D_improvement,cache_version,32,3,721.6,670.7,790.6,357.4,364.2,28.89,131.66,234.13,0.0000,0.29,0.82,0.15,0.17,1.59/2,0.001,0.01,31 +D_improvement,cache_version,64,3,817.6,781.9,870.0,410.5,407.1,47.20,243.84,516.49,0.0000,0.31,0.76,0.21,0.18,1.59/2,0.103,0.65,58 +D_improvement,pool_8,32,3,361.5,270.6,395.8,181.5,179.9,80.97,213.58,259.73,0.0000,0.37,0.22,1.01,0.09,1.53/2,0.004,0.02,0 +D_improvement,pool_8,64,3,361.7,308.7,388.8,180.5,181.2,111.06,412.93,635.54,0.0000,0.36,0.21,0.97,0.09,1.46/2,0.012,0.39,3 +D_improvement,leastconn,32,3,365.3,361.9,366.3,181.6,183.5,49.28,204.72,245.42,0.0000,0.36,0.21,1.00,0.09,1.47/2,0.000,0.00,2 +D_improvement,leastconn,64,3,315.1,313.0,337.1,157.5,157.6,221.25,450.90,512.51,0.0000,0.32,0.20,1.00,0.09,1.39/2,0.000,0.00,0 +E_scale_out_after_fix,1x0.50,4,3,487.9,487.5,495.9,248.0,243.4,5.63,28.41,38.24,0.0000,1.00,0.42,0.18,0.18,1.11/2,0.000,0.00,2 +E_scale_out_after_fix,1x0.50,16,3,527.3,526.0,530.6,264.7,265.9,24.38,65.49,82.53,0.0000,1.01,0.43,0.16,0.17,1.11/2,0.000,0.00,3 +E_scale_out_after_fix,1x0.50,64,3,525.9,525.7,549.9,259.5,269.3,116.35,179.63,207.68,0.0000,1.00,0.49,0.18,0.18,1.21/2,0.977,20.57,3 +E_scale_out_after_fix,2x0.50,4,3,598.9,593.0,634.0,304.7,298.5,5.76,11.88,20.15,0.0000,0.77,0.51,0.27,0.20,1.53/2,0.000,0.00,2 +E_scale_out_after_fix,2x0.50,16,3,593.3,561.6,637.1,296.5,296.8,23.48,57.36,81.29,0.0000,0.76,0.57,0.36,0.19,1.61/2,0.000,0.00,8 +E_scale_out_after_fix,2x0.50,64,3,561.0,531.3,595.4,278.7,282.3,101.03,244.15,335.72,0.0000,0.73,0.62,0.28,0.18,1.57/2,0.753,12.09,35 +E_scale_out_after_fix,4x0.50,4,3,550.3,548.2,553.0,279.0,273.3,6.21,14.15,22.45,0.0000,0.41,0.53,0.21,0.20,1.54/2,0.000,0.00,3 +E_scale_out_after_fix,4x0.50,16,3,538.7,535.8,545.1,266.4,272.3,24.95,64.57,96.19,0.0000,0.40,0.55,0.21,0.20,1.54/2,0.000,0.00,8 +E_scale_out_after_fix,4x0.50,64,3,513.3,465.3,527.5,260.6,252.7,78.12,392.00,829.03,0.0000,0.37,0.63,0.19,0.17,1.57/2,0.120,1.57,59 diff --git a/evidence/track1/summary.md b/evidence/track1/summary.md new file mode 100644 index 00000000..c1df517e --- /dev/null +++ b/evidence/track1/summary.md @@ -0,0 +1,64 @@ +# Трек 1 — сводка (сгенерировано scripts/track1_report.py) + +Медианы по повторам; util_* — доля CPU-лимита контейнера роли; pool_empty — доля acquire без свободного соединения. + +## A_fixed_total — Фиксированный суммарный бюджет API: 1.0 CPU / 768M + +**Гипотеза:** При фиксированном суммарном CPU рост числа реплик не увеличивает пиковый RPS (тот же бюджет) и немного ухудшает p95 из-за накладных расходов на процесс и пул соединений; выигрыш реплик — только отказоустойчивость. + +| config | пик RPS | c пика | c насыщения | узкое место (util) | CPU хоста | pool empty / wait ms | +|---|---|---|---|---|---|---| +| 1x1.00 | 460.3 | 64 | 16 | redis (1.00) — насыщена | 67% | 0.000 / 0.00 | +| 2x0.50 | 435.9 | 16 | 16 | redis (1.00) — насыщена | 74% | 0.000 / 0.00 | +| 4x0.25 | 474.5 | 64 | 64 | api (0.53) | 46% | 0.001 / 0.05 | + +## B_scale_out — Рост ресурсов: реплики по 0.5 CPU, БД 1.0 CPU, LB 0.5 CPU + +**Гипотеза:** Пиковый RPS растёт почти линейно, пока узкое место — CPU API; затем рост останавливается на общей зависимости (PostgreSQL, Redis или LB), чья утилизация CPU приближается к лимиту. + +| config | пик RPS | c пика | c насыщения | узкое место (util) | CPU хоста | pool empty / wait ms | +|---|---|---|---|---|---|---| +| 1x0.50 | 395.1 | 16 | 64 | api (0.99) — насыщена | 59% | 0.015 / 0.08 | +| 2x0.50 | 426.7 | 64 | 16 | redis (1.01) — насыщена | 75% | 0.000 / 0.00 | +| 4x0.50 | 419.0 | 64 | 16 | redis (1.00) — насыщена | 80% | 0.000 / 0.00 | + +## C_shared_resources — 4×0.5 CPU API, меняем ресурсы общих зависимостей + +**Гипотеза:** Если насыщение B вызвано общей зависимостью, увеличение её CPU поднимает пиковый RPS, а увеличение CPU других зависимостей — нет. + +| config | пик RPS | c пика | c насыщения | узкое место (util) | CPU хоста | pool empty / wait ms | +|---|---|---|---|---|---|---| +| pg1_lb0.5_redis0.5 | 331.2 | 16 | 64 | redis (1.00) — насыщена | 73% | 0.000 / 0.01 | +| pg2 | 383.4 | 64 | 64 | redis (0.96) — насыщена | 78% | 0.000 / 0.01 | +| lb1 | 410.9 | 64 | 64 | redis (0.97) — насыщена | 78% | 0.001 / 0.11 | +| redis1 | 404.6 | 64 | 64 | redis (0.50) | 81% | 0.000 / 0.01 | + +## D_improvement — Кандидаты улучшения на 4×0.5 CPU + +**Гипотеза:** Инвалидация кэша истории через SCAN (lab2) делает O(keyspace/100) запросов к Redis на каждую запись; ключ с версией чата (CACHE_INVALIDATION=version) делает 1 INCR и поднимает RPS записи при большом keyspace. Альтернативы: меньший пул на реплику, leastconn. + +| config | пик RPS | c пика | c насыщения | узкое место (util) | CPU хоста | pool empty / wait ms | +|---|---|---|---|---|---|---| +| baseline_scan | 374.5 | 32 | 64 | redis (0.99) — насыщена | 76% | 0.000 / 0.01 | +| cache_version | 817.6 | 64 | 64 | postgres (0.76) | 79% | 0.103 / 0.65 | +| pool_8 | 361.7 | 64 | 64 | redis (0.97) — насыщена | 73% | 0.012 / 0.39 | +| leastconn | 365.3 | 32 | 64 | redis (1.00) — насыщена | 70% | 0.000 / 0.00 | + +Сравнение с `baseline_scan` (уровни ≥ насыщения baseline): + +| кандидат | c | ΔRPS % | Δp95 % | повторы b/c | подтверждено | +|---|---|---|---|---|---| +| cache_version | 64 | 125.8 | -42.1 | 3/3 | да | +| pool_8 | 64 | -0.1 | -2.0 | 3/3 | нет | +| leastconn | 64 | -13.0 | 7.0 | 3/3 | нет | + +## E_scale_out_after_fix — Рост реплик после улучшения (CACHE_INVALIDATION=version), реплики по 0.5 CPU + +**Гипотеза:** После снятия упора в Redis рост реплик снова увеличивает RPS, пока не насытится следующая общая зависимость (ожидаем PostgreSQL) или CPU хоста. + +| config | пик RPS | c пика | c насыщения | узкое место (util) | CPU хоста | pool empty / wait ms | +|---|---|---|---|---|---|---| +| 1x0.50 | 527.3 | 16 | 16 | api (1.01) — насыщена | 55% | 0.000 / 0.00 | +| 2x0.50 | 598.9 | 4 | 16 | api (0.76) | 81% | 0.000 / 0.00 | +| 4x0.50 | 550.3 | 4 | 16 | postgres (0.55) | 77% | 0.000 / 0.00 | + diff --git a/experiments/track1.json b/experiments/track1.json index fc78565a..469d6d40 100644 --- a/experiments/track1.json +++ b/experiments/track1.json @@ -113,8 +113,14 @@ "API_REPLICAS": "4", "API_CPUS": "0.50", "REDIS_CPUS": "1.00" + }, + { + "label": "baseline_again", + "API_REPLICAS": "4", + "API_CPUS": "0.50" } - ] + ], + "note": "Базовая конфигурация измеряется в начале и в конце серии (baseline_again), чтобы видеть дрейф runner во времени." }, { "name": "D_improvement", -- 2.54.0 From b05562cbac28186efadbf3fff747b600dea73c69 Mon Sep 17 00:00:00 2001 From: CharaWein Date: Sat, 24 Oct 2026 03:02:44 +0300 Subject: [PATCH 8/8] =?UTF-8?q?lab3:=20=D1=80=D0=B5=D0=B7=D1=83=D0=BB?= =?UTF-8?q?=D1=8C=D1=82=D0=B0=D1=82=D1=8B=20=D0=BF=D0=BE=D1=81=D0=BB=D0=B5?= =?UTF-8?q?=20=D0=B8=D1=81=D0=BF=D1=80=D0=B0=D0=B2=D0=BB=D0=B5=D0=BD=D0=B8?= =?UTF-8?q?=D0=B9=20(=D0=BF=D1=80=D0=BE=D0=B3=D0=BE=D0=BD=D1=8B=203?= =?UTF-8?q?=E2=80=934),=20=D0=BE=D1=82=D1=87=D1=91=D1=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .github/workflows/lab3-stand.yml | 16 +- REPORT.md | 165 ++++++++++-------- evidence/track1/RUNS.txt | 1 + .../run3_C_superseded.jsonl | 24 +++ evidence/track1/raw.jsonl | 74 +++++--- evidence/track1/report.html | 2 +- evidence/track1/runner_C_shared_resources.txt | 4 +- evidence/track1/summary.csv | 18 +- evidence/track1/summary.md | 23 +-- scripts/track1.py | 9 + 10 files changed, 213 insertions(+), 123 deletions(-) create mode 100644 evidence/track1/legacy_before_review_fix/run3_C_superseded.jsonl diff --git a/.github/workflows/lab3-stand.yml b/.github/workflows/lab3-stand.yml index fbe552e0..08e077d3 100644 --- a/.github/workflows/lab3-stand.yml +++ b/.github/workflows/lab3-stand.yml @@ -92,13 +92,25 @@ jobs: strategy: fail-fast: false matrix: - # Прогон 3 (40039513675) измерил A–E на исправленном коде. Прогон 4 переснимает - # только C: 5 повторов и базовая конфигурация в начале и в конце серии. + # Полная процедура отчёта: A, B, D, E измерены прогоном 40039513675, + # C — прогоном 40041006083 (5 повторов, база в начале и в конце серии). include: + - series: A_fixed_total + configs: "" + levels: "4,16,64" + - series: B_scale_out + configs: "1x0.50,2x0.50,4x0.50" + levels: "4,16,64" - series: C_shared_resources configs: "" levels: "16,64" repeats: 5 + - series: D_improvement + configs: "" + levels: "32,64" + - series: E_scale_out_after_fix + configs: "" + levels: "4,16,64" steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v5 diff --git a/REPORT.md b/REPORT.md index f986d484..15b1e9c9 100644 --- a/REPORT.md +++ b/REPORT.md @@ -104,159 +104,174 @@ migrate (one-shot) ──► postgres — до старта api | Подтверждённая запись может отсутствовать в следующем чтении: при `ACL SETUSER default -incr` POST → 201, строка в PostgreSQL есть, GET возвращает прежние два сообщения | версия чата для ключа кэша хранилась в Redis и увеличивалась `INCR` после COMMIT; ошибка `INCR` игнорировалась (`message_cache.go:95`), ключ не менялся, чтение попадало в старый кэш | версия перенесена в `chats.version` и растёт в транзакции записи; ключ кэша строится из версии, прочитанной из PostgreSQL вместе с проверкой членства; `INCR`/`GET` версии в Redis удалены. Режим `CACHE_INVALIDATION=scan` теперь только воспроизводит стоимость SCAN для эксперимента и на корректность не влияет | [student-tests/regressions.py](student-tests/regressions.py) — ровно сценарий проверки (2 сообщения → кэш → `ACL -incr` → 3-е → чтение) и жёсткий вариант `-incr -del -unlink -scan`, шесть чтений через обе реплики; в режимах `version` и `scan`. Тот же тест против кода до исправления — FAIL (job `regression-before-fix`) | | Принимается пароль из одних пробелов (`" " × 12` → 201) | `validatePassword` проверял только длину | добавлена проверка `strings.TrimSpace(s) == ""` → 400; остальные обязательные строки (`display_name`, `title`, `text`) уже проверялись так же | unit-тест [validate_test.go](internal/service/validate_test.go) (пробелы, табуляции, NBSP, границы 12/128); HTTP-регрессия на 3 вариантах | -Изменение кэша меняет путь записи и чтения, поэтому **все серии трека 1 переизмерены на исправленном коде** (прогон 3). Данные прогонов 1–2 на коде до исправления сохранены в `evidence/track1/legacy_before_review_fix/` и в выводах не используются. +Изменение кэша меняет путь записи и чтения, поэтому **все серии трека 1 переизмерены на исправленном коде** (прогоны 3 и 4). Данные прогонов 1–2 на коде до исправления сохранены в `evidence/track1/legacy_before_review_fix/` и в выводах не используются. ## Где запускался стенд -На машине разработки Docker Desktop не запускается: в BIOS выключена аппаратная виртуализация (`VirtualizationFirmwareEnabled=False`, backend `hasNoVirtualization=true`). Поэтому все Docker-проверки выполнены на **GitHub-hosted runner** workflow [.github/workflows/lab3-stand.yml](.github/workflows/lab3-stand.yml) — тот же compose.yaml и те же скрипты, что и в инструкции выше: +На машине разработки Docker Desktop не запускается: в BIOS выключена аппаратная виртуализация (`VirtualizationFirmwareEnabled=False`, backend `hasNoVirtualization=true`). Поэтому все Docker-проверки выполнены на **GitHub-hosted runner** workflow [.github/workflows/lab3-stand.yml](.github/workflows/lab3-stand.yml) — тот же compose.yaml и те же скрипты, что и в инструкции выше. -| Прогон | Что | Ссылка | -| --- | --- | --- | -| 1 (commit fe4b4cf) | уровни 3–4 (найден баг rolling update), трек 1: серии A, B, D | https://github.com/CharaWein/2026_lab3/actions/runs/39970452644 | -| 2 (commit 0a37181) | уровни 3–4 после исправления — **доказательства ниже из этого прогона**; трек 1: серии C, E | https://github.com/CharaWein/2026_lab3/actions/runs/39972671424 | +| Прогон | Код | Что | Ссылка | +| --- | --- | --- | --- | +| 1 | fe4b4cf (до исправлений) | уровни 3–4 (найден баг rolling update), трек: A, B, D | https://github.com/CharaWein/2026_lab3/actions/runs/39970452644 | +| 2 | 0a37181 (до исправлений) | уровни 3–4, трек: C, E | https://github.com/CharaWein/2026_lab3/actions/runs/39972671424 | +| **3** | **bab82c7 (после исправлений)** | **уровни 3–4 и регрессии — все доказательства ниже**; регрессия против кода до исправления; трек: A, B, D, E | https://github.com/CharaWein/2026_lab3/actions/runs/40039513675 | +| **4** | eec3e43 (тот же код приложения) | трек: серия C повторно — 5 повторов, контрольная база в начале и в конце | https://github.com/CharaWein/2026_lab3/actions/runs/40041006083 | -Runner: 2 vCPU (AMD EPYC 7763 / 9V74, Intel Xeon 6973P — модель разная для разных job, записана в `evidence/track1/runner_*.txt`), 8 GB RAM, Docker 28.0.4, Compose v2.38.2 (`evidence/runner.txt`). Каждая серия трека 1 выполнялась целиком на одном runner, поэтому сравнения **внутри** серии корректны, а абсолютные RPS **между** сериями сравнивать нельзя. +Прогоны 1–2 относятся к коду до исправления по замечаниям проверки; их данные лежат в `evidence/track1/legacy_before_review_fix/` и в выводах не используются. -До Docker-прогона логика приложения дополнительно проверялась нативно (PostgreSQL 17, fakeredis, 2 процесса API за временным прокси) — `evidence/local_native_check.txt`, `evidence/idempotency_concurrent_native.json`. +Runner: 2 vCPU, 8 GB RAM, Docker 28.0.4, Compose v2.38.2 (`evidence/runner.txt`). Модель CPU у разных job разная (записана в `evidence/track1/runner_*.txt`), поэтому сравнения корректны только **внутри** серии. + +До Docker-прогона логика приложения проверялась и нативно (PostgreSQL 17, fakeredis, 2 процесса API за временным прокси) — `evidence/local_native_check.txt`. Сценарий с ACL Redis нативно не воспроизводится: fakeredis не применяет ACL к командам; он проверен только на настоящем Redis в CI. ## Доказательства критериев +Все файлы — из прогона 3. + ### Уровень 3 | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл | | --- | --- | --- | --- | | Стенд в compose.yaml, одна последовательность запуска | `scripts/init-secrets.sh` → `docker compose up -d --build --wait` | lb, 2×api, postgres, redis healthy; migrate отработал однократно | evidence/docker_ps.txt | | ≥2 реплики, одна точка входа, общая БД и сессии | `docker compose ps` | опубликованы только `127.0.0.1:8080` (lb) и `:8404` (stats); api — только `8080/tcp` внутри сети | evidence/docker_ps.txt | -| Запросы одной сессии обслуживают разные реплики | 20 запросов через LB; 40 запросов `/users/me` в failover-тесте | `259a4143c86a`×10, `904a0714df9b`×10; `observed_instances_before: 2` | evidence/instances.txt, evidence/failover_1.txt | +| Запросы одной сессии обслуживают разные реплики | 20 запросов через LB; 40 запросов `/users/me` в failover-тесте | `932349e41b13`×10, `9c02b883d167`×10; `observed_instances_before: 2` | evidence/instances.txt, evidence/failover_1.txt | | Публичный smoke | `make test` | `PASS: lab3 public API scenario` | evidence/smoke.txt | -| Отказ одной реплики ≤10 s | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`, 2 прогона, между ними `restore.sh` | PASS ×2; 143 и 144 успешных записи, **0** ошибок, первая запись после hook за 3.39 s и 3.36 s; остановленный контейнер `Exited (0)` | evidence/failover_1.txt, failover_2.txt | +| Отказ одной реплики ≤10 s | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`, 2 прогона, между ними `restore.sh` | PASS ×2; по 144 успешных записи, **0** ошибок, первая запись после hook за 3.37 s и 3.28 s; остановленный контейнер `Exited (0)` | evidence/failover_1.txt, failover_2.txt | | Повтор POST с тем же ключом без дублей (конкурентно, через разные реплики) | `make test-idempotency`: 10 раундов × 16 параллельных запросов | 160/160 → 201 с одним Message, 1 сообщение на ключ, 2 реплики, `duplicates_found: 0`; другой body — 409; ключ изолирован по чату и пользователю | evidence/idempotency_concurrent.json | +| Подтверждённая запись видна следующему чтению, даже если Redis отказывает в командах | `student-tests/regressions.py` в режимах `version` и `scan` | PASS: `ACL -incr` и `ACL -incr -del -unlink -scan` — каждое из 6 чтений через обе реплики видит новое сообщение | evidence/regressions.txt | +| Тот же тест против кода до исправления | job `regression-before-fix` (commit 7cd5506) | **FAIL**: `read 0 after 201 misses confirmed message (denied: ['incr'])`; пароль из пробелов → `received 201` | evidence/regressions_before_fix.txt | +| Пароль из одних пробелов → 400 | `regressions.py`, `go test ./internal/service/` | PASS: пробелы, табуляции, NBSP → 400 | evidence/regressions.txt | | Persistence с прежним токеном | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS; перезапущены postgres, redis, api, lb (uptime до/после в файле), volumes сохранены | evidence/persistence.txt | -Публичный failover-тест останавливает реплику, обслужившую первый запрос; в обоих прогонах это была `api-2`. Остановка **каждой** реплики по очереди показана в серии уровня 4 ниже. +Публичный failover-тест останавливает реплику, обслужившую первый запрос; в обоих прогонах это была `api-1`. Остановка **каждой** реплики по очереди показана в серии уровня 4. ### Уровень 4 | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл | | --- | --- | --- | --- | -| Health/readiness, timeouts, SIGTERM согласованы; LB исключает backend | drain 3 s + HAProxy check inter 1 s × fall 2; `docker stop` | после SIGTERM реплика отвечала ещё 0.75 s / 1.46 s, затем исчезла из ответов LB; **0 ошибок**. Период проверки 1 s, максимальное время обнаружения ≈2 s | evidence/failover_series.json | +| Health/readiness, timeouts, SIGTERM согласованы; LB исключает backend | drain 3 s + HAProxy check inter 1 s × fall 2; `docker stop` | после SIGTERM реплика отвечала ещё 1.35 s / 1.34 s, затем исчезла из ответов LB; **0 ошибок**. Период проверки 1 s, максимальное время обнаружения ≈2 s | evidence/failover_series.json | | Поочерёдная остановка каждой реплики: RPS, ошибки, восстановление | `make test-failover-series` (4 потока, POST+GET) | таблица ниже | evidence/failover_series.json | | Параллельная идемпотентность | см. уровень 3 | 0 дублей | evidence/idempotency_concurrent.json | | CPU/RAM-лимиты, api без портов, нет container_name | compose.yaml, `docker stats` | api 0.5 CPU/256M, lb 0.5/128M, postgres 1.0/512M, redis 0.5/256M | evidence/docker_stats.txt, evidence/docker_ps.txt | -| Rolling update под нагрузкой | `scripts/rolling-update.sh` во время 90 s `tests/load.py` | api-1, api-2 → api-3, api-4 за 27 s; **33 461 запрос, 0 ошибок**, 371 RPS, p99 27.7 ms | evidence/rolling_update.txt, rolling_update_load.json | -| Миграции однократно и совместимы | сервис `migrate` + `docker compose run --rm migrate` перед заменой | `no change`; 0002 только добавляет таблицу (expand) | evidence/rolling_update.txt | +| Rolling update под нагрузкой | `scripts/rolling-update.sh` во время 90 s `tests/load.py` | api-1, api-2 → api-3, api-4 за 27 s; **45 591 запрос, 0 ошибок**, 506 RPS, p99 19.9 ms | evidence/rolling_update.txt, rolling_update_load.json | +| Миграции однократно и совместимы | сервис `migrate` + `docker compose run --rm migrate` перед заменой | `no change`; 0002 и 0003 только добавляют таблицу/столбец с DEFAULT (expand) | evidence/rolling_update.txt | ## Эксперименты и отказы | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| `docker stop` реплики `259a4143c86a` под нагрузкой | 0–единицы ошибок благодаря drain | 347.8 RPS до → 361.9 RPS в окне 15 s, **0 ошибок**; stop занял 3.57 s | ошибок нет; после `docker start` healthy и в LB через 6.25 s; потерь нет | -| `docker stop` реплики `904a0714df9b` | то же | 345.8 → 357.9 RPS, **0 ошибок**; stop 4.12 s | ошибок нет; возврат через 6.81 s; потерь нет | -| Итог серии | нет потерь и дублей | 9 388 подтверждённых записей, 9 389 в истории (+1 — сообщение до серии), дублей 0, потерь 0 | — | -| Rolling update | 0 ошибок | 0 из 33 461 | замена 27 s | +| `docker stop` реплики `4f142660cef9` под нагрузкой | 0–единицы ошибок благодаря drain | 463.0 RPS до → 493.4 RPS в окне 15 s, **0 ошибок**; stop занял 3.66 s | ошибок нет; после `docker start` healthy и в LB через 5.93 s; потерь нет | +| `docker stop` реплики `29c5ff8f740e` | то же | 480.2 → 484.8 RPS, **0 ошибок**; stop 3.98 s | ошибок нет; возврат через 6.38 s; потерь нет | +| Итог серии | нет потерь и дублей | все 12 741 подтверждённых записей на месте и не изменены, дублей 0 (в истории 12 744 сообщения: несколько записей, ответ на которые клиент не учёл при завершении нагрузки; повтор с тем же ключом дублей не создаёт) | — | +| Rolling update | 0 ошибок | 0 из 45 591 | замена 27 s | | Restart всего стенда | данные и сессия сохранены | PASS с прежним токеном | ≈12 s до healthy | -| Прогон 1: rolling update | 0 ошибок | **найден баг**: `wait_healthy` перезаписывал `cid` внешнего цикла, удалялась новая реплика; сборка (72 s) не попадала в окно нагрузки | исправлено в 0a37181, проверено прогоном 2 | +| Redis отказывает в `INCR`/`DEL`/`SCAN` | запись видна сразу | видна в каждом из 6 чтений | — | +| Прогон 1: rolling update | 0 ошибок | **найден баг**: `wait_healthy` перезаписывал `cid` внешнего цикла, удалялась новая реплика; сборка (72 s) не попадала в окно нагрузки | исправлено в 0a37181 | ## Трек 5.1: цена масштабирования ### Вопрос и гипотезы -Помогает ли добавление API-реплик, где точка насыщения и почему рост реплик перестаёт помогать? Гипотезы A–D записаны **до** измерений в [experiments/track1.json](experiments/track1.json). Серия E и её гипотеза добавлены **после** прогона 1, чтобы проверить, куда смещается насыщение после улучшения. +Помогает ли добавление API-реплик, где точка насыщения и почему рост реплик перестаёт помогать? Гипотезы A–D записаны **до** первых измерений в [experiments/track1.json](experiments/track1.json). Серия E и её гипотеза добавлены после прогона 1, чтобы проверить, куда смещается насыщение после улучшения. В серию C после прогона 3 добавлена контрольная повторная база. | Серия | Что меняем | Гипотеза | | --- | --- | --- | | A_fixed_total | 1×1.0 / 2×0.5 / 4×0.25 CPU API (сумма 1.0 CPU) | RPS не растёт, p95 чуть хуже; реплики дают только отказоустойчивость | | B_scale_out | 1/2/4 реплики по 0.5 CPU | рост, пока узкое место — CPU API, затем упор в общую зависимость | | C_shared_resources | 4×0.5 API; PG 1→2, LB 0.5→1, Redis 0.5→1 CPU | RPS поднимает только ресурс насыщенной зависимости | -| D_improvement | 4×0.5 API: baseline и 3 кандидата | SCAN-инвалидация кэша (наследие lab2) — O(keyspace/100) запросов к Redis на запись; `CACHE_INVALIDATION=version` (1 INCR) поднимет RPS | +| D_improvement | 4×0.5 API: baseline и 3 кандидата | SCAN-инвалидация кэша (наследие lab2) — O(keyspace/100) запросов к Redis на запись; без неё (`CACHE_INVALIDATION=version`) RPS вырастет | | E_scale_out_after_fix | 1/2/4 × 0.5 CPU с `version` | после снятия упора в Redis реплики снова помогают до следующей общей зависимости | ### Методика -- Отдельный compose-проект `mtusi2026lab3-bench` (порт 18080). Конфигурация задаётся только переменными окружения (`API_REPLICAS`, `API_CPUS`, `API_MEMORY`, `PG_CPUS`, `LB_CPUS`, `REDIS_CPUS`, `DB_POOL_MAX`, `CACHE_INVALIDATION`, `LB_BALANCE`), образ один. -- База: PostgreSQL 1.0 CPU / 512M, `max_connections=200`; Redis 0.5 CPU; LB 0.5 CPU; пул 20 на реплику; `CACHE_INVALIDATION=scan` (поведение lab2); фоновый keyspace Redis — 10 000 ключей `pad:*` (≈ активные сессии). +- Отдельный compose-проект `mtusi2026lab3-bench` (порт 18080). Конфигурация — только переменные окружения (`API_REPLICAS`, `API_CPUS`, `API_MEMORY`, `PG_CPUS`, `LB_CPUS`, `REDIS_CPUS`, `DB_POOL_MAX`, `CACHE_INVALIDATION`, `LB_BALANCE`), образ один. +- База: PostgreSQL 1.0 CPU / 512M, `max_connections=200`; Redis 0.5 CPU; LB 0.5 CPU; пул 20 на реплику; `CACHE_INVALIDATION=scan` (на каждую запись SCAN+DEL ключей чата, как в lab2; корректность от этого режима не зависит — версия ключа в PostgreSQL); фоновый keyspace Redis — 10 000 ключей `pad:*` (≈ активные сессии). - Нагрузка [cmd/bench](cmd/bench/main.go): closed-loop, 50% POST сообщения (уникальный Idempotency-Key) / 50% GET истории `limit=50`, 8 чатов × 2 участника, без повторов, таймаут 5 s. -- **Фактический объём** (сокращён из-за времени работы runner): уровни параллелизма 4/16/64 (C: 16/64, D: 32/64), прогрев 3 s, измерение 15 s, **3 повтора** каждой точки — всего 129 прогонов. Полная методика (6 уровней, 30 s, 3–5 повторов) запускается `make track1`. +- **Фактический объём** (сокращён из-за времени работы runner): уровни параллелизма 4/16/64 (C: 16/64, D: 32/64), прогрев 3 s, измерение 15 s; 3 повтора каждой точки (C: 5). Полная методика (6 уровней, 30 s) запускается `make track1`. - Во время прогона раз в 1–2 s снимаются `docker stats` (CPU нормирован на лимит роли) и `pg_stat_activity`; до и после — счётчики пула pgx (внутренний порт 9090, не публикуется). -- Правила анализа в [scripts/track1_report.py](scripts/track1_report.py): медиана повторов; насыщение — первый уровень с ростом RPS < 10%; узкое место — роль с максимальной утилизацией лимита (≥ 0.85 — насыщена); улучшение подтверждено, если min(RPS кандидата) > max(RPS baseline) по всем повторам, p95 не хуже, ошибок не больше. Метрика «CPU хоста» (сумма util × лимит × число контейнеров по ролям) добавлена после прогона 2. -- Сырые данные: [evidence/track1/raw.jsonl](evidence/track1/raw.jsonl) (одна строка — один прогон, без токенов). Сводка: [summary.md](evidence/track1/summary.md), [summary.csv](evidence/track1/summary.csv). Графики RPS и p95 по каждой серии: [report.html](evidence/track1/report.html). +- Правила анализа в [scripts/track1_report.py](scripts/track1_report.py): медиана повторов; насыщение — первый уровень с ростом RPS < 10%; узкое место — роль с максимальной утилизацией лимита (≥ 0.85 — насыщена); улучшение подтверждено, если min(RPS кандидата) > max(RPS baseline) по всем повторам, p95 не хуже, ошибок не больше. Метрика «CPU хоста» (сумма util × лимит × число контейнеров) добавлена после прогона 2. +- Сырые данные: [evidence/track1/raw.jsonl](evidence/track1/raw.jsonl) (одна строка — один прогон, без токенов). Сводка: [summary.md](evidence/track1/summary.md), [summary.csv](evidence/track1/summary.csv). Графики RPS и p95 по сериям: [report.html](evidence/track1/report.html). -Ошибок (`error_ratio`) не было ни в одном из 129 прогонов. +Ошибок (`error_ratio`) не было ни в одном прогоне. -### Результаты (медианы 3 повторов) +### Результаты (медианы повторов, исправленный код) -**A — фиксированный бюджет API 1.0 CPU** +**A — фиксированный бюджет API 1.0 CPU** (прогон 3) -| config | RPS c=4 / 16 / 64 | p95 c=16, ms | util Redis | util API | +| config | RPS c=4 / 16 / 64 | p95 c=16, ms | util Redis c=16 | util API c=16 | | --- | --- | --- | --- | --- | -| 1×1.00 | 224 / **258** / 247 | 142 | 1.00 | 0.67 | -| 2×0.50 | 198 / 234 / **252** | 166 | 0.99 | 0.79 | -| 4×0.25 | 182 / 215 / **231** | 183 | 0.88 | 0.86 | +| 1×1.00 | 400 / 431 / 460 | 87.6 | 1.00 | 0.59 | +| 2×0.50 | 414 / 436 / 432 | 93.8 | 1.00 | 0.72 | +| 4×0.25 | 366 / 431 / 475 | 93.2 | 0.93 | 0.86 | -Гипотеза подтверждена частично: RPS не растёт (258 → 252 → 231), p95 растёт (142 → 166 → 183 ms при c=16). Но причина не в API: Redis упирается в свой лимит уже при одной реплике. +RPS от числа реплик не зависит систематически: различия между конфигурациями до 13%, сопоставимы с разбросом повторов (4–14%), и знак меняется от уровня к уровню. p95 при c=16 вырос на 7% (88 → 94 ms) — в пределах разброса, поэтому эту часть гипотезы считаю **не подтверждённой**. Причина «потолка» не в API, а в Redis: он насыщен уже при одной реплике. -**B — рост числа реплик по 0.5 CPU** +**B — рост числа реплик по 0.5 CPU** (прогон 3) | config | пик RPS | × к 1 реплике | узкое место на пике | | --- | --- | --- | --- | -| 1×0.50 | 295 | 1.00 | **API 1.00** | -| 2×0.50 | 372 | 1.26 | **Redis 1.00** (API 0.77) | -| 4×0.50 | 357 | 1.21 | **Redis 0.97** (API 0.43) | +| 1×0.50 | 395 | 1.00 | **API 1.00** | +| 2×0.50 | 427 | 1.08 | **Redis 1.01** (API 0.67) | +| 4×0.50 | 419 | 1.06 | **Redis 1.00** (API 0.37) | -**Saturation point — 2 реплики.** С одной на две реплики RPS растёт на 26% (снимается упор в CPU API), дальше роста нет: Redis (0.5 CPU) загружен на 100% лимита, а CPU API простаивает (0.43). Рост реплик перестаёт помогать, потому что каждая запись делает SCAN по keyspace Redis, и общий Redis насыщается раньше API. +**Saturation point — 2 реплики.** Одна реплика упирается в собственный CPU; со второй упор переходит в Redis (0.5 CPU, 100% лимита), и дальше рост реплик не помогает: CPU API простаивает (0.37), а каждая запись в режиме `scan` делает SCAN по keyspace общего Redis. Смещение узкого места (API 1.00 → Redis 1.00) видно по утилизации и воспроизводится в прогоне 1 на другой машине. Величину прироста от второй реплики (+8% здесь, +26% в прогоне 1) нужно считать неточной: конфигурация 1×0.50 шла первой в серии, а серия C показала, что первая конфигурация может быть занижена на 10–16%. -**C — проверка причины (4×0.5 API)** +**C — проверка причины (4×0.5 API)** (прогон 4: 5 повторов, базовая конфигурация в начале и в конце серии) -| config | RPS c=16 / 64 | util Redis | вывод | -| --- | --- | --- | --- | -| базовая | 455 / 494 | 1.00 | — | -| PG 2 CPU | 463 / 501 | 1.00 | +1%, в пределах шума | -| LB 1 CPU | 453 / 486 | 0.99 | 0% | -| **Redis 1 CPU** | **492 / 538** | **0.55** | **+8–9%**, Redis перестаёт быть насыщенным | - -RPS поднимает только ресурс Redis — гипотеза C подтверждена. Прирост ограничен (+9%), потому что дальше сказывается CPU хоста (см. E). - -**D — подтверждённое улучшение (4×0.5 API)** - -| кандидат | RPS c=32 / 64 | p95 c=32, ms | util Redis | подтверждено | +| config | RPS c=16 / 64 (медиана) | min–max c=64 | util Redis | Δ к базе в конце, c=16 / 64 | | --- | --- | --- | --- | --- | -| baseline (`scan`) | 214 / 222 | 346 | 1.00 | — | -| **`CACHE_INVALIDATION=version`** | **544 / 549** | **130** | **0.24** | **да: +148% RPS, −57% p95 при c=64; все 3 повтора лучше всех 3 повторов baseline** | -| `DB_POOL_MAX=8` | 208 / 234 | 347 | 1.00 | нет (+5%, внутри разброса) | -| `LB_BALANCE=leastconn` | 232 / 224 | 321 | 0.99 | нет (+1%) | +| база (в начале серии) | 357 / 411 | 369–424 | 0.99 | −16% / −10% | +| PG 2 CPU | 428 / 460 | 442–473 | 0.97 | 0% / +0.5% | +| LB 1 CPU | 425 / 443 | 420–454 | 0.97 | −0.5% / −3% | +| **Redis 1 CPU** | **442 / 478** | **467–479** | **0.50** | **+3.5% / +4.5%** | +| база (в конце серии) | 427 / 458 | 451–476 | 0.97 | — | -Изменение кода: ключ кэша истории включает версию чата, запись делает один `INCR` вместо `SCAN`+`DEL` ([message_cache.go](internal/repository/redis/message_cache.go)). Корректность сохранена: к моменту ответа на запись версия уже увеличена, и следующее чтение идёт по новому ключу (smoke и идемпотентность проходят в обоих режимах). Режим `version` — значение по умолчанию в compose.yaml. +Два результата: -**E — рост реплик после улучшения** +1. **Методический:** одна и та же базовая конфигурация в начале серии на 10–16% медленнее, чем в конце (первая конфигурация на «холодной» машине). В прогоне 3 база C стояла только в начале, поэтому все три изменения ресурсов выглядели как прирост — тот прогон признан смещённым и заменён (`evidence/track1/legacy_before_review_fix/run3_C_superseded.jsonl`). В [scripts/track1.py](scripts/track1.py) добавлен неучитываемый разогрев перед первой конфигурацией серии (`--series-warmup`, 30 s); в прогонах этого отчёта его ещё не было. +2. **По существу:** относительно базы в конце серии ресурсы PostgreSQL и LB не дают ничего, ресурс Redis — единственный, кто снимает насыщение (утилизация 0.97 → 0.50 от удвоенного лимита) и даёт прирост, но лишь **+4%** (диапазоны повторов почти не пересекаются: 467–479 против 451–476). Гипотеза C подтверждается в слабой форме: Redis — первое узкое место, но за ним сразу CPU двухъядерного узла (контейнеры занимают ≈80% от 2 vCPU, плюс генератор нагрузки). Удвоение квоты Redis на переподписанном узле не добавляет реальных ядер, а вот **уменьшение работы** Redis (серия D) освобождает общий CPU и даёт +126%. На старом коде (прогон 2) картина та же: Redis ×2 — +9%, PG и LB — 0%. -| config | пик RPS | p95 c=64, ms | util API / PG / Redis | CPU контейнеров, ядер из 2 | +**D — подтверждённое улучшение (4×0.5 API)** (прогон 3) + +| кандидат | RPS c=32 / 64 | p95 c=32 / 64, ms | util Redis / PG | подтверждено | | --- | --- | --- | --- | --- | -| 1×0.50 | 560 | 176 | **1.00** / 0.40 / 0.23 | 1.09 | -| 2×0.50 | **618** | 207 | 0.78 / 0.55 / 0.24 | 1.55 | -| 4×0.50 | 599 | 244 | 0.42 / 0.51 / 0.27 | 1.56 | +| baseline (`scan`) | 375 / 362 | 211 / 421 | 0.99 / 0.22 | — | +| **`CACHE_INVALIDATION=version`** | **722 / 818** | **132 / 244** | **0.21 / 0.76** | **да: +126% RPS и −42% p95 при c=64; все 3 повтора лучше всех 3 повторов baseline** | +| `DB_POOL_MAX=8` | 362 / 362 | 214 / 413 | 0.97 / 0.21 | нет (0%) | +| `LB_BALANCE=leastconn` | 365 / 315 | 205 / 451 | 1.00 / 0.20 | нет (−13% при c=64) | -После улучшения одна реплика даёт почти вдвое больше, чем в B (на другом процессоре runner, поэтому сравнение приблизительное). Но вторая реплика добавляет лишь +10%, а четвёртая — ничего: RPS 618 → 599, p95 растёт (207 → 244 ms), активных соединений PostgreSQL в пике больше (29 → 45). Ни один контейнер не упирается в лимит; вместе они занимают ≈1.56 из 2 vCPU runner, остальное делят генератор нагрузки, dockerd и сетевой стек. Интерпретация: **следующий потолок — CPU узла**, и реплики на одном двухъядерном узле не добавляют вычислительной мощности. Это интерпретация, а не прямое измерение: CPU генератора нагрузки не измерялся. +Улучшение — отказ от SCAN+DEL при записи: свежесть кэша гарантирует версия чата в PostgreSQL, поэтому удалять старые ключи не нужно, они истекают по TTL ([message_cache.go](internal/repository/redis/message_cache.go)). Режим `version` — значение по умолчанию в compose.yaml. После улучшения узкое место смещается в PostgreSQL: утилизация 0.76–0.82, до 58 активных соединений, у пула появляются ожидания (10% acquire без свободного соединения, 0.65 ms в среднем). В прогоне 1 на старом коде то же улучшение дало +148% — эффект воспроизводится. + +**E — рост реплик после улучшения** (прогон 3) + +| config | пик RPS | p95 c=64, ms | util API / PG c=64 | активных соединений PG c=64 | CPU контейнеров, ядер из 2 | +| --- | --- | --- | --- | --- | --- | +| 1×0.50 | 527 | 180 | **1.00** / 0.49 | 3 | 1.21 | +| 2×0.50 | **599** | 244 | 0.73 / 0.62 | 35 | 1.57 | +| 4×0.50 | 550 | 392 | 0.37 / 0.63 | 59 | 1.57 | + +После снятия упора в Redis вторая реплика даёт +14% (с той же оговоркой о первой конфигурации серии), а четвёртая уже ухудшает результат: −8% RPS и p95 в 1.6 раза выше (244 → 392 ms) — это сравнение второй и третьей конфигураций, и смещение «холодного старта» его не затрагивает. Ни один контейнер не упирается в свой лимит; вместе они занимают ≈1.57 из 2 vCPU runner, остальное делят генератор нагрузки, dockerd и сетевой стек. Растёт число одновременно активных соединений PostgreSQL (3 → 35 → 59). Интерпретация (не прямое измерение): (1) потолок CPU двухъядерного узла — реплики на одном узле не добавляют вычислительной мощности; (2) конкуренция в PostgreSQL — каждая запись обновляет строку `chats.version`, а при 8 чатах и 64 клиентах записи в один чат ждут блокировку строки; чем больше реплик и соединений, тем больше ожидающих. Ожидания блокировок (`pg_locks`, `wait_event`) не измерялись — это следующий шаг. ### Выводы трека -1. При фиксированном CPU реплики не увеличивают пропускную способность и ухудшают p95 (A). -2. При росте ресурсов насыщение наступает на 2 репликах из-за общей зависимости — Redis (B); это подтверждено изменением только её ресурса (C). -3. Подтверждённое улучшение — инвалидация кэша по версии вместо SCAN: ×2.5 RPS и −57% p95 на той же конфигурации (D). -4. После улучшения точка насыщения смещается к CPU узла (E): дальше масштабировать нужно узлами, а не репликами на одном узле. +1. При фиксированном CPU реплики не увеличивают пропускную способность (A); заметного ухудшения p95 в пределах разброса не обнаружено. +2. При росте ресурсов насыщение наступает на 2 репликах из-за общей зависимости — Redis (B, воспроизводится в прогонах 1 и 3). Серия C с контрольной базой показывает, что за Redis сразу следует CPU узла: удвоение квоты Redis даёт лишь +4%, ресурсы PostgreSQL и LB — 0%. +3. Подтверждённое улучшение — запись без SCAN-инвалидации при версии кэша из PostgreSQL: +126% RPS и −42% p95 на той же конфигурации (D, воспроизводится в прогонах 1 и 3). +4. После улучшения насыщение смещается к PostgreSQL и CPU узла (E): больше двух реплик на одном двухъядерном узле только увеличивают задержку. Дальнейшее масштабирование — отдельные узлы и снижение конкуренции за строку чата (например, версия в отдельной таблице или счётчик без блокировки строки), а не реплики. ### Ограничения трека - Runner 2 vCPU: сумма лимитов в конфигурациях 4×0.5 (3.5–4 CPU) больше, чем у хоста; лимиты Docker — квоты CFS. Поэтому «утилизация лимита < 1» не значит, что CPU свободен. -- Сокращённая методика: 3 уровня параллелизма, 15 s, 3 повтора; точка насыщения определена с шагом ×4 по параллелизму. -- Разные job — разные модели CPU; абсолютные RPS сравнимы только внутри серии (база C даёт 494 RPS против 357 у B 4×0.5 при одинаковой конфигурации — другой процессор). -- Аномалия: в 2 из 3 повторов `A 4×0.25 c=64` сборщик `docker stats` почти не получил замеров (утилизация занижена, RPS нормальный). Медиана утилизации в этой точке недостоверна; вывод по A сделан по c=4/16. +- Сокращённая методика: 3 уровня параллелизма, 15 s, 3–5 повторов; точка насыщения определена с шагом ×4 по параллелизму. +- Разные job — разные модели CPU; абсолютные RPS сравнимы только внутри серии. +- Первая конфигурация серии занижена на 10–16% («холодный старт», измерено в C). Это затрагивает величину прироста 1 → 2 реплики в B и E, но не смещение узкого места по утилизации и не результат D (+126% намного больше смещения, к тому же baseline D в прогоне 1 тоже уступил кандидату в 2.5 раза). Разогрев серии добавлен в инструмент, но в этих прогонах не применялся. +- Аномалия: в повторах `A 4×0.25 c=64` (и в прогоне 1, и в прогоне 3) сборщик `docker stats` получил мало замеров — утилизация в этой точке занижена при нормальном RPS. Выводы по A сделаны по c=4/16. +- CPU генератора нагрузки и ожидания блокировок PostgreSQL не измерялись; выводы о CPU узла и блокировках в E — интерпретация. - Только closed-loop; задержки — успешных запросов (ошибок не было). -- История растёт во время серии; GET читает первые 50 сообщений по индексу, поэтому стоимость чтения от объёма почти не зависит. ## Ограничения и следующие шаги -- Выдерживается отказ одной API-реплики (процесс/контейнер). Не выдерживается отказ LB, PostgreSQL, Redis или хоста — это SPOF (один узел, БД не реплицирована). -- Миграции совместимы с работающей версией только при подходе expand→contract; `0002` только добавляет таблицу. Деструктивные миграции так применять нельзя. -- Ключи идемпотентности хранятся в PostgreSQL рядом с сообщением — атомарность без распределённых транзакций ценой одной лишней записи на POST. +- Выдерживается отказ одной API-реплики (процесс/контейнер) и отказ Redis в отдельных командах кэша. Не выдерживается отказ LB, PostgreSQL, Redis целиком (нужен для сессий) или хоста — это SPOF (один узел, БД не реплицирована). +- Миграции совместимы с работающей версией только при подходе expand→contract; 0002 и 0003 только добавляют объекты. Деструктивные миграции так применять нельзя. +- Ключи идемпотентности и версия чата хранятся в PostgreSQL в транзакции записи — атомарность без распределённых транзакций ценой блокировки строки чата на время записи (см. серию E). - Ошибки, сгенерированные самим HAProxy (502/503/504), не содержат X-Instance-Id — это допускается контрактом. -- Docker-стенд на машине разработки не запускается (нет VT-x), доказательства получены на GitHub runner. На любой машине с Docker всё воспроизводится теми же командами. +- Docker-стенд на машине разработки не запускается (нет VT-x); доказательства получены на GitHub runner. На любой машине с Docker всё воспроизводится теми же командами. diff --git a/evidence/track1/RUNS.txt b/evidence/track1/RUNS.txt index a7d6e236..02cf632d 100644 --- a/evidence/track1/RUNS.txt +++ b/evidence/track1/RUNS.txt @@ -1 +1,2 @@ run3=https://github.com/CharaWein/2026_lab3/actions/runs/40039513675 commit=bab82c7 series=A,B,C,D,E (after review fix); levels 3-4 + regression-before-fix from the same run +run4=https://github.com/CharaWein/2026_lab3/actions/runs/40041006083 commit=eec3e43 series=C_shared_resources (5 repeats, baseline at start and end); run3 C superseded -> legacy_before_review_fix/run3_C_superseded.jsonl diff --git a/evidence/track1/legacy_before_review_fix/run3_C_superseded.jsonl b/evidence/track1/legacy_before_review_fix/run3_C_superseded.jsonl new file mode 100644 index 00000000..f98d5211 --- /dev/null +++ b/evidence/track1/legacy_before_review_fix/run3_C_superseded.jsonl @@ -0,0 +1,24 @@ +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1243, "2ef3d3401cb2": 1242, "533549b432a8": 1242, "8f4056cc3ff4": 1241}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 206.674, "p50": 22.165, "p95": 118.795, "p99": 150.913}, "mode": "closed", "ok": 4968, "ok_read_rps": 168.6, "ok_rps": 331.2, "ok_write_rps": 162.6, "rate": 0, "read_ms": {"max": 44.795, "p50": 5.456, "p95": 16.323, "p99": 25.96}, "requests": 4968, "timestamp": "2026-10-23T23:26:29Z", "warmup_s": 3, "write_ms": {"max": 206.674, "p50": 89.332, "p95": 132.244, "p99": 171.409}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.7, "cpu_pct_max_per_container": 21.1, "cpu_utilization_of_limit": 0.354, "mem_max_mib": 138.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.094, "mem_max_mib": 8.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.6, "cpu_pct_max_per_container": 22.5, "cpu_utilization_of_limit": 0.206, "mem_max_mib": 80.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.4, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.008, "mem_max_mib": 11.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 21}}, "pool": {"acquires": 17106, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.034, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1306, "2ef3d3401cb2": 1308, "533549b432a8": 1310, "8f4056cc3ff4": 1310}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 242.967, "p50": 36.927, "p95": 116.484, "p99": 143.198}, "mode": "closed", "ok": 5234, "ok_read_rps": 172.46666666666667, "ok_rps": 348.93333333333334, "ok_write_rps": 176.46666666666667, "rate": 0, "read_ms": {"max": 61.356, "p50": 5.422, "p95": 16.465, "p99": 25.069}, "requests": 5234, "timestamp": "2026-10-23T23:26:49Z", "warmup_s": 3, "write_ms": {"max": 242.967, "p50": 78.066, "p95": 126.752, "p99": 157.955}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.2, "cpu_pct_max_per_container": 23.7, "cpu_utilization_of_limit": 0.384, "mem_max_mib": 255.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 8.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.4, "cpu_pct_max_per_container": 23.6, "cpu_utilization_of_limit": 0.214, "mem_max_mib": 84.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.991, "mem_max_mib": 11.2}, "postgres_connections": {"active_max": 16, "active_mean": 2.3, "total_max": 22}}, "pool": {"acquires": 18183, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1104, "2ef3d3401cb2": 1100, "533549b432a8": 1099, "8f4056cc3ff4": 1101}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 224.267, "p50": 38.097, "p95": 134.642, "p99": 171.335}, "mode": "closed", "ok": 4404, "ok_read_rps": 145.73333333333332, "ok_rps": 293.6, "ok_write_rps": 147.86666666666667, "rate": 0, "read_ms": {"max": 41.9, "p50": 6.18, "p95": 19.781, "p99": 29.134}, "requests": 4404, "timestamp": "2026-10-23T23:27:10Z", "warmup_s": 3, "write_ms": {"max": 224.267, "p50": 97.02, "p95": 152.977, "p99": 184.371}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 16.9, "cpu_pct_max_per_container": 19.3, "cpu_utilization_of_limit": 0.338, "mem_max_mib": 251.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.0, "cpu_pct_max_per_container": 22.3, "cpu_utilization_of_limit": 0.2, "mem_max_mib": 88.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.7, "cpu_pct_max_per_container": 51.8, "cpu_utilization_of_limit": 1.014, "mem_max_mib": 11.4}, "postgres_connections": {"active_max": 3, "active_mean": 0.4, "total_max": 22}}, "pool": {"acquires": 15996, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1217, "2ef3d3401cb2": 1206, "533549b432a8": 1209, "8f4056cc3ff4": 1208}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 672.9, "p50": 262.164, "p95": 460.581, "p99": 550.176}, "mode": "closed", "ok": 4840, "ok_read_rps": 158.2, "ok_rps": 322.6666666666667, "ok_write_rps": 164.46666666666667, "rate": 0, "read_ms": {"max": 215.547, "p50": 16.362, "p95": 43.832, "p99": 86.781}, "requests": 4840, "timestamp": "2026-10-23T23:27:31Z", "warmup_s": 3, "write_ms": {"max": 672.9, "p50": 358.675, "p95": 500.928, "p99": 564.241}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.6, "cpu_pct_max_per_container": 20.8, "cpu_utilization_of_limit": 0.352, "mem_max_mib": 247.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.095, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.6, "cpu_pct_max_per_container": 23.2, "cpu_utilization_of_limit": 0.216, "mem_max_mib": 216.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.3, "cpu_pct_max_per_container": 52.1, "cpu_utilization_of_limit": 1.007, "mem_max_mib": 18.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.2, "total_max": 76}}, "pool": {"acquires": 16507, "empty_acquire_ratio": 0.0041, "avg_acquire_wait_ms": 1.279, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1097, "2ef3d3401cb2": 1103, "533549b432a8": 1098, "8f4056cc3ff4": 1095}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 652.544, "p50": 53.271, "p95": 511.157, "p99": 579.698}, "mode": "closed", "ok": 4393, "ok_read_rps": 147.4, "ok_rps": 292.8666666666667, "ok_write_rps": 145.46666666666667, "rate": 0, "read_ms": {"max": 80.131, "p50": 17.482, "p95": 39.376, "p99": 51.011}, "requests": 4393, "timestamp": "2026-10-23T23:27:55Z", "warmup_s": 3, "write_ms": {"max": 652.544, "p50": 413.179, "p95": 542.831, "p99": 600.759}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 16.7, "cpu_pct_max_per_container": 20.1, "cpu_utilization_of_limit": 0.335, "mem_max_mib": 190.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.5, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.09, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.5, "cpu_pct_max_per_container": 25.6, "cpu_utilization_of_limit": 0.195, "mem_max_mib": 218.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 77}}, "pool": {"acquires": 15765, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.013, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1245, "2ef3d3401cb2": 1255, "533549b432a8": 1236, "8f4056cc3ff4": 1246}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 583.385, "p50": 42.372, "p95": 463.752, "p99": 516.875}, "mode": "closed", "ok": 4982, "ok_read_rps": 170.13333333333333, "ok_rps": 332.1333333333333, "ok_write_rps": 162, "rate": 0, "read_ms": {"max": 74.941, "p50": 15.823, "p95": 36.224, "p99": 51.606}, "requests": 4982, "timestamp": "2026-10-23T23:28:15Z", "warmup_s": 3, "write_ms": {"max": 583.385, "p50": 365.728, "p95": 490.161, "p99": 529.503}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.6, "cpu_pct_max_per_container": 20.5, "cpu_utilization_of_limit": 0.353, "mem_max_mib": 63.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 10.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.7, "cpu_pct_max_per_container": 20.8, "cpu_utilization_of_limit": 0.197, "mem_max_mib": 223.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 12.7}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 77}}, "pool": {"acquires": 17370, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1144, "3a27245eecd3": 1146, "9cafee3d15ce": 1145, "beb91c4b6792": 1146}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 217.825, "p50": 26.601, "p95": 126.088, "p99": 148.151}, "mode": "closed", "ok": 4581, "ok_read_rps": 154.33333333333334, "ok_rps": 305.4, "ok_write_rps": 151.06666666666666, "rate": 0, "read_ms": {"max": 51.025, "p50": 5.996, "p95": 16.906, "p99": 26.735}, "requests": 4581, "timestamp": "2026-10-23T23:28:53Z", "warmup_s": 3, "write_ms": {"max": 217.825, "p50": 95.541, "p95": 138.411, "p99": 155.259}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.1, "cpu_pct_max_per_container": 19.5, "cpu_utilization_of_limit": 0.342, "mem_max_mib": 144.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.098, "mem_max_mib": 10.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.1, "cpu_pct_max_per_container": 23.3, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 82.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.7, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.014, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 24}}, "pool": {"acquires": 16085, "empty_acquire_ratio": 0.0009, "avg_acquire_wait_ms": 0.056, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1203, "3a27245eecd3": 1204, "9cafee3d15ce": 1196, "beb91c4b6792": 1205}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 226.511, "p50": 36.263, "p95": 126.913, "p99": 157.702}, "mode": "closed", "ok": 4808, "ok_read_rps": 160.4, "ok_rps": 320.53333333333336, "ok_write_rps": 160.13333333333333, "rate": 0, "read_ms": {"max": 113.381, "p50": 5.595, "p95": 19.559, "p99": 33.333}, "requests": 4808, "timestamp": "2026-10-23T23:29:13Z", "warmup_s": 3, "write_ms": {"max": 226.511, "p50": 90.369, "p95": 139.819, "p99": 169.703}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.7, "cpu_pct_max_per_container": 22.3, "cpu_utilization_of_limit": 0.353, "mem_max_mib": 239.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.094, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.1, "cpu_pct_max_per_container": 42.4, "cpu_utilization_of_limit": 0.115, "mem_max_mib": 86.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.7, "cpu_utilization_of_limit": 1.0, "mem_max_mib": 12.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 24}}, "pool": {"acquires": 16066, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1487, "3a27245eecd3": 1486, "9cafee3d15ce": 1487, "beb91c4b6792": 1492}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 169.105, "p50": 38.702, "p95": 98.134, "p99": 128.479}, "mode": "closed", "ok": 5952, "ok_read_rps": 194.26666666666668, "ok_rps": 396.8, "ok_write_rps": 202.53333333333333, "rate": 0, "read_ms": {"max": 51.566, "p50": 5.052, "p95": 15.519, "p99": 26.623}, "requests": 5952, "timestamp": "2026-10-23T23:29:33Z", "warmup_s": 3, "write_ms": {"max": 169.105, "p50": 69.4, "p95": 109.211, "p99": 143.721}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.427, "mem_max_mib": 248.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.0, "cpu_pct_max_per_container": 28.5, "cpu_utilization_of_limit": 0.115, "mem_max_mib": 98.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.5, "cpu_pct_max_per_container": 50.3, "cpu_utilization_of_limit": 0.949, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 28}}, "pool": {"acquires": 20655, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1372, "3a27245eecd3": 1369, "9cafee3d15ce": 1379, "beb91c4b6792": 1387}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 602.217, "p50": 186.508, "p95": 419.726, "p99": 479.103}, "mode": "closed", "ok": 5507, "ok_read_rps": 183.06666666666666, "ok_rps": 367.1333333333333, "ok_write_rps": 184.06666666666666, "rate": 0, "read_ms": {"max": 128.965, "p50": 13.859, "p95": 31.074, "p99": 50.59}, "requests": 5507, "timestamp": "2026-10-23T23:29:54Z", "warmup_s": 3, "write_ms": {"max": 602.217, "p50": 318.012, "p95": 444.494, "p99": 498.412}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.7, "cpu_pct_max_per_container": 23.6, "cpu_utilization_of_limit": 0.373, "mem_max_mib": 253.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 10.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.111, "mem_max_mib": 111.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.1, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 0.982, "mem_max_mib": 13.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 32}}, "pool": {"acquires": 19667, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.013, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1436, "3a27245eecd3": 1436, "9cafee3d15ce": 1433, "beb91c4b6792": 1446}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 843.954, "p50": 69.707, "p95": 395.186, "p99": 555.551}, "mode": "closed", "ok": 5751, "ok_read_rps": 193.8, "ok_rps": 383.4, "ok_write_rps": 189.6, "rate": 0, "read_ms": {"max": 266.917, "p50": 15, "p95": 42.392, "p99": 71.437}, "requests": 5751, "timestamp": "2026-10-23T23:30:14Z", "warmup_s": 3, "write_ms": {"max": 843.954, "p50": 306.984, "p95": 446.034, "p99": 600.955}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.3, "cpu_pct_max_per_container": 21.9, "cpu_utilization_of_limit": 0.387, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.099, "mem_max_mib": 11.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 26.9, "cpu_pct_max_per_container": 40.8, "cpu_utilization_of_limit": 0.134, "mem_max_mib": 216.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.1, "cpu_pct_max_per_container": 49.1, "cpu_utilization_of_limit": 0.961, "mem_max_mib": 14.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 76}}, "pool": {"acquires": 19510, "empty_acquire_ratio": 0.0055, "avg_acquire_wait_ms": 1.044, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1563, "3a27245eecd3": 1554, "9cafee3d15ce": 1561, "beb91c4b6792": 1564}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 458.763, "p50": 209.95, "p95": 352.224, "p99": 410.267}, "mode": "closed", "ok": 6242, "ok_read_rps": 203.33333333333334, "ok_rps": 416.1333333333333, "ok_write_rps": 212.8, "rate": 0, "read_ms": {"max": 95.05, "p50": 12.742, "p95": 28.693, "p99": 44.209}, "requests": 6242, "timestamp": "2026-10-23T23:30:36Z", "warmup_s": 3, "write_ms": {"max": 458.763, "p50": 279.547, "p95": 380.263, "p99": 424.66}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.2, "cpu_pct_max_per_container": 22.8, "cpu_utilization_of_limit": 0.405, "mem_max_mib": 73.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 11.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.2, "cpu_pct_max_per_container": 25.3, "cpu_utilization_of_limit": 0.116, "mem_max_mib": 220.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.2, "cpu_pct_max_per_container": 48.8, "cpu_utilization_of_limit": 0.944, "mem_max_mib": 13.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 76}}, "pool": {"acquires": 22017, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1323, "3a27245eecd3": 1325, "9cafee3d15ce": 1324, "beb91c4b6792": 1327}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 178.939, "p50": 21.992, "p95": 112.786, "p99": 145.393}, "mode": "closed", "ok": 5299, "ok_read_rps": 180.13333333333333, "ok_rps": 353.26666666666665, "ok_write_rps": 173.13333333333333, "rate": 0, "read_ms": {"max": 66.646, "p50": 5.555, "p95": 16.14, "p99": 28.82}, "requests": 5299, "timestamp": "2026-10-23T23:31:05Z", "warmup_s": 3, "write_ms": {"max": 178.939, "p50": 81.652, "p95": 127.798, "p99": 153.186}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.2, "cpu_pct_max_per_container": 24.0, "cpu_utilization_of_limit": 0.384, "mem_max_mib": 237.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.049, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 24.8, "cpu_utilization_of_limit": 0.222, "mem_max_mib": 78.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.1, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 0.982, "mem_max_mib": 13.2}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 21}}, "pool": {"acquires": 18455, "empty_acquire_ratio": 0.0009, "avg_acquire_wait_ms": 0.051, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1338, "3a27245eecd3": 1336, "9cafee3d15ce": 1335, "beb91c4b6792": 1338}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 677.896, "p50": 37.685, "p95": 105.769, "p99": 149.759}, "mode": "closed", "ok": 5347, "ok_read_rps": 176.26666666666668, "ok_rps": 356.46666666666664, "ok_write_rps": 180.2, "rate": 0, "read_ms": {"max": 211.976, "p50": 5.14, "p95": 15.21, "p99": 31.815}, "requests": 5347, "timestamp": "2026-10-23T23:31:24Z", "warmup_s": 3, "write_ms": {"max": 677.896, "p50": 75.583, "p95": 125.406, "p99": 164.102}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.4, "cpu_pct_max_per_container": 23.5, "cpu_utilization_of_limit": 0.388, "mem_max_mib": 253.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.047, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 25.0, "cpu_pct_max_per_container": 41.4, "cpu_utilization_of_limit": 0.25, "mem_max_mib": 88.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 46.7, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.934, "mem_max_mib": 13.1}, "postgres_connections": {"active_max": 3, "active_mean": 0.7, "total_max": 24}}, "pool": {"acquires": 19004, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.004, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1336, "3a27245eecd3": 1338, "9cafee3d15ce": 1335, "beb91c4b6792": 1335}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 348.508, "p50": 25.447, "p95": 114.883, "p99": 151.644}, "mode": "closed", "ok": 5344, "ok_read_rps": 180.33333333333334, "ok_rps": 356.26666666666665, "ok_write_rps": 175.93333333333334, "rate": 0, "read_ms": {"max": 140.733, "p50": 5.614, "p95": 17.077, "p99": 30.139}, "requests": 5344, "timestamp": "2026-10-23T23:31:44Z", "warmup_s": 3, "write_ms": {"max": 348.508, "p50": 79.14, "p95": 130.817, "p99": 173.595}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.1, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.382, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.049, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.7, "cpu_pct_max_per_container": 25.3, "cpu_utilization_of_limit": 0.217, "mem_max_mib": 96.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.3, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.965, "mem_max_mib": 13.1}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 26}}, "pool": {"acquires": 18631, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.008, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1404, "3a27245eecd3": 1405, "9cafee3d15ce": 1403, "beb91c4b6792": 1410}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 570.539, "p50": 53.112, "p95": 405.753, "p99": 489.61}, "mode": "closed", "ok": 5622, "ok_read_rps": 189.8, "ok_rps": 374.8, "ok_write_rps": 185, "rate": 0, "read_ms": {"max": 297.745, "p50": 13.542, "p95": 34.88, "p99": 60.6}, "requests": 5622, "timestamp": "2026-10-23T23:32:04Z", "warmup_s": 3, "write_ms": {"max": 570.539, "p50": 318.817, "p95": 443.588, "p99": 521.066}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.3, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.385, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.05, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.7, "cpu_pct_max_per_container": 38.8, "cpu_utilization_of_limit": 0.247, "mem_max_mib": 154.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.0, "cpu_pct_max_per_container": 49.9, "cpu_utilization_of_limit": 0.98, "mem_max_mib": 14.1}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 50}}, "pool": {"acquires": 19762, "empty_acquire_ratio": 0.0012, "avg_acquire_wait_ms": 0.106, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1541, "3a27245eecd3": 1542, "9cafee3d15ce": 1544, "beb91c4b6792": 1537}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 571.122, "p50": 41.571, "p95": 379.461, "p99": 477.927}, "mode": "closed", "ok": 6164, "ok_read_rps": 208.13333333333333, "ok_rps": 410.93333333333334, "ok_write_rps": 202.8, "rate": 0, "read_ms": {"max": 102.403, "p50": 12.731, "p95": 29.276, "p99": 43.524}, "requests": 6164, "timestamp": "2026-10-23T23:32:25Z", "warmup_s": 3, "write_ms": {"max": 571.122, "p50": 289.583, "p95": 429.936, "p99": 506.316}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.8, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.396, "mem_max_mib": 234.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.05, "mem_max_mib": 9.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.4, "cpu_pct_max_per_container": 37.2, "cpu_utilization_of_limit": 0.244, "mem_max_mib": 210.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.1, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 0.962, "mem_max_mib": 14.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 74}}, "pool": {"acquires": 20688, "empty_acquire_ratio": 0.0013, "avg_acquire_wait_ms": 0.366, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1588, "3a27245eecd3": 1582, "9cafee3d15ce": 1585, "beb91c4b6792": 1590}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 495.795, "p50": 38.123, "p95": 369.645, "p99": 427.292}, "mode": "closed", "ok": 6345, "ok_read_rps": 216.2, "ok_rps": 423, "ok_write_rps": 206.8, "rate": 0, "read_ms": {"max": 82.119, "p50": 13.025, "p95": 30.114, "p99": 45.098}, "requests": 6345, "timestamp": "2026-10-23T23:32:46Z", "warmup_s": 3, "write_ms": {"max": 495.795, "p50": 285.975, "p95": 395.812, "p99": 452.116}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.3, "cpu_pct_max_per_container": 22.1, "cpu_utilization_of_limit": 0.406, "mem_max_mib": 54.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.3, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.053, "mem_max_mib": 10.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.1, "cpu_pct_max_per_container": 26.4, "cpu_utilization_of_limit": 0.231, "mem_max_mib": 220.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.3, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 0.966, "mem_max_mib": 14.3}, "postgres_connections": {"active_max": 3, "active_mean": 0.6, "total_max": 75}}, "pool": {"acquires": 22178, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.013, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1492, "3a27245eecd3": 1493, "9cafee3d15ce": 1495, "beb91c4b6792": 1492}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 205.369, "p50": 29.384, "p95": 98.163, "p99": 131.51}, "mode": "closed", "ok": 5972, "ok_read_rps": 198.66666666666666, "ok_rps": 398.1333333333333, "ok_write_rps": 199.46666666666667, "rate": 0, "read_ms": {"max": 52.092, "p50": 4.895, "p95": 13.789, "p99": 22.055}, "requests": 5972, "timestamp": "2026-10-23T23:33:14Z", "warmup_s": 3, "write_ms": {"max": 205.369, "p50": 70.699, "p95": 109.915, "p99": 144.848}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.5, "cpu_pct_max_per_container": 23.4, "cpu_utilization_of_limit": 0.429, "mem_max_mib": 60.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.5, "cpu_pct_max_per_container": 24.2, "cpu_utilization_of_limit": 0.225, "mem_max_mib": 224.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.0, "cpu_pct_max_per_container": 51.7, "cpu_utilization_of_limit": 0.49, "mem_max_mib": 11.7}, "postgres_connections": {"active_max": 2, "active_mean": 0.6, "total_max": 75}}, "pool": {"acquires": 20615, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1469, "3a27245eecd3": 1471, "9cafee3d15ce": 1472, "beb91c4b6792": 1468}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 228.462, "p50": 28.229, "p95": 104.603, "p99": 138.431}, "mode": "closed", "ok": 5880, "ok_read_rps": 198.2, "ok_rps": 392, "ok_write_rps": 193.8, "rate": 0, "read_ms": {"max": 131.703, "p50": 5.345, "p95": 17.621, "p99": 37.853}, "requests": 5880, "timestamp": "2026-10-23T23:33:33Z", "warmup_s": 3, "write_ms": {"max": 228.462, "p50": 72.192, "p95": 119.751, "p99": 149.268}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.426, "mem_max_mib": 54.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 25.0, "cpu_pct_max_per_container": 33.8, "cpu_utilization_of_limit": 0.25, "mem_max_mib": 227.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.4, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 0.494, "mem_max_mib": 11.8}, "postgres_connections": {"active_max": 3, "active_mean": 0.7, "total_max": 75}}, "pool": {"acquires": 20550, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1393, "3a27245eecd3": 1396, "9cafee3d15ce": 1398, "beb91c4b6792": 1395}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 184.833, "p50": 32.112, "p95": 104.052, "p99": 131.39}, "mode": "closed", "ok": 5582, "ok_read_rps": 185.4, "ok_rps": 372.1333333333333, "ok_write_rps": 186.73333333333332, "rate": 0, "read_ms": {"max": 52.035, "p50": 5.195, "p95": 14.777, "p99": 26.574}, "requests": 5582, "timestamp": "2026-10-23T23:33:53Z", "warmup_s": 3, "write_ms": {"max": 184.833, "p50": 75.98, "p95": 117.102, "p99": 140.782}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 23.3, "cpu_utilization_of_limit": 0.425, "mem_max_mib": 54.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.4, "cpu_pct_max_per_container": 24.6, "cpu_utilization_of_limit": 0.224, "mem_max_mib": 229.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.8, "cpu_pct_max_per_container": 52.2, "cpu_utilization_of_limit": 0.498, "mem_max_mib": 12.3}, "postgres_connections": {"active_max": 4, "active_mean": 0.6, "total_max": 75}}, "pool": {"acquires": 19306, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1538, "3a27245eecd3": 1554, "9cafee3d15ce": 1547, "beb91c4b6792": 1548}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 549.094, "p50": 47.098, "p95": 375.082, "p99": 428.764}, "mode": "closed", "ok": 6187, "ok_read_rps": 208.2, "ok_rps": 412.46666666666664, "ok_write_rps": 204.26666666666668, "rate": 0, "read_ms": {"max": 82.73, "p50": 13.073, "p95": 31.862, "p99": 46.73}, "requests": 6187, "timestamp": "2026-10-23T23:34:14Z", "warmup_s": 3, "write_ms": {"max": 549.094, "p50": 288.439, "p95": 396.509, "p99": 460.481}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.9, "cpu_pct_max_per_container": 23.6, "cpu_utilization_of_limit": 0.418, "mem_max_mib": 54.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.4, "cpu_pct_max_per_container": 5.9, "cpu_utilization_of_limit": 0.107, "mem_max_mib": 10.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.6, "cpu_pct_max_per_container": 24.8, "cpu_utilization_of_limit": 0.236, "mem_max_mib": 236.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 54.2, "cpu_utilization_of_limit": 0.502, "mem_max_mib": 13.5}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 76}}, "pool": {"acquires": 20793, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.008, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1403, "3a27245eecd3": 1401, "9cafee3d15ce": 1405, "beb91c4b6792": 1406}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 678.797, "p50": 58.303, "p95": 426.689, "p99": 536.919}, "mode": "closed", "ok": 5615, "ok_read_rps": 188.53333333333333, "ok_rps": 374.3333333333333, "ok_write_rps": 185.8, "rate": 0, "read_ms": {"max": 87.435, "p50": 13.931, "p95": 33.561, "p99": 55.567}, "requests": 5615, "timestamp": "2026-10-23T23:34:34Z", "warmup_s": 3, "write_ms": {"max": 678.797, "p50": 320.861, "p95": 470.893, "p99": 576.676}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.5, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.409, "mem_max_mib": 60.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.2, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.104, "mem_max_mib": 10.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.0, "cpu_pct_max_per_container": 27.2, "cpu_utilization_of_limit": 0.24, "mem_max_mib": 244.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.9, "cpu_pct_max_per_container": 55.9, "cpu_utilization_of_limit": 0.509, "mem_max_mib": 13.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 78}}, "pool": {"acquires": 19003, "empty_acquire_ratio": 0.0017, "avg_acquire_wait_ms": 0.016, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1515, "3a27245eecd3": 1521, "9cafee3d15ce": 1513, "beb91c4b6792": 1520}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 554.522, "p50": 43.666, "p95": 405.322, "p99": 468.326}, "mode": "closed", "ok": 6069, "ok_read_rps": 205.26666666666668, "ok_rps": 404.6, "ok_write_rps": 199.33333333333334, "rate": 0, "read_ms": {"max": 62.349, "p50": 13.646, "p95": 32.06, "p99": 46.229}, "requests": 6069, "timestamp": "2026-10-23T23:34:56Z", "warmup_s": 3, "write_ms": {"max": 554.522, "p50": 291.584, "p95": 441.414, "p99": 488.015}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.0, "cpu_pct_max_per_container": 23.9, "cpu_utilization_of_limit": 0.42, "mem_max_mib": 55.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.4, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.108, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.9, "cpu_pct_max_per_container": 25.1, "cpu_utilization_of_limit": 0.239, "mem_max_mib": 246.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 55.3, "cpu_utilization_of_limit": 0.501, "mem_max_mib": 13.7}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 78}}, "pool": {"acquires": 20929, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} diff --git a/evidence/track1/raw.jsonl b/evidence/track1/raw.jsonl index e8c1657d..fc0afa87 100644 --- a/evidence/track1/raw.jsonl +++ b/evidence/track1/raw.jsonl @@ -52,30 +52,6 @@ {"series": "B_scale_out", "config": "4x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 1574, "8759eb8c2e05": 1563, "e59a806e8df9": 1572, "f5d97f666c30": 1576}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 421.671, "p50": 229.027, "p95": 341.03, "p99": 371.812}, "mode": "closed", "ok": 6285, "ok_read_rps": 206.53333333333333, "ok_rps": 419, "ok_write_rps": 212.46666666666667, "rate": 0, "read_ms": {"max": 82.262, "p50": 12.85, "p95": 26.722, "p99": 37.439}, "requests": 6285, "timestamp": "2026-10-23T23:36:02Z", "warmup_s": 3, "write_ms": {"max": 421.671, "p50": 280.329, "p95": 358.21, "p99": 383.369}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.4, "cpu_pct_max_per_container": 21.0, "cpu_utilization_of_limit": 0.368, "mem_max_mib": 242.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.6, "cpu_pct_max_per_container": 6.0, "cpu_utilization_of_limit": 0.113, "mem_max_mib": 12.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 28.1, "cpu_pct_max_per_container": 30.9, "cpu_utilization_of_limit": 0.281, "mem_max_mib": 282.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 14.1}, "postgres_connections": {"active_max": 3, "active_mean": 0.7, "total_max": 80}}, "pool": {"acquires": 21527, "empty_acquire_ratio": 0.0065, "avg_acquire_wait_ms": 0.469, "pool_max_conns_total": 80}} {"series": "B_scale_out", "config": "4x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 1571, "8759eb8c2e05": 1574, "e59a806e8df9": 1574, "f5d97f666c30": 1584}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 434.235, "p50": 182.649, "p95": 343.641, "p99": 390.485}, "mode": "closed", "ok": 6303, "ok_read_rps": 209.93333333333334, "ok_rps": 420.2, "ok_write_rps": 210.26666666666668, "rate": 0, "read_ms": {"max": 97.706, "p50": 13.273, "p95": 30.757, "p99": 46}, "requests": 6303, "timestamp": "2026-10-23T23:36:24Z", "warmup_s": 3, "write_ms": {"max": 434.235, "p50": 282.753, "p95": 364.367, "p99": 404.991}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.3, "cpu_pct_max_per_container": 21.9, "cpu_utilization_of_limit": 0.367, "mem_max_mib": 63.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.4, "cpu_pct_max_per_container": 5.8, "cpu_utilization_of_limit": 0.108, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 27.3, "cpu_pct_max_per_container": 30.7, "cpu_utilization_of_limit": 0.273, "mem_max_mib": 287.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.6, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.971, "mem_max_mib": 14.0}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 80}}, "pool": {"acquires": 21777, "empty_acquire_ratio": 0.0004, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} {"series": "B_scale_out", "config": "4x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8322920448"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"72ed7547ec9c": 1523, "8759eb8c2e05": 1536, "e59a806e8df9": 1528, "f5d97f666c30": 1527}, "label": "B_scale_out/4x0.50", "latency_ms": {"max": 462.871, "p50": 213.437, "p95": 357.106, "p99": 416.866}, "mode": "closed", "ok": 6114, "ok_read_rps": 203.13333333333333, "ok_rps": 407.6, "ok_write_rps": 204.46666666666667, "rate": 0, "read_ms": {"max": 52.386, "p50": 13.066, "p95": 26.731, "p99": 34.753}, "requests": 6114, "timestamp": "2026-10-23T23:36:47Z", "warmup_s": 3, "write_ms": {"max": 462.871, "p50": 288.351, "p95": 379.333, "p99": 427.916}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.4, "cpu_pct_max_per_container": 21.4, "cpu_utilization_of_limit": 0.367, "mem_max_mib": 61.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.3, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.106, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 29.9, "cpu_pct_max_per_container": 48.2, "cpu_utilization_of_limit": 0.299, "mem_max_mib": 291.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.7, "cpu_pct_max_per_container": 52.3, "cpu_utilization_of_limit": 0.973, "mem_max_mib": 14.3}, "postgres_connections": {"active_max": 3, "active_mean": 0.9, "total_max": 81}}, "pool": {"acquires": 21361, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1243, "2ef3d3401cb2": 1242, "533549b432a8": 1242, "8f4056cc3ff4": 1241}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 206.674, "p50": 22.165, "p95": 118.795, "p99": 150.913}, "mode": "closed", "ok": 4968, "ok_read_rps": 168.6, "ok_rps": 331.2, "ok_write_rps": 162.6, "rate": 0, "read_ms": {"max": 44.795, "p50": 5.456, "p95": 16.323, "p99": 25.96}, "requests": 4968, "timestamp": "2026-10-23T23:26:29Z", "warmup_s": 3, "write_ms": {"max": 206.674, "p50": 89.332, "p95": 132.244, "p99": 171.409}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.7, "cpu_pct_max_per_container": 21.1, "cpu_utilization_of_limit": 0.354, "mem_max_mib": 138.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.094, "mem_max_mib": 8.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.6, "cpu_pct_max_per_container": 22.5, "cpu_utilization_of_limit": 0.206, "mem_max_mib": 80.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.4, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.008, "mem_max_mib": 11.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 21}}, "pool": {"acquires": 17106, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.034, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1306, "2ef3d3401cb2": 1308, "533549b432a8": 1310, "8f4056cc3ff4": 1310}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 242.967, "p50": 36.927, "p95": 116.484, "p99": 143.198}, "mode": "closed", "ok": 5234, "ok_read_rps": 172.46666666666667, "ok_rps": 348.93333333333334, "ok_write_rps": 176.46666666666667, "rate": 0, "read_ms": {"max": 61.356, "p50": 5.422, "p95": 16.465, "p99": 25.069}, "requests": 5234, "timestamp": "2026-10-23T23:26:49Z", "warmup_s": 3, "write_ms": {"max": 242.967, "p50": 78.066, "p95": 126.752, "p99": 157.955}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.2, "cpu_pct_max_per_container": 23.7, "cpu_utilization_of_limit": 0.384, "mem_max_mib": 255.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 8.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.4, "cpu_pct_max_per_container": 23.6, "cpu_utilization_of_limit": 0.214, "mem_max_mib": 84.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.991, "mem_max_mib": 11.2}, "postgres_connections": {"active_max": 16, "active_mean": 2.3, "total_max": 22}}, "pool": {"acquires": 18183, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1104, "2ef3d3401cb2": 1100, "533549b432a8": 1099, "8f4056cc3ff4": 1101}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 224.267, "p50": 38.097, "p95": 134.642, "p99": 171.335}, "mode": "closed", "ok": 4404, "ok_read_rps": 145.73333333333332, "ok_rps": 293.6, "ok_write_rps": 147.86666666666667, "rate": 0, "read_ms": {"max": 41.9, "p50": 6.18, "p95": 19.781, "p99": 29.134}, "requests": 4404, "timestamp": "2026-10-23T23:27:10Z", "warmup_s": 3, "write_ms": {"max": 224.267, "p50": 97.02, "p95": 152.977, "p99": 184.371}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 16.9, "cpu_pct_max_per_container": 19.3, "cpu_utilization_of_limit": 0.338, "mem_max_mib": 251.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.0, "cpu_pct_max_per_container": 22.3, "cpu_utilization_of_limit": 0.2, "mem_max_mib": 88.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.7, "cpu_pct_max_per_container": 51.8, "cpu_utilization_of_limit": 1.014, "mem_max_mib": 11.4}, "postgres_connections": {"active_max": 3, "active_mean": 0.4, "total_max": 22}}, "pool": {"acquires": 15996, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1217, "2ef3d3401cb2": 1206, "533549b432a8": 1209, "8f4056cc3ff4": 1208}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 672.9, "p50": 262.164, "p95": 460.581, "p99": 550.176}, "mode": "closed", "ok": 4840, "ok_read_rps": 158.2, "ok_rps": 322.6666666666667, "ok_write_rps": 164.46666666666667, "rate": 0, "read_ms": {"max": 215.547, "p50": 16.362, "p95": 43.832, "p99": 86.781}, "requests": 4840, "timestamp": "2026-10-23T23:27:31Z", "warmup_s": 3, "write_ms": {"max": 672.9, "p50": 358.675, "p95": 500.928, "p99": 564.241}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.6, "cpu_pct_max_per_container": 20.8, "cpu_utilization_of_limit": 0.352, "mem_max_mib": 247.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.095, "mem_max_mib": 9.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.6, "cpu_pct_max_per_container": 23.2, "cpu_utilization_of_limit": 0.216, "mem_max_mib": 216.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.3, "cpu_pct_max_per_container": 52.1, "cpu_utilization_of_limit": 1.007, "mem_max_mib": 18.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.2, "total_max": 76}}, "pool": {"acquires": 16507, "empty_acquire_ratio": 0.0041, "avg_acquire_wait_ms": 1.279, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1097, "2ef3d3401cb2": 1103, "533549b432a8": 1098, "8f4056cc3ff4": 1095}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 652.544, "p50": 53.271, "p95": 511.157, "p99": 579.698}, "mode": "closed", "ok": 4393, "ok_read_rps": 147.4, "ok_rps": 292.8666666666667, "ok_write_rps": 145.46666666666667, "rate": 0, "read_ms": {"max": 80.131, "p50": 17.482, "p95": 39.376, "p99": 51.011}, "requests": 4393, "timestamp": "2026-10-23T23:27:55Z", "warmup_s": 3, "write_ms": {"max": 652.544, "p50": 413.179, "p95": 542.831, "p99": 600.759}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 16.7, "cpu_pct_max_per_container": 20.1, "cpu_utilization_of_limit": 0.335, "mem_max_mib": 190.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.5, "cpu_pct_max_per_container": 4.7, "cpu_utilization_of_limit": 0.09, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.5, "cpu_pct_max_per_container": 25.6, "cpu_utilization_of_limit": 0.195, "mem_max_mib": 218.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 77}}, "pool": {"acquires": 15765, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.013, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"17f4fa182a1e": 1245, "2ef3d3401cb2": 1255, "533549b432a8": 1236, "8f4056cc3ff4": 1246}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 583.385, "p50": 42.372, "p95": 463.752, "p99": 516.875}, "mode": "closed", "ok": 4982, "ok_read_rps": 170.13333333333333, "ok_rps": 332.1333333333333, "ok_write_rps": 162, "rate": 0, "read_ms": {"max": 74.941, "p50": 15.823, "p95": 36.224, "p99": 51.606}, "requests": 4982, "timestamp": "2026-10-23T23:28:15Z", "warmup_s": 3, "write_ms": {"max": 583.385, "p50": 365.728, "p95": 490.161, "p99": 529.503}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.6, "cpu_pct_max_per_container": 20.5, "cpu_utilization_of_limit": 0.353, "mem_max_mib": 63.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 10.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.7, "cpu_pct_max_per_container": 20.8, "cpu_utilization_of_limit": 0.197, "mem_max_mib": 223.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 12.7}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 77}}, "pool": {"acquires": 17370, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1144, "3a27245eecd3": 1146, "9cafee3d15ce": 1145, "beb91c4b6792": 1146}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 217.825, "p50": 26.601, "p95": 126.088, "p99": 148.151}, "mode": "closed", "ok": 4581, "ok_read_rps": 154.33333333333334, "ok_rps": 305.4, "ok_write_rps": 151.06666666666666, "rate": 0, "read_ms": {"max": 51.025, "p50": 5.996, "p95": 16.906, "p99": 26.735}, "requests": 4581, "timestamp": "2026-10-23T23:28:53Z", "warmup_s": 3, "write_ms": {"max": 217.825, "p50": 95.541, "p95": 138.411, "p99": 155.259}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.1, "cpu_pct_max_per_container": 19.5, "cpu_utilization_of_limit": 0.342, "mem_max_mib": 144.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.098, "mem_max_mib": 10.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.1, "cpu_pct_max_per_container": 23.3, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 82.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.7, "cpu_pct_max_per_container": 51.5, "cpu_utilization_of_limit": 1.014, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 24}}, "pool": {"acquires": 16085, "empty_acquire_ratio": 0.0009, "avg_acquire_wait_ms": 0.056, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1203, "3a27245eecd3": 1204, "9cafee3d15ce": 1196, "beb91c4b6792": 1205}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 226.511, "p50": 36.263, "p95": 126.913, "p99": 157.702}, "mode": "closed", "ok": 4808, "ok_read_rps": 160.4, "ok_rps": 320.53333333333336, "ok_write_rps": 160.13333333333333, "rate": 0, "read_ms": {"max": 113.381, "p50": 5.595, "p95": 19.559, "p99": 33.333}, "requests": 4808, "timestamp": "2026-10-23T23:29:13Z", "warmup_s": 3, "write_ms": {"max": 226.511, "p50": 90.369, "p95": 139.819, "p99": 169.703}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.7, "cpu_pct_max_per_container": 22.3, "cpu_utilization_of_limit": 0.353, "mem_max_mib": 239.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.094, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.1, "cpu_pct_max_per_container": 42.4, "cpu_utilization_of_limit": 0.115, "mem_max_mib": 86.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.7, "cpu_utilization_of_limit": 1.0, "mem_max_mib": 12.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 24}}, "pool": {"acquires": 16066, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1487, "3a27245eecd3": 1486, "9cafee3d15ce": 1487, "beb91c4b6792": 1492}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 169.105, "p50": 38.702, "p95": 98.134, "p99": 128.479}, "mode": "closed", "ok": 5952, "ok_read_rps": 194.26666666666668, "ok_rps": 396.8, "ok_write_rps": 202.53333333333333, "rate": 0, "read_ms": {"max": 51.566, "p50": 5.052, "p95": 15.519, "p99": 26.623}, "requests": 5952, "timestamp": "2026-10-23T23:29:33Z", "warmup_s": 3, "write_ms": {"max": 169.105, "p50": 69.4, "p95": 109.211, "p99": 143.721}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.427, "mem_max_mib": 248.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.0, "cpu_pct_max_per_container": 28.5, "cpu_utilization_of_limit": 0.115, "mem_max_mib": 98.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.5, "cpu_pct_max_per_container": 50.3, "cpu_utilization_of_limit": 0.949, "mem_max_mib": 12.6}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 28}}, "pool": {"acquires": 20655, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1372, "3a27245eecd3": 1369, "9cafee3d15ce": 1379, "beb91c4b6792": 1387}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 602.217, "p50": 186.508, "p95": 419.726, "p99": 479.103}, "mode": "closed", "ok": 5507, "ok_read_rps": 183.06666666666666, "ok_rps": 367.1333333333333, "ok_write_rps": 184.06666666666666, "rate": 0, "read_ms": {"max": 128.965, "p50": 13.859, "p95": 31.074, "p99": 50.59}, "requests": 5507, "timestamp": "2026-10-23T23:29:54Z", "warmup_s": 3, "write_ms": {"max": 602.217, "p50": 318.012, "p95": 444.494, "p99": 498.412}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.7, "cpu_pct_max_per_container": 23.6, "cpu_utilization_of_limit": 0.373, "mem_max_mib": 253.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 10.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.111, "mem_max_mib": 111.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.1, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 0.982, "mem_max_mib": 13.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 32}}, "pool": {"acquires": 19667, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.013, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1436, "3a27245eecd3": 1436, "9cafee3d15ce": 1433, "beb91c4b6792": 1446}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 843.954, "p50": 69.707, "p95": 395.186, "p99": 555.551}, "mode": "closed", "ok": 5751, "ok_read_rps": 193.8, "ok_rps": 383.4, "ok_write_rps": 189.6, "rate": 0, "read_ms": {"max": 266.917, "p50": 15, "p95": 42.392, "p99": 71.437}, "requests": 5751, "timestamp": "2026-10-23T23:30:14Z", "warmup_s": 3, "write_ms": {"max": 843.954, "p50": 306.984, "p95": 446.034, "p99": 600.955}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.3, "cpu_pct_max_per_container": 21.9, "cpu_utilization_of_limit": 0.387, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.099, "mem_max_mib": 11.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 26.9, "cpu_pct_max_per_container": 40.8, "cpu_utilization_of_limit": 0.134, "mem_max_mib": 216.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.1, "cpu_pct_max_per_container": 49.1, "cpu_utilization_of_limit": 0.961, "mem_max_mib": 14.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 76}}, "pool": {"acquires": 19510, "empty_acquire_ratio": 0.0055, "avg_acquire_wait_ms": 1.044, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1563, "3a27245eecd3": 1554, "9cafee3d15ce": 1561, "beb91c4b6792": 1564}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 458.763, "p50": 209.95, "p95": 352.224, "p99": 410.267}, "mode": "closed", "ok": 6242, "ok_read_rps": 203.33333333333334, "ok_rps": 416.1333333333333, "ok_write_rps": 212.8, "rate": 0, "read_ms": {"max": 95.05, "p50": 12.742, "p95": 28.693, "p99": 44.209}, "requests": 6242, "timestamp": "2026-10-23T23:30:36Z", "warmup_s": 3, "write_ms": {"max": 458.763, "p50": 279.547, "p95": 380.263, "p99": 424.66}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.2, "cpu_pct_max_per_container": 22.8, "cpu_utilization_of_limit": 0.405, "mem_max_mib": 73.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 11.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.2, "cpu_pct_max_per_container": 25.3, "cpu_utilization_of_limit": 0.116, "mem_max_mib": 220.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.2, "cpu_pct_max_per_container": 48.8, "cpu_utilization_of_limit": 0.944, "mem_max_mib": 13.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 76}}, "pool": {"acquires": 22017, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1323, "3a27245eecd3": 1325, "9cafee3d15ce": 1324, "beb91c4b6792": 1327}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 178.939, "p50": 21.992, "p95": 112.786, "p99": 145.393}, "mode": "closed", "ok": 5299, "ok_read_rps": 180.13333333333333, "ok_rps": 353.26666666666665, "ok_write_rps": 173.13333333333333, "rate": 0, "read_ms": {"max": 66.646, "p50": 5.555, "p95": 16.14, "p99": 28.82}, "requests": 5299, "timestamp": "2026-10-23T23:31:05Z", "warmup_s": 3, "write_ms": {"max": 178.939, "p50": 81.652, "p95": 127.798, "p99": 153.186}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.2, "cpu_pct_max_per_container": 24.0, "cpu_utilization_of_limit": 0.384, "mem_max_mib": 237.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.049, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 24.8, "cpu_utilization_of_limit": 0.222, "mem_max_mib": 78.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.1, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 0.982, "mem_max_mib": 13.2}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 21}}, "pool": {"acquires": 18455, "empty_acquire_ratio": 0.0009, "avg_acquire_wait_ms": 0.051, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1338, "3a27245eecd3": 1336, "9cafee3d15ce": 1335, "beb91c4b6792": 1338}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 677.896, "p50": 37.685, "p95": 105.769, "p99": 149.759}, "mode": "closed", "ok": 5347, "ok_read_rps": 176.26666666666668, "ok_rps": 356.46666666666664, "ok_write_rps": 180.2, "rate": 0, "read_ms": {"max": 211.976, "p50": 5.14, "p95": 15.21, "p99": 31.815}, "requests": 5347, "timestamp": "2026-10-23T23:31:24Z", "warmup_s": 3, "write_ms": {"max": 677.896, "p50": 75.583, "p95": 125.406, "p99": 164.102}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.4, "cpu_pct_max_per_container": 23.5, "cpu_utilization_of_limit": 0.388, "mem_max_mib": 253.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.047, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 25.0, "cpu_pct_max_per_container": 41.4, "cpu_utilization_of_limit": 0.25, "mem_max_mib": 88.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 46.7, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.934, "mem_max_mib": 13.1}, "postgres_connections": {"active_max": 3, "active_mean": 0.7, "total_max": 24}}, "pool": {"acquires": 19004, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.004, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1336, "3a27245eecd3": 1338, "9cafee3d15ce": 1335, "beb91c4b6792": 1335}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 348.508, "p50": 25.447, "p95": 114.883, "p99": 151.644}, "mode": "closed", "ok": 5344, "ok_read_rps": 180.33333333333334, "ok_rps": 356.26666666666665, "ok_write_rps": 175.93333333333334, "rate": 0, "read_ms": {"max": 140.733, "p50": 5.614, "p95": 17.077, "p99": 30.139}, "requests": 5344, "timestamp": "2026-10-23T23:31:44Z", "warmup_s": 3, "write_ms": {"max": 348.508, "p50": 79.14, "p95": 130.817, "p99": 173.595}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.1, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.382, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.049, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.7, "cpu_pct_max_per_container": 25.3, "cpu_utilization_of_limit": 0.217, "mem_max_mib": 96.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.3, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.965, "mem_max_mib": 13.1}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 26}}, "pool": {"acquires": 18631, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.008, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1404, "3a27245eecd3": 1405, "9cafee3d15ce": 1403, "beb91c4b6792": 1410}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 570.539, "p50": 53.112, "p95": 405.753, "p99": 489.61}, "mode": "closed", "ok": 5622, "ok_read_rps": 189.8, "ok_rps": 374.8, "ok_write_rps": 185, "rate": 0, "read_ms": {"max": 297.745, "p50": 13.542, "p95": 34.88, "p99": 60.6}, "requests": 5622, "timestamp": "2026-10-23T23:32:04Z", "warmup_s": 3, "write_ms": {"max": 570.539, "p50": 318.817, "p95": 443.588, "p99": 521.066}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.3, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.385, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.05, "mem_max_mib": 10.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.7, "cpu_pct_max_per_container": 38.8, "cpu_utilization_of_limit": 0.247, "mem_max_mib": 154.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.0, "cpu_pct_max_per_container": 49.9, "cpu_utilization_of_limit": 0.98, "mem_max_mib": 14.1}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 50}}, "pool": {"acquires": 19762, "empty_acquire_ratio": 0.0012, "avg_acquire_wait_ms": 0.106, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1541, "3a27245eecd3": 1542, "9cafee3d15ce": 1544, "beb91c4b6792": 1537}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 571.122, "p50": 41.571, "p95": 379.461, "p99": 477.927}, "mode": "closed", "ok": 6164, "ok_read_rps": 208.13333333333333, "ok_rps": 410.93333333333334, "ok_write_rps": 202.8, "rate": 0, "read_ms": {"max": 102.403, "p50": 12.731, "p95": 29.276, "p99": 43.524}, "requests": 6164, "timestamp": "2026-10-23T23:32:25Z", "warmup_s": 3, "write_ms": {"max": 571.122, "p50": 289.583, "p95": 429.936, "p99": 506.316}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.8, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.396, "mem_max_mib": 234.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.05, "mem_max_mib": 9.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.4, "cpu_pct_max_per_container": 37.2, "cpu_utilization_of_limit": 0.244, "mem_max_mib": 210.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.1, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 0.962, "mem_max_mib": 14.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 74}}, "pool": {"acquires": 20688, "empty_acquire_ratio": 0.0013, "avg_acquire_wait_ms": 0.366, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1588, "3a27245eecd3": 1582, "9cafee3d15ce": 1585, "beb91c4b6792": 1590}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 495.795, "p50": 38.123, "p95": 369.645, "p99": 427.292}, "mode": "closed", "ok": 6345, "ok_read_rps": 216.2, "ok_rps": 423, "ok_write_rps": 206.8, "rate": 0, "read_ms": {"max": 82.119, "p50": 13.025, "p95": 30.114, "p99": 45.098}, "requests": 6345, "timestamp": "2026-10-23T23:32:46Z", "warmup_s": 3, "write_ms": {"max": 495.795, "p50": 285.975, "p95": 395.812, "p99": 452.116}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.3, "cpu_pct_max_per_container": 22.1, "cpu_utilization_of_limit": 0.406, "mem_max_mib": 54.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.3, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.053, "mem_max_mib": 10.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.1, "cpu_pct_max_per_container": 26.4, "cpu_utilization_of_limit": 0.231, "mem_max_mib": 220.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.3, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 0.966, "mem_max_mib": 14.3}, "postgres_connections": {"active_max": 3, "active_mean": 0.6, "total_max": 75}}, "pool": {"acquires": 22178, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.013, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1492, "3a27245eecd3": 1493, "9cafee3d15ce": 1495, "beb91c4b6792": 1492}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 205.369, "p50": 29.384, "p95": 98.163, "p99": 131.51}, "mode": "closed", "ok": 5972, "ok_read_rps": 198.66666666666666, "ok_rps": 398.1333333333333, "ok_write_rps": 199.46666666666667, "rate": 0, "read_ms": {"max": 52.092, "p50": 4.895, "p95": 13.789, "p99": 22.055}, "requests": 5972, "timestamp": "2026-10-23T23:33:14Z", "warmup_s": 3, "write_ms": {"max": 205.369, "p50": 70.699, "p95": 109.915, "p99": 144.848}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.5, "cpu_pct_max_per_container": 23.4, "cpu_utilization_of_limit": 0.429, "mem_max_mib": 60.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.5, "cpu_pct_max_per_container": 24.2, "cpu_utilization_of_limit": 0.225, "mem_max_mib": 224.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.0, "cpu_pct_max_per_container": 51.7, "cpu_utilization_of_limit": 0.49, "mem_max_mib": 11.7}, "postgres_connections": {"active_max": 2, "active_mean": 0.6, "total_max": 75}}, "pool": {"acquires": 20615, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1469, "3a27245eecd3": 1471, "9cafee3d15ce": 1472, "beb91c4b6792": 1468}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 228.462, "p50": 28.229, "p95": 104.603, "p99": 138.431}, "mode": "closed", "ok": 5880, "ok_read_rps": 198.2, "ok_rps": 392, "ok_write_rps": 193.8, "rate": 0, "read_ms": {"max": 131.703, "p50": 5.345, "p95": 17.621, "p99": 37.853}, "requests": 5880, "timestamp": "2026-10-23T23:33:33Z", "warmup_s": 3, "write_ms": {"max": 228.462, "p50": 72.192, "p95": 119.751, "p99": 149.268}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.426, "mem_max_mib": 54.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 25.0, "cpu_pct_max_per_container": 33.8, "cpu_utilization_of_limit": 0.25, "mem_max_mib": 227.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.4, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 0.494, "mem_max_mib": 11.8}, "postgres_connections": {"active_max": 3, "active_mean": 0.7, "total_max": 75}}, "pool": {"acquires": 20550, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1393, "3a27245eecd3": 1396, "9cafee3d15ce": 1398, "beb91c4b6792": 1395}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 184.833, "p50": 32.112, "p95": 104.052, "p99": 131.39}, "mode": "closed", "ok": 5582, "ok_read_rps": 185.4, "ok_rps": 372.1333333333333, "ok_write_rps": 186.73333333333332, "rate": 0, "read_ms": {"max": 52.035, "p50": 5.195, "p95": 14.777, "p99": 26.574}, "requests": 5582, "timestamp": "2026-10-23T23:33:53Z", "warmup_s": 3, "write_ms": {"max": 184.833, "p50": 75.98, "p95": 117.102, "p99": 140.782}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 23.3, "cpu_utilization_of_limit": 0.425, "mem_max_mib": 54.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.4, "cpu_pct_max_per_container": 24.6, "cpu_utilization_of_limit": 0.224, "mem_max_mib": 229.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.8, "cpu_pct_max_per_container": 52.2, "cpu_utilization_of_limit": 0.498, "mem_max_mib": 12.3}, "postgres_connections": {"active_max": 4, "active_mean": 0.6, "total_max": 75}}, "pool": {"acquires": 19306, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1538, "3a27245eecd3": 1554, "9cafee3d15ce": 1547, "beb91c4b6792": 1548}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 549.094, "p50": 47.098, "p95": 375.082, "p99": 428.764}, "mode": "closed", "ok": 6187, "ok_read_rps": 208.2, "ok_rps": 412.46666666666664, "ok_write_rps": 204.26666666666668, "rate": 0, "read_ms": {"max": 82.73, "p50": 13.073, "p95": 31.862, "p99": 46.73}, "requests": 6187, "timestamp": "2026-10-23T23:34:14Z", "warmup_s": 3, "write_ms": {"max": 549.094, "p50": 288.439, "p95": 396.509, "p99": 460.481}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.9, "cpu_pct_max_per_container": 23.6, "cpu_utilization_of_limit": 0.418, "mem_max_mib": 54.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.4, "cpu_pct_max_per_container": 5.9, "cpu_utilization_of_limit": 0.107, "mem_max_mib": 10.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.6, "cpu_pct_max_per_container": 24.8, "cpu_utilization_of_limit": 0.236, "mem_max_mib": 236.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 54.2, "cpu_utilization_of_limit": 0.502, "mem_max_mib": 13.5}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 76}}, "pool": {"acquires": 20793, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.008, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1403, "3a27245eecd3": 1401, "9cafee3d15ce": 1405, "beb91c4b6792": 1406}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 678.797, "p50": 58.303, "p95": 426.689, "p99": 536.919}, "mode": "closed", "ok": 5615, "ok_read_rps": 188.53333333333333, "ok_rps": 374.3333333333333, "ok_write_rps": 185.8, "rate": 0, "read_ms": {"max": 87.435, "p50": 13.931, "p95": 33.561, "p99": 55.567}, "requests": 5615, "timestamp": "2026-10-23T23:34:34Z", "warmup_s": 3, "write_ms": {"max": 678.797, "p50": 320.861, "p95": 470.893, "p99": 576.676}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.5, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.409, "mem_max_mib": 60.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.2, "cpu_pct_max_per_container": 5.7, "cpu_utilization_of_limit": 0.104, "mem_max_mib": 10.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.0, "cpu_pct_max_per_container": 27.2, "cpu_utilization_of_limit": 0.24, "mem_max_mib": 244.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.9, "cpu_pct_max_per_container": 55.9, "cpu_utilization_of_limit": 0.509, "mem_max_mib": 13.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 78}}, "pool": {"acquires": 19003, "empty_acquire_ratio": 0.0017, "avg_acquire_wait_ms": 0.016, "pool_max_conns_total": 80}} -{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"185d46c9f9f9": 1515, "3a27245eecd3": 1521, "9cafee3d15ce": 1513, "beb91c4b6792": 1520}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 554.522, "p50": 43.666, "p95": 405.322, "p99": 468.326}, "mode": "closed", "ok": 6069, "ok_read_rps": 205.26666666666668, "ok_rps": 404.6, "ok_write_rps": 199.33333333333334, "rate": 0, "read_ms": {"max": 62.349, "p50": 13.646, "p95": 32.06, "p99": 46.229}, "requests": 6069, "timestamp": "2026-10-23T23:34:56Z", "warmup_s": 3, "write_ms": {"max": 554.522, "p50": 291.584, "p95": 441.414, "p99": 488.015}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.0, "cpu_pct_max_per_container": 23.9, "cpu_utilization_of_limit": 0.42, "mem_max_mib": 55.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.4, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.108, "mem_max_mib": 10.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.9, "cpu_pct_max_per_container": 25.1, "cpu_utilization_of_limit": 0.239, "mem_max_mib": 246.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 55.3, "cpu_utilization_of_limit": 0.501, "mem_max_mib": 13.7}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 78}}, "pool": {"acquires": 20929, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} {"series": "D_improvement", "config": "baseline_scan", "concurrency": 32, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"246a774804a5": 1402, "93921a38e28e": 1401, "bbaee9b7f361": 1407, "ea9e7f87bfdf": 1410}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 302.086, "p50": 36.286, "p95": 210.733, "p99": 248.858}, "mode": "closed", "ok": 5620, "ok_read_rps": 188.86666666666667, "ok_rps": 374.6666666666667, "ok_write_rps": 185.8, "rate": 0, "read_ms": {"max": 62.957, "p50": 7.994, "p95": 23.126, "p99": 35.378}, "requests": 5620, "timestamp": "2026-10-23T23:26:32Z", "warmup_s": 3, "write_ms": {"max": 302.086, "p50": 155.989, "p95": 223.864, "p99": 259.623}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.6, "cpu_pct_max_per_container": 21.6, "cpu_utilization_of_limit": 0.372, "mem_max_mib": 138.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.099, "mem_max_mib": 9.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.5, "cpu_pct_max_per_container": 26.1, "cpu_utilization_of_limit": 0.225, "mem_max_mib": 120.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.1, "cpu_pct_max_per_container": 51.3, "cpu_utilization_of_limit": 1.001, "mem_max_mib": 12.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 41}}, "pool": {"acquires": 18869, "empty_acquire_ratio": 0.0016, "avg_acquire_wait_ms": 0.29, "pool_max_conns_total": 80}} {"series": "D_improvement", "config": "baseline_scan", "concurrency": 32, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"246a774804a5": 1402, "93921a38e28e": 1404, "bbaee9b7f361": 1406, "ea9e7f87bfdf": 1405}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 336.422, "p50": 55.124, "p95": 205.601, "p99": 259.884}, "mode": "closed", "ok": 5617, "ok_read_rps": 187.46666666666667, "ok_rps": 374.46666666666664, "ok_write_rps": 187, "rate": 0, "read_ms": {"max": 80.088, "p50": 8.012, "p95": 22.44, "p99": 35.849}, "requests": 5617, "timestamp": "2026-10-23T23:26:52Z", "warmup_s": 3, "write_ms": {"max": 336.422, "p50": 155.144, "p95": 223.114, "p99": 282.964}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.0, "cpu_pct_max_per_container": 21.7, "cpu_utilization_of_limit": 0.381, "mem_max_mib": 255.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 9.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 24.2, "cpu_utilization_of_limit": 0.222, "mem_max_mib": 129.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.992, "mem_max_mib": 11.9}, "postgres_connections": {"active_max": 2, "active_mean": 0.3, "total_max": 41}}, "pool": {"acquires": 19794, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} {"series": "D_improvement", "config": "baseline_scan", "concurrency": 32, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 32, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"246a774804a5": 1380, "93921a38e28e": 1375, "bbaee9b7f361": 1380, "ea9e7f87bfdf": 1375}, "label": "D_improvement/baseline_scan", "latency_ms": {"max": 599.673, "p50": 49.481, "p95": 213.452, "p99": 298.072}, "mode": "closed", "ok": 5510, "ok_read_rps": 184.8, "ok_rps": 367.3333333333333, "ok_write_rps": 182.53333333333333, "rate": 0, "read_ms": {"max": 154.643, "p50": 8.303, "p95": 25.956, "p99": 46.017}, "requests": 5510, "timestamp": "2026-10-23T23:27:13Z", "warmup_s": 3, "write_ms": {"max": 599.673, "p50": 155.995, "p95": 240.127, "p99": 365.087}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.3, "cpu_pct_max_per_container": 23.7, "cpu_utilization_of_limit": 0.366, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.094, "mem_max_mib": 9.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 23.9, "cpu_utilization_of_limit": 0.222, "mem_max_mib": 135.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.1, "cpu_pct_max_per_container": 50.4, "cpu_utilization_of_limit": 0.961, "mem_max_mib": 12.2}, "postgres_connections": {"active_max": 14, "active_mean": 2.6, "total_max": 43}}, "pool": {"acquires": 18983, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.007, "pool_max_conns_total": 80}} @@ -127,3 +103,53 @@ {"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"341f1c584d37": 1755, "45a6a0e6d809": 1750, "4770041f3a94": 1737, "8e63a84dfe7b": 1738}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 2110.687, "p50": 83.303, "p95": 456.482, "p99": 829.035}, "mode": "closed", "ok": 6980, "ok_read_rps": 232.4, "ok_rps": 465.3333333333333, "ok_write_rps": 232.93333333333334, "rate": 0, "read_ms": {"max": 273.397, "p50": 40.272, "p95": 118.648, "p99": 176.984}, "requests": 6980, "timestamp": "2026-10-23T23:35:43Z", "warmup_s": 3, "write_ms": {"max": 2110.687, "p50": 162.575, "p95": 629.875, "p99": 986.418}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.8, "cpu_pct_max_per_container": 21.5, "cpu_utilization_of_limit": 0.357, "mem_max_mib": 246.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.4, "cpu_pct_max_per_container": 8.7, "cpu_utilization_of_limit": 0.168, "mem_max_mib": 11.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 68.0, "cpu_pct_max_per_container": 74.2, "cpu_utilization_of_limit": 0.68, "mem_max_mib": 317.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 9.1, "cpu_pct_max_per_container": 11.9, "cpu_utilization_of_limit": 0.183, "mem_max_mib": 76.0}, "postgres_connections": {"active_max": 62, "active_mean": 52.5, "total_max": 81}}, "pool": {"acquires": 23727, "empty_acquire_ratio": 0.12, "avg_acquire_wait_ms": 1.869, "pool_max_conns_total": 80}} {"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"341f1c584d37": 1928, "45a6a0e6d809": 1916, "4770041f3a94": 1921, "8e63a84dfe7b": 1934}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 2593.861, "p50": 74.531, "p95": 392.002, "p99": 848.891}, "mode": "closed", "ok": 7699, "ok_read_rps": 252.66666666666666, "ok_rps": 513.2666666666667, "ok_write_rps": 260.6, "rate": 0, "read_ms": {"max": 246.963, "p50": 37.216, "p95": 109.495, "p99": 151.743}, "requests": 7699, "timestamp": "2026-10-23T23:36:04Z", "warmup_s": 3, "write_ms": {"max": 2593.861, "p50": 139.415, "p95": 572.154, "p99": 1031.392}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.0, "cpu_pct_max_per_container": 22.2, "cpu_utilization_of_limit": 0.38, "mem_max_mib": 66.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.6, "cpu_pct_max_per_container": 9.2, "cpu_utilization_of_limit": 0.173, "mem_max_mib": 11.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 62.8, "cpu_pct_max_per_container": 67.9, "cpu_utilization_of_limit": 0.628, "mem_max_mib": 316.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 9.3, "cpu_pct_max_per_container": 12.2, "cpu_utilization_of_limit": 0.186, "mem_max_mib": 71.6}, "postgres_connections": {"active_max": 53, "active_mean": 44.8, "total_max": 80}}, "pool": {"acquires": 25939, "empty_acquire_ratio": 0.1466, "avg_acquire_wait_ms": 1.574, "pool_max_conns_total": 80}} {"series": "E_scale_out_after_fix", "config": "4x0.50", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "version", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323964928"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"341f1c584d37": 1980, "45a6a0e6d809": 1979, "4770041f3a94": 1979, "8e63a84dfe7b": 1975}, "label": "E_scale_out_after_fix/4x0.50", "latency_ms": {"max": 1989.892, "p50": 78.118, "p95": 375.37, "p99": 652.649}, "mode": "closed", "ok": 7913, "ok_read_rps": 265.6, "ok_rps": 527.5333333333333, "ok_write_rps": 261.93333333333334, "rate": 0, "read_ms": {"max": 338.686, "p50": 40.634, "p95": 121.587, "p99": 171.549}, "requests": 7913, "timestamp": "2026-10-23T23:36:25Z", "warmup_s": 3, "write_ms": {"max": 1989.892, "p50": 145.256, "p95": 493.903, "p99": 829.45}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.7, "cpu_pct_max_per_container": 22.0, "cpu_utilization_of_limit": 0.373, "mem_max_mib": 66.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 8.6, "cpu_pct_max_per_container": 9.0, "cpu_utilization_of_limit": 0.171, "mem_max_mib": 11.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 60.7, "cpu_pct_max_per_container": 62.4, "cpu_utilization_of_limit": 0.607, "mem_max_mib": 319.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 13.8, "cpu_pct_max_per_container": 25.9, "cpu_utilization_of_limit": 0.277, "mem_max_mib": 74.8}, "postgres_connections": {"active_max": 59, "active_mean": 37, "total_max": 80}}, "pool": {"acquires": 27161, "empty_acquire_ratio": 0.0764, "avg_acquire_wait_ms": 0.568, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"3cbe08111059": 1305, "6487d88d9bd5": 1303, "7b6ba6e8db1a": 1304, "d10ca452a699": 1301}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 193.555, "p50": 28.068, "p95": 111.852, "p99": 143.319}, "mode": "closed", "ok": 5213, "ok_read_rps": 175.06666666666666, "ok_rps": 347.53333333333336, "ok_write_rps": 172.46666666666667, "rate": 0, "read_ms": {"max": 64.384, "p50": 5.603, "p95": 15.949, "p99": 27.909}, "requests": 5213, "timestamp": "2026-10-23T23:42:40Z", "warmup_s": 3, "write_ms": {"max": 193.555, "p50": 82.514, "p95": 124.936, "p99": 157.536}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 18.7, "cpu_pct_max_per_container": 20.5, "cpu_utilization_of_limit": 0.375, "mem_max_mib": 138.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.099, "mem_max_mib": 10.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.7, "cpu_pct_max_per_container": 23.7, "cpu_utilization_of_limit": 0.217, "mem_max_mib": 76.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.3, "cpu_pct_max_per_container": 51.1, "cpu_utilization_of_limit": 1.006, "mem_max_mib": 11.4}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 22}}, "pool": {"acquires": 17552, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.023, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"3cbe08111059": 1182, "6487d88d9bd5": 1180, "7b6ba6e8db1a": 1183, "d10ca452a699": 1182}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 235.946, "p50": 50.806, "p95": 120.496, "p99": 159.111}, "mode": "closed", "ok": 4727, "ok_read_rps": 154.46666666666667, "ok_rps": 315.1333333333333, "ok_write_rps": 160.66666666666666, "rate": 0, "read_ms": {"max": 54.819, "p50": 5.755, "p95": 16.351, "p99": 28.919}, "requests": 4727, "timestamp": "2026-10-23T23:43:00Z", "warmup_s": 3, "write_ms": {"max": 235.946, "p50": 89.646, "p95": 137.233, "p99": 176.752}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 17.8, "cpu_pct_max_per_container": 22.0, "cpu_utilization_of_limit": 0.356, "mem_max_mib": 252.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.093, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.8, "cpu_pct_max_per_container": 21.7, "cpu_utilization_of_limit": 0.198, "mem_max_mib": 86.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.2, "cpu_pct_max_per_container": 51.4, "cpu_utilization_of_limit": 1.003, "mem_max_mib": 11.2}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 23}}, "pool": {"acquires": 16611, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"3cbe08111059": 1355, "6487d88d9bd5": 1353, "7b6ba6e8db1a": 1354, "d10ca452a699": 1352}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 228.735, "p50": 39.425, "p95": 109.425, "p99": 143.118}, "mode": "closed", "ok": 5414, "ok_read_rps": 177.66666666666666, "ok_rps": 360.93333333333334, "ok_write_rps": 183.26666666666668, "rate": 0, "read_ms": {"max": 87.69, "p50": 5.216, "p95": 15.182, "p99": 23.804}, "requests": 5414, "timestamp": "2026-10-23T23:43:21Z", "warmup_s": 3, "write_ms": {"max": 228.735, "p50": 77.318, "p95": 123.398, "p99": 160.955}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.0, "cpu_pct_max_per_container": 22.2, "cpu_utilization_of_limit": 0.399, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.098, "mem_max_mib": 10.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 22.6, "cpu_utilization_of_limit": 0.213, "mem_max_mib": 94.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.6, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 0.993, "mem_max_mib": 11.2}, "postgres_connections": {"active_max": 2, "active_mean": 0.3, "total_max": 25}}, "pool": {"acquires": 18968, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.004, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 3, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"3cbe08111059": 1337, "6487d88d9bd5": 1342, "7b6ba6e8db1a": 1339, "d10ca452a699": 1335}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 237.543, "p50": 41.472, "p95": 109.367, "p99": 142.28}, "mode": "closed", "ok": 5353, "ok_read_rps": 175.73333333333332, "ok_rps": 356.8666666666667, "ok_write_rps": 181.13333333333333, "rate": 0, "read_ms": {"max": 66.943, "p50": 5.265, "p95": 16.475, "p99": 28.382}, "requests": 5353, "timestamp": "2026-10-23T23:43:42Z", "warmup_s": 3, "write_ms": {"max": 237.543, "p50": 77.814, "p95": 122.834, "p99": 168.573}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.5, "cpu_pct_max_per_container": 22.2, "cpu_utilization_of_limit": 0.39, "mem_max_mib": 255.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 10.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.7, "cpu_pct_max_per_container": 34.9, "cpu_utilization_of_limit": 0.227, "mem_max_mib": 100.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 1.0, "mem_max_mib": 11.8}, "postgres_connections": {"active_max": 16, "active_mean": 2.6, "total_max": 26}}, "pool": {"acquires": 18513, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 16, "repeat": 4, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"3cbe08111059": 1520, "6487d88d9bd5": 1520, "7b6ba6e8db1a": 1519, "d10ca452a699": 1518}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 151.594, "p50": 32.275, "p95": 95.004, "p99": 121.781}, "mode": "closed", "ok": 6077, "ok_read_rps": 200.93333333333334, "ok_rps": 405.1333333333333, "ok_write_rps": 204.2, "rate": 0, "read_ms": {"max": 50.952, "p50": 4.942, "p95": 14.614, "p99": 24.716}, "requests": 6077, "timestamp": "2026-10-23T23:44:02Z", "warmup_s": 3, "write_ms": {"max": 151.594, "p50": 69.328, "p95": 106.875, "p99": 128.91}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.9, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.438, "mem_max_mib": 252.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.099, "mem_max_mib": 10.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 19.9, "cpu_pct_max_per_container": 22.4, "cpu_utilization_of_limit": 0.199, "mem_max_mib": 103.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.2, "cpu_pct_max_per_container": 50.2, "cpu_utilization_of_limit": 0.985, "mem_max_mib": 11.9}, "postgres_connections": {"active_max": 2, "active_mean": 0.4, "total_max": 26}}, "pool": {"acquires": 20753, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"3cbe08111059": 1587, "6487d88d9bd5": 1591, "7b6ba6e8db1a": 1586, "d10ca452a699": 1591}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 661.425, "p50": 176.467, "p95": 346.643, "p99": 406.06}, "mode": "closed", "ok": 6355, "ok_read_rps": 209.2, "ok_rps": 423.6666666666667, "ok_write_rps": 214.46666666666667, "rate": 0, "read_ms": {"max": 243.047, "p50": 13.007, "p95": 35.414, "p99": 78.72}, "requests": 6355, "timestamp": "2026-10-23T23:44:22Z", "warmup_s": 3, "write_ms": {"max": 661.425, "p50": 276.276, "p95": 369.348, "p99": 427.91}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.7, "cpu_pct_max_per_container": 24.1, "cpu_utilization_of_limit": 0.414, "mem_max_mib": 249.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 12.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.3, "cpu_pct_max_per_container": 30.1, "cpu_utilization_of_limit": 0.243, "mem_max_mib": 232.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.6, "cpu_pct_max_per_container": 49.5, "cpu_utilization_of_limit": 0.973, "mem_max_mib": 13.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 79}}, "pool": {"acquires": 21302, "empty_acquire_ratio": 0.0054, "avg_acquire_wait_ms": 0.863, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"3cbe08111059": 1477, "6487d88d9bd5": 1479, "7b6ba6e8db1a": 1481, "d10ca452a699": 1456}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 656.959, "p50": 98.618, "p95": 390.392, "p99": 481.383}, "mode": "closed", "ok": 5893, "ok_read_rps": 197.2, "ok_rps": 392.8666666666667, "ok_write_rps": 195.66666666666666, "rate": 0, "read_ms": {"max": 231.976, "p50": 13.544, "p95": 34.812, "p99": 67.972}, "requests": 5893, "timestamp": "2026-10-23T23:44:43Z", "warmup_s": 3, "write_ms": {"max": 656.959, "p50": 299.125, "p95": 426.888, "p99": 512.044}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.3, "cpu_pct_max_per_container": 23.2, "cpu_utilization_of_limit": 0.406, "mem_max_mib": 68.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 25.6, "cpu_pct_max_per_container": 41.2, "cpu_utilization_of_limit": 0.256, "mem_max_mib": 239.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.3, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 0.987, "mem_max_mib": 13.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 80}}, "pool": {"acquires": 20382, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.002, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"3cbe08111059": 1560, "6487d88d9bd5": 1566, "7b6ba6e8db1a": 1560, "d10ca452a699": 1569}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 506.331, "p50": 42.525, "p95": 360.611, "p99": 421.561}, "mode": "closed", "ok": 6255, "ok_read_rps": 210.26666666666668, "ok_rps": 417, "ok_write_rps": 206.73333333333332, "rate": 0, "read_ms": {"max": 80.611, "p50": 13.065, "p95": 30.334, "p99": 41.016}, "requests": 6255, "timestamp": "2026-10-23T23:45:03Z", "warmup_s": 3, "write_ms": {"max": 506.331, "p50": 283.511, "p95": 388.475, "p99": 440.36}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.6, "cpu_pct_max_per_container": 23.0, "cpu_utilization_of_limit": 0.413, "mem_max_mib": 67.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.102, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.9, "cpu_pct_max_per_container": 24.3, "cpu_utilization_of_limit": 0.219, "mem_max_mib": 236.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.3, "cpu_pct_max_per_container": 50.5, "cpu_utilization_of_limit": 0.986, "mem_max_mib": 13.1}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 79}}, "pool": {"acquires": 21566, "empty_acquire_ratio": 0.0003, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 3, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"3cbe08111059": 1551, "6487d88d9bd5": 1527, "7b6ba6e8db1a": 1545, "d10ca452a699": 1547}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 473.366, "p50": 178.899, "p95": 359.483, "p99": 425.983}, "mode": "closed", "ok": 6170, "ok_read_rps": 204.26666666666668, "ok_rps": 411.3333333333333, "ok_write_rps": 207.06666666666666, "rate": 0, "read_ms": {"max": 77.777, "p50": 12.901, "p95": 29.232, "p99": 41.118}, "requests": 6170, "timestamp": "2026-10-23T23:45:23Z", "warmup_s": 3, "write_ms": {"max": 473.366, "p50": 286.832, "p95": 389.129, "p99": 439.266}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.5, "cpu_pct_max_per_container": 22.8, "cpu_utilization_of_limit": 0.41, "mem_max_mib": 72.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.2, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.103, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.9, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.219, "mem_max_mib": 240.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.9, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.998, "mem_max_mib": 13.1}, "postgres_connections": {"active_max": 2, "active_mean": 0.3, "total_max": 79}}, "pool": {"acquires": 21502, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg1_lb0.5_redis0.5", "concurrency": 64, "repeat": 4, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"3cbe08111059": 1378, "6487d88d9bd5": 1389, "7b6ba6e8db1a": 1383, "d10ca452a699": 1381}, "label": "C_shared_resources/pg1_lb0.5_redis0.5", "latency_ms": {"max": 853.36, "p50": 119.172, "p95": 430.907, "p99": 547.265}, "mode": "closed", "ok": 5531, "ok_read_rps": 185.33333333333334, "ok_rps": 368.73333333333335, "ok_write_rps": 183.4, "rate": 0, "read_ms": {"max": 254.033, "p50": 18.105, "p95": 79.219, "p99": 142.065}, "requests": 5531, "timestamp": "2026-10-23T23:45:44Z", "warmup_s": 3, "write_ms": {"max": 853.36, "p50": 305.673, "p95": 475.857, "p99": 588.68}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 19.3, "cpu_pct_max_per_container": 21.7, "cpu_utilization_of_limit": 0.386, "mem_max_mib": 64.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.092, "mem_max_mib": 12.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 27.3, "cpu_pct_max_per_container": 45.9, "cpu_utilization_of_limit": 0.273, "mem_max_mib": 244.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.1, "cpu_pct_max_per_container": 51.0, "cpu_utilization_of_limit": 0.962, "mem_max_mib": 13.2}, "postgres_connections": {"active_max": 33, "active_mean": 4.9, "total_max": 79}}, "pool": {"acquires": 19657, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1597, "b201667f0488": 1600, "ceac3545a6f4": 1601, "ffe44b74e740": 1599}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 191.809, "p50": 28.612, "p95": 89.154, "p99": 107.545}, "mode": "closed", "ok": 6397, "ok_read_rps": 212.46666666666667, "ok_rps": 426.46666666666664, "ok_write_rps": 214, "rate": 0, "read_ms": {"max": 79.524, "p50": 4.604, "p95": 15.91, "p99": 27.71}, "requests": 6397, "timestamp": "2026-10-23T23:46:22Z", "warmup_s": 3, "write_ms": {"max": 191.809, "p50": 66.667, "p95": 96.95, "p99": 117.908}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.9, "cpu_pct_max_per_container": 23.9, "cpu_utilization_of_limit": 0.437, "mem_max_mib": 138.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.094, "mem_max_mib": 12.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.3, "cpu_pct_max_per_container": 28.5, "cpu_utilization_of_limit": 0.116, "mem_max_mib": 94.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.3, "cpu_pct_max_per_container": 49.2, "cpu_utilization_of_limit": 0.946, "mem_max_mib": 13.0}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 27}}, "pool": {"acquires": 22018, "empty_acquire_ratio": 0.0009, "avg_acquire_wait_ms": 0.052, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1644, "b201667f0488": 1645, "ceac3545a6f4": 1642, "ffe44b74e740": 1642}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 146.288, "p50": 22.201, "p95": 87.276, "p99": 100.623}, "mode": "closed", "ok": 6573, "ok_read_rps": 220.8, "ok_rps": 438.2, "ok_write_rps": 217.4, "rate": 0, "read_ms": {"max": 48.064, "p50": 4.494, "p95": 12.841, "p99": 21.923}, "requests": 6573, "timestamp": "2026-10-23T23:46:41Z", "warmup_s": 3, "write_ms": {"max": 146.288, "p50": 66.585, "p95": 94.181, "p99": 106.126}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.1, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.441, "mem_max_mib": 253.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.098, "mem_max_mib": 12.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.7, "cpu_pct_max_per_container": 41.9, "cpu_utilization_of_limit": 0.123, "mem_max_mib": 108.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.5, "cpu_pct_max_per_container": 49.1, "cpu_utilization_of_limit": 0.95, "mem_max_mib": 12.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 27}}, "pool": {"acquires": 22769, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1597, "b201667f0488": 1594, "ceac3545a6f4": 1597, "ffe44b74e740": 1592}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 578.851, "p50": 28.964, "p95": 87.534, "p99": 112.439}, "mode": "closed", "ok": 6380, "ok_read_rps": 211.46666666666667, "ok_rps": 425.3333333333333, "ok_write_rps": 213.86666666666667, "rate": 0, "read_ms": {"max": 117.962, "p50": 4.527, "p95": 15.496, "p99": 25.85}, "requests": 6380, "timestamp": "2026-10-23T23:47:01Z", "warmup_s": 3, "write_ms": {"max": 578.851, "p50": 65.012, "p95": 96.767, "p99": 126.358}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.1, "cpu_pct_max_per_container": 25.6, "cpu_utilization_of_limit": 0.443, "mem_max_mib": 255.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 12.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.8, "cpu_pct_max_per_container": 23.5, "cpu_utilization_of_limit": 0.109, "mem_max_mib": 104.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.0, "cpu_pct_max_per_container": 49.4, "cpu_utilization_of_limit": 0.959, "mem_max_mib": 12.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 27}}, "pool": {"acquires": 22058, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 3, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1604, "b201667f0488": 1605, "ceac3545a6f4": 1606, "ffe44b74e740": 1601}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 248.505, "p50": 30.527, "p95": 90.435, "p99": 114.918}, "mode": "closed", "ok": 6416, "ok_read_rps": 212.73333333333332, "ok_rps": 427.73333333333335, "ok_write_rps": 215, "rate": 0, "read_ms": {"max": 43.949, "p50": 4.767, "p95": 13.799, "p99": 22.621}, "requests": 6416, "timestamp": "2026-10-23T23:47:21Z", "warmup_s": 3, "write_ms": {"max": 248.505, "p50": 65.474, "p95": 101.281, "p99": 125.47}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.4, "cpu_pct_max_per_container": 24.5, "cpu_utilization_of_limit": 0.448, "mem_max_mib": 248.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 12.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.1, "cpu_pct_max_per_container": 24.6, "cpu_utilization_of_limit": 0.11, "mem_max_mib": 103.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.4, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 0.988, "mem_max_mib": 13.0}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 27}}, "pool": {"acquires": 22148, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 16, "repeat": 4, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1607, "b201667f0488": 1607, "ceac3545a6f4": 1610, "ffe44b74e740": 1606}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 135.459, "p50": 31.738, "p95": 89.469, "p99": 110.207}, "mode": "closed", "ok": 6430, "ok_read_rps": 211.66666666666666, "ok_rps": 428.6666666666667, "ok_write_rps": 217, "rate": 0, "read_ms": {"max": 73.901, "p50": 4.501, "p95": 13.283, "p99": 22.634}, "requests": 6430, "timestamp": "2026-10-23T23:47:42Z", "warmup_s": 3, "write_ms": {"max": 135.459, "p50": 66.052, "p95": 98.831, "p99": 114.571}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 24.9, "cpu_utilization_of_limit": 0.444, "mem_max_mib": 254.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.096, "mem_max_mib": 12.4}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.0, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.11, "mem_max_mib": 106.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.6, "cpu_pct_max_per_container": 50.2, "cpu_utilization_of_limit": 0.971, "mem_max_mib": 19.7}, "postgres_connections": {"active_max": 2, "active_mean": 0.4, "total_max": 28}}, "pool": {"acquires": 22314, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1742, "b201667f0488": 1744, "ceac3545a6f4": 1748, "ffe44b74e740": 1751}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 456.341, "p50": 91.033, "p95": 308.634, "p99": 355.235}, "mode": "closed", "ok": 6985, "ok_read_rps": 233.06666666666666, "ok_rps": 465.6666666666667, "ok_write_rps": 232.6, "rate": 0, "read_ms": {"max": 289.387, "p50": 11.705, "p95": 27.847, "p99": 42.863}, "requests": 6985, "timestamp": "2026-10-23T23:48:02Z", "warmup_s": 3, "write_ms": {"max": 456.341, "p50": 257.599, "p95": 328.51, "p99": 367.45}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 24.1, "cpu_utilization_of_limit": 0.426, "mem_max_mib": 246.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.099, "mem_max_mib": 12.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.0, "cpu_pct_max_per_container": 25.5, "cpu_utilization_of_limit": 0.115, "mem_max_mib": 224.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.3, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 0.967, "mem_max_mib": 14.1}, "postgres_connections": {"active_max": 4, "active_mean": 0.7, "total_max": 76}}, "pool": {"acquires": 23545, "empty_acquire_ratio": 0.0034, "avg_acquire_wait_ms": 0.653, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1682, "b201667f0488": 1675, "ceac3545a6f4": 1678, "ffe44b74e740": 1672}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 589.494, "p50": 183.264, "p95": 319.482, "p99": 413.862}, "mode": "closed", "ok": 6707, "ok_read_rps": 221.66666666666666, "ok_rps": 447.1333333333333, "ok_write_rps": 225.46666666666667, "rate": 0, "read_ms": {"max": 70.435, "p50": 11.873, "p95": 26.49, "p99": 39.674}, "requests": 6707, "timestamp": "2026-10-23T23:48:24Z", "warmup_s": 3, "write_ms": {"max": 589.494, "p50": 261.184, "p95": 350.023, "p99": 518.07}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.1, "cpu_pct_max_per_container": 23.9, "cpu_utilization_of_limit": 0.423, "mem_max_mib": 100.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.5, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 12.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.5, "cpu_pct_max_per_container": 25.8, "cpu_utilization_of_limit": 0.117, "mem_max_mib": 228.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.0, "cpu_pct_max_per_container": 50.2, "cpu_utilization_of_limit": 0.98, "mem_max_mib": 14.2}, "postgres_connections": {"active_max": 2, "active_mean": 0.4, "total_max": 76}}, "pool": {"acquires": 23095, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1728, "b201667f0488": 1721, "ceac3545a6f4": 1722, "ffe44b74e740": 1722}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 493.264, "p50": 181.001, "p95": 321.426, "p99": 376.062}, "mode": "closed", "ok": 6893, "ok_read_rps": 226.86666666666667, "ok_rps": 459.53333333333336, "ok_write_rps": 232.66666666666666, "rate": 0, "read_ms": {"max": 66.819, "p50": 11.429, "p95": 25.278, "p99": 37.621}, "requests": 6893, "timestamp": "2026-10-23T23:48:46Z", "warmup_s": 3, "write_ms": {"max": 493.264, "p50": 253.646, "p95": 346.516, "p99": 389.463}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.2, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.425, "mem_max_mib": 62.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 12.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.1, "cpu_pct_max_per_container": 25.8, "cpu_utilization_of_limit": 0.116, "mem_max_mib": 235.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.2, "cpu_pct_max_per_container": 50.8, "cpu_utilization_of_limit": 0.983, "mem_max_mib": 14.2}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 77}}, "pool": {"acquires": 23393, "empty_acquire_ratio": 0.0032, "avg_acquire_wait_ms": 0.038, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 3, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1775, "b201667f0488": 1770, "ceac3545a6f4": 1773, "ffe44b74e740": 1775}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 477.533, "p50": 96.363, "p95": 302.26, "p99": 351.285}, "mode": "closed", "ok": 7093, "ok_read_rps": 236.73333333333332, "ok_rps": 472.8666666666667, "ok_write_rps": 236.13333333333333, "rate": 0, "read_ms": {"max": 110.712, "p50": 11.556, "p95": 26.779, "p99": 41.984}, "requests": 7093, "timestamp": "2026-10-23T23:49:06Z", "warmup_s": 3, "write_ms": {"max": 477.533, "p50": 252.572, "p95": 317.593, "p99": 375.454}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.2, "cpu_pct_max_per_container": 23.3, "cpu_utilization_of_limit": 0.424, "mem_max_mib": 61.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 12.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.1, "cpu_pct_max_per_container": 25.1, "cpu_utilization_of_limit": 0.115, "mem_max_mib": 238.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.5, "cpu_pct_max_per_container": 50.3, "cpu_utilization_of_limit": 0.969, "mem_max_mib": 14.4}, "postgres_connections": {"active_max": 2, "active_mean": 0.6, "total_max": 77}}, "pool": {"acquires": 24540, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "pg2", "concurrency": 64, "repeat": 4, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "2.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1654, "b201667f0488": 1660, "ceac3545a6f4": 1660, "ffe44b74e740": 1661}, "label": "C_shared_resources/pg2", "latency_ms": {"max": 459.558, "p50": 146.154, "p95": 343.472, "p99": 390.285}, "mode": "closed", "ok": 6635, "ok_read_rps": 220.46666666666667, "ok_rps": 442.3333333333333, "ok_write_rps": 221.86666666666667, "rate": 0, "read_ms": {"max": 99.196, "p50": 12.217, "p95": 29.354, "p99": 44.191}, "requests": 6635, "timestamp": "2026-10-23T23:49:26Z", "warmup_s": 3, "write_ms": {"max": 459.558, "p50": 265.81, "p95": 366.864, "p99": 415.182}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.2, "cpu_pct_max_per_container": 24.8, "cpu_utilization_of_limit": 0.423, "mem_max_mib": 61.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.103, "mem_max_mib": 13.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.9, "cpu_pct_max_per_container": 25.6, "cpu_utilization_of_limit": 0.12, "mem_max_mib": 242.1}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.8, "cpu_pct_max_per_container": 50.3, "cpu_utilization_of_limit": 0.975, "mem_max_mib": 14.4}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 77}}, "pool": {"acquires": 23104, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1593, "b201667f0488": 1593, "ceac3545a6f4": 1592, "ffe44b74e740": 1597}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 138.614, "p50": 30.907, "p95": 91.714, "p99": 108.298}, "mode": "closed", "ok": 6375, "ok_read_rps": 210.66666666666666, "ok_rps": 425, "ok_write_rps": 214.33333333333334, "rate": 0, "read_ms": {"max": 39.353, "p50": 4.437, "p95": 12.732, "p99": 21.346}, "requests": 6375, "timestamp": "2026-10-23T23:49:55Z", "warmup_s": 3, "write_ms": {"max": 138.614, "p50": 66.771, "p95": 99.519, "p99": 115.328}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.0, "cpu_pct_max_per_container": 24.7, "cpu_utilization_of_limit": 0.441, "mem_max_mib": 232.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.047, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 22.4, "cpu_utilization_of_limit": 0.213, "mem_max_mib": 86.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.8, "cpu_pct_max_per_container": 50.1, "cpu_utilization_of_limit": 0.957, "mem_max_mib": 13.8}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 24}}, "pool": {"acquires": 21939, "empty_acquire_ratio": 0.0009, "avg_acquire_wait_ms": 0.051, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1579, "b201667f0488": 1581, "ceac3545a6f4": 1578, "ffe44b74e740": 1582}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 161.675, "p50": 29.03, "p95": 93.185, "p99": 114.843}, "mode": "closed", "ok": 6320, "ok_read_rps": 209.46666666666667, "ok_rps": 421.3333333333333, "ok_write_rps": 211.86666666666667, "rate": 0, "read_ms": {"max": 54.503, "p50": 4.651, "p95": 13.017, "p99": 22.388}, "requests": 6320, "timestamp": "2026-10-23T23:50:14Z", "warmup_s": 3, "write_ms": {"max": 161.675, "p50": 67.108, "p95": 101.679, "p99": 120.698}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.0, "cpu_pct_max_per_container": 24.1, "cpu_utilization_of_limit": 0.44, "mem_max_mib": 230.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.048, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.7, "cpu_pct_max_per_container": 26.6, "cpu_utilization_of_limit": 0.227, "mem_max_mib": 95.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.2, "cpu_pct_max_per_container": 50.4, "cpu_utilization_of_limit": 0.964, "mem_max_mib": 17.1}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 26}}, "pool": {"acquires": 21781, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.003, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1641, "b201667f0488": 1640, "ceac3545a6f4": 1636, "ffe44b74e740": 1636}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 139.351, "p50": 19.114, "p95": 89.622, "p99": 108.012}, "mode": "closed", "ok": 6553, "ok_read_rps": 222.2, "ok_rps": 436.8666666666667, "ok_write_rps": 214.66666666666666, "rate": 0, "read_ms": {"max": 46.456, "p50": 4.63, "p95": 14.263, "p99": 22.925}, "requests": 6553, "timestamp": "2026-10-23T23:50:34Z", "warmup_s": 3, "write_ms": {"max": 139.351, "p50": 66.282, "p95": 98.663, "p99": 116.365}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.1, "cpu_pct_max_per_container": 24.2, "cpu_utilization_of_limit": 0.442, "mem_max_mib": 232.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.049, "mem_max_mib": 8.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 25.4, "cpu_utilization_of_limit": 0.222, "mem_max_mib": 99.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.8, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 0.996, "mem_max_mib": 13.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.4, "total_max": 26}}, "pool": {"acquires": 22282, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 3, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1642, "b201667f0488": 1640, "ceac3545a6f4": 1640, "ffe44b74e740": 1644}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 148.2, "p50": 30.416, "p95": 87.523, "p99": 104.8}, "mode": "closed", "ok": 6566, "ok_read_rps": 216.86666666666667, "ok_rps": 437.73333333333335, "ok_write_rps": 220.86666666666667, "rate": 0, "read_ms": {"max": 46.356, "p50": 4.496, "p95": 12.906, "p99": 21.358}, "requests": 6566, "timestamp": "2026-10-23T23:50:55Z", "warmup_s": 3, "write_ms": {"max": 148.2, "p50": 64.732, "p95": 96.583, "p99": 113.076}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.0, "cpu_pct_max_per_container": 24.1, "cpu_utilization_of_limit": 0.44, "mem_max_mib": 227.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.048, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.2, "cpu_pct_max_per_container": 23.2, "cpu_utilization_of_limit": 0.212, "mem_max_mib": 103.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.1, "cpu_pct_max_per_container": 50.3, "cpu_utilization_of_limit": 0.983, "mem_max_mib": 13.4}, "postgres_connections": {"active_max": 2, "active_mean": 0.6, "total_max": 26}}, "pool": {"acquires": 22640, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 16, "repeat": 4, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1564, "b201667f0488": 1564, "ceac3545a6f4": 1563, "ffe44b74e740": 1562}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 226.049, "p50": 34.132, "p95": 91.484, "p99": 114.895}, "mode": "closed", "ok": 6253, "ok_read_rps": 206.93333333333334, "ok_rps": 416.8666666666667, "ok_write_rps": 209.93333333333334, "rate": 0, "read_ms": {"max": 118.23, "p50": 4.974, "p95": 15.107, "p99": 27.431}, "requests": 6253, "timestamp": "2026-10-23T23:51:15Z", "warmup_s": 3, "write_ms": {"max": 226.049, "p50": 67.444, "p95": 102.05, "p99": 120.881}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.5, "cpu_pct_max_per_container": 24.7, "cpu_utilization_of_limit": 0.43, "mem_max_mib": 232.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.047, "mem_max_mib": 9.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 25.3, "cpu_pct_max_per_container": 45.1, "cpu_utilization_of_limit": 0.253, "mem_max_mib": 106.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.6, "cpu_pct_max_per_container": 50.9, "cpu_utilization_of_limit": 0.973, "mem_max_mib": 13.5}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 26}}, "pool": {"acquires": 21639, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1676, "b201667f0488": 1673, "ceac3545a6f4": 1666, "ffe44b74e740": 1662}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 447.843, "p50": 184.913, "p95": 328.605, "p99": 371.129}, "mode": "closed", "ok": 6677, "ok_read_rps": 218.6, "ok_rps": 445.1333333333333, "ok_write_rps": 226.53333333333333, "rate": 0, "read_ms": {"max": 82.72, "p50": 12.02, "p95": 26.788, "p99": 40.934}, "requests": 6677, "timestamp": "2026-10-23T23:51:35Z", "warmup_s": 3, "write_ms": {"max": 447.843, "p50": 264.492, "p95": 348.07, "p99": 381.754}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.1, "cpu_pct_max_per_container": 24.1, "cpu_utilization_of_limit": 0.422, "mem_max_mib": 235.9}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.8, "cpu_utilization_of_limit": 0.051, "mem_max_mib": 10.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.0, "cpu_pct_max_per_container": 26.8, "cpu_utilization_of_limit": 0.24, "mem_max_mib": 227.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.7, "cpu_pct_max_per_container": 50.4, "cpu_utilization_of_limit": 0.974, "mem_max_mib": 14.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 77}}, "pool": {"acquires": 22708, "empty_acquire_ratio": 0.0034, "avg_acquire_wait_ms": 0.933, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1572, "b201667f0488": 1575, "ceac3545a6f4": 1586, "ffe44b74e740": 1572}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 497.078, "p50": 206.931, "p95": 345.977, "p99": 405.832}, "mode": "closed", "ok": 6305, "ok_read_rps": 206.8, "ok_rps": 420.3333333333333, "ok_write_rps": 213.53333333333333, "rate": 0, "read_ms": {"max": 87.649, "p50": 12.731, "p95": 27.836, "p99": 43.651}, "requests": 6305, "timestamp": "2026-10-23T23:51:55Z", "warmup_s": 3, "write_ms": {"max": 497.078, "p50": 281.649, "p95": 368.45, "p99": 425.36}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.7, "cpu_pct_max_per_container": 22.4, "cpu_utilization_of_limit": 0.414, "mem_max_mib": 78.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.6, "cpu_utilization_of_limit": 0.051, "mem_max_mib": 10.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.9, "cpu_pct_max_per_container": 26.2, "cpu_utilization_of_limit": 0.239, "mem_max_mib": 236.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.8, "cpu_pct_max_per_container": 50.6, "cpu_utilization_of_limit": 0.997, "mem_max_mib": 14.5}, "postgres_connections": {"active_max": 2, "active_mean": 0.4, "total_max": 77}}, "pool": {"acquires": 22014, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1630, "b201667f0488": 1626, "ceac3545a6f4": 1628, "ffe44b74e740": 1621}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 724.332, "p50": 94.088, "p95": 341.624, "p99": 398.281}, "mode": "closed", "ok": 6505, "ok_read_rps": 218.66666666666666, "ok_rps": 433.6666666666667, "ok_write_rps": 215, "rate": 0, "read_ms": {"max": 246.347, "p50": 12.311, "p95": 37.842, "p99": 93.128}, "requests": 6505, "timestamp": "2026-10-23T23:52:17Z", "warmup_s": 3, "write_ms": {"max": 724.332, "p50": 273.129, "p95": 365.962, "p99": 450.081}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.1, "cpu_pct_max_per_container": 23.0, "cpu_utilization_of_limit": 0.422, "mem_max_mib": 55.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.051, "mem_max_mib": 10.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.8, "cpu_pct_max_per_container": 26.5, "cpu_utilization_of_limit": 0.238, "mem_max_mib": 239.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.5, "cpu_pct_max_per_container": 50.2, "cpu_utilization_of_limit": 0.971, "mem_max_mib": 14.4}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 79}}, "pool": {"acquires": 22537, "empty_acquire_ratio": 0.0006, "avg_acquire_wait_ms": 0.004, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 3, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1661, "b201667f0488": 1660, "ceac3545a6f4": 1662, "ffe44b74e740": 1661}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 449.817, "p50": 146.462, "p95": 332.928, "p99": 382.361}, "mode": "closed", "ok": 6644, "ok_read_rps": 219.86666666666667, "ok_rps": 442.93333333333334, "ok_write_rps": 223.06666666666666, "rate": 0, "read_ms": {"max": 87.02, "p50": 12.442, "p95": 30.883, "p99": 46.862}, "requests": 6644, "timestamp": "2026-10-23T23:52:37Z", "warmup_s": 3, "write_ms": {"max": 449.817, "p50": 271.07, "p95": 355.931, "p99": 392.782}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.7, "cpu_pct_max_per_container": 22.6, "cpu_utilization_of_limit": 0.415, "mem_max_mib": 56.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.049, "mem_max_mib": 10.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 24.6, "cpu_pct_max_per_container": 28.4, "cpu_utilization_of_limit": 0.246, "mem_max_mib": 243.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.3, "cpu_pct_max_per_container": 49.8, "cpu_utilization_of_limit": 0.966, "mem_max_mib": 14.4}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 78}}, "pool": {"acquires": 23069, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "lb1", "concurrency": 64, "repeat": 4, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "1.00", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1700, "b201667f0488": 1699, "ceac3545a6f4": 1708, "ffe44b74e740": 1709}, "label": "C_shared_resources/lb1", "latency_ms": {"max": 491.215, "p50": 176.926, "p95": 323.207, "p99": 379.283}, "mode": "closed", "ok": 6816, "ok_read_rps": 222.33333333333334, "ok_rps": 454.4, "ok_write_rps": 232.06666666666666, "rate": 0, "read_ms": {"max": 88.804, "p50": 11.635, "p95": 29.244, "p99": 47.985}, "requests": 6816, "timestamp": "2026-10-23T23:52:58Z", "warmup_s": 3, "write_ms": {"max": 491.215, "p50": 258.029, "p95": 347.159, "p99": 402.201}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.7, "cpu_pct_max_per_container": 22.3, "cpu_utilization_of_limit": 0.413, "mem_max_mib": 56.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.048, "mem_max_mib": 10.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.0, "cpu_pct_max_per_container": 25.4, "cpu_utilization_of_limit": 0.23, "mem_max_mib": 251.4}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.8, "cpu_pct_max_per_container": 49.6, "cpu_utilization_of_limit": 0.976, "mem_max_mib": 14.6}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 80}}, "pool": {"acquires": 23612, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.005, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1661, "b201667f0488": 1659, "ceac3545a6f4": 1657, "ffe44b74e740": 1659}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 171.145, "p50": 21.406, "p95": 88.391, "p99": 111.23}, "mode": "closed", "ok": 6636, "ok_read_rps": 222.93333333333334, "ok_rps": 442.4, "ok_write_rps": 219.46666666666667, "rate": 0, "read_ms": {"max": 77.386, "p50": 4.626, "p95": 13.315, "p99": 24.031}, "requests": 6636, "timestamp": "2026-10-23T23:53:25Z", "warmup_s": 3, "write_ms": {"max": 171.145, "p50": 64.554, "p95": 99.552, "p99": 122.869}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.4, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.447, "mem_max_mib": 52.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 10.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.4, "cpu_pct_max_per_container": 26.3, "cpu_utilization_of_limit": 0.234, "mem_max_mib": 254.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.0, "cpu_pct_max_per_container": 50.7, "cpu_utilization_of_limit": 0.5, "mem_max_mib": 18.4}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 80}}, "pool": {"acquires": 22849, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1678, "b201667f0488": 1680, "ceac3545a6f4": 1680, "ffe44b74e740": 1679}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 190.765, "p50": 21.489, "p95": 85.066, "p99": 107.823}, "mode": "closed", "ok": 6717, "ok_read_rps": 225.46666666666667, "ok_rps": 447.8, "ok_write_rps": 222.33333333333334, "rate": 0, "read_ms": {"max": 53.019, "p50": 4.1, "p95": 12.3, "p99": 21.605}, "requests": 6717, "timestamp": "2026-10-23T23:53:45Z", "warmup_s": 3, "write_ms": {"max": 190.765, "p50": 64.884, "p95": 94.648, "p99": 117.695}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.443, "mem_max_mib": 52.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.099, "mem_max_mib": 10.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.7, "cpu_pct_max_per_container": 24.8, "cpu_utilization_of_limit": 0.217, "mem_max_mib": 257.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.6, "cpu_pct_max_per_container": 50.1, "cpu_utilization_of_limit": 0.476, "mem_max_mib": 12.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 80}}, "pool": {"acquires": 23029, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1683, "b201667f0488": 1682, "ceac3545a6f4": 1675, "ffe44b74e740": 1677}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 181.465, "p50": 17.27, "p95": 87.981, "p99": 115.154}, "mode": "closed", "ok": 6717, "ok_read_rps": 227.66666666666666, "ok_rps": 447.8, "ok_write_rps": 220.13333333333333, "rate": 0, "read_ms": {"max": 52.578, "p50": 4.18, "p95": 11.65, "p99": 22.759}, "requests": 6717, "timestamp": "2026-10-23T23:54:05Z", "warmup_s": 3, "write_ms": {"max": 181.465, "p50": 65.167, "p95": 99.159, "p99": 125.231}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.4, "cpu_pct_max_per_container": 24.2, "cpu_utilization_of_limit": 0.448, "mem_max_mib": 52.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 10.7}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.4, "cpu_pct_max_per_container": 25.5, "cpu_utilization_of_limit": 0.214, "mem_max_mib": 260.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.4, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 0.484, "mem_max_mib": 13.3}, "postgres_connections": {"active_max": 0, "active_mean": 0, "total_max": 80}}, "pool": {"acquires": 23052, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 3, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1632, "b201667f0488": 1641, "ceac3545a6f4": 1635, "ffe44b74e740": 1635}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 165.441, "p50": 25.027, "p95": 90.106, "p99": 110.795}, "mode": "closed", "ok": 6543, "ok_read_rps": 218.93333333333334, "ok_rps": 436.2, "ok_write_rps": 217.26666666666668, "rate": 0, "read_ms": {"max": 87.293, "p50": 4.364, "p95": 14.591, "p99": 26.083}, "requests": 6543, "timestamp": "2026-10-23T23:54:25Z", "warmup_s": 3, "write_ms": {"max": 165.441, "p50": 66.227, "p95": 100.34, "p99": 118.998}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.3, "cpu_pct_max_per_container": 25.6, "cpu_utilization_of_limit": 0.447, "mem_max_mib": 52.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.095, "mem_max_mib": 10.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.7, "cpu_pct_max_per_container": 25.0, "cpu_utilization_of_limit": 0.217, "mem_max_mib": 263.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.3, "cpu_pct_max_per_container": 52.1, "cpu_utilization_of_limit": 0.483, "mem_max_mib": 12.4}, "postgres_connections": {"active_max": 2, "active_mean": 0.3, "total_max": 80}}, "pool": {"acquires": 22406, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 16, "repeat": 4, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1604, "b201667f0488": 1606, "ceac3545a6f4": 1604, "ffe44b74e740": 1607}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 241.976, "p50": 27.678, "p95": 87.393, "p99": 120.932}, "mode": "closed", "ok": 6421, "ok_read_rps": 213.53333333333333, "ok_rps": 428.06666666666666, "ok_write_rps": 214.53333333333333, "rate": 0, "read_ms": {"max": 49.615, "p50": 4.316, "p95": 13.496, "p99": 24.799}, "requests": 6421, "timestamp": "2026-10-23T23:54:46Z", "warmup_s": 3, "write_ms": {"max": 241.976, "p50": 66.615, "p95": 98.901, "p99": 136.086}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.3, "cpu_pct_max_per_container": 25.4, "cpu_utilization_of_limit": 0.445, "mem_max_mib": 52.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.095, "mem_max_mib": 10.9}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 23.8, "cpu_utilization_of_limit": 0.213, "mem_max_mib": 266.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.3, "cpu_pct_max_per_container": 48.9, "cpu_utilization_of_limit": 0.473, "mem_max_mib": 12.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 80}}, "pool": {"acquires": 22137, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1780, "b201667f0488": 1778, "ceac3545a6f4": 1790, "ffe44b74e740": 1782}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 430.065, "p50": 174.957, "p95": 301.616, "p99": 338.668}, "mode": "closed", "ok": 7130, "ok_read_rps": 235.06666666666666, "ok_rps": 475.3333333333333, "ok_write_rps": 240.26666666666668, "rate": 0, "read_ms": {"max": 95.21, "p50": 10.885, "p95": 23.998, "p99": 40.673}, "requests": 7130, "timestamp": "2026-10-23T23:55:06Z", "warmup_s": 3, "write_ms": {"max": 430.065, "p50": 250.368, "p95": 319.471, "p99": 356.483}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.7, "cpu_pct_max_per_container": 23.5, "cpu_utilization_of_limit": 0.435, "mem_max_mib": 54.4}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.099, "mem_max_mib": 11.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.4, "cpu_pct_max_per_container": 24.3, "cpu_utilization_of_limit": 0.224, "mem_max_mib": 270.5}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.9, "cpu_pct_max_per_container": 52.6, "cpu_utilization_of_limit": 0.499, "mem_max_mib": 13.5}, "postgres_connections": {"active_max": 3, "active_mean": 0.6, "total_max": 80}}, "pool": {"acquires": 25066, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1796, "b201667f0488": 1802, "ceac3545a6f4": 1792, "ffe44b74e740": 1793}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 450.638, "p50": 162.417, "p95": 302.008, "p99": 341.353}, "mode": "closed", "ok": 7183, "ok_read_rps": 235.53333333333333, "ok_rps": 478.8666666666667, "ok_write_rps": 243.33333333333334, "rate": 0, "read_ms": {"max": 88.108, "p50": 11.209, "p95": 25.908, "p99": 41.453}, "requests": 7183, "timestamp": "2026-10-23T23:55:27Z", "warmup_s": 3, "write_ms": {"max": 450.638, "p50": 249.03, "p95": 321.636, "p99": 359.625}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.0, "cpu_pct_max_per_container": 24.6, "cpu_utilization_of_limit": 0.44, "mem_max_mib": 74.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.098, "mem_max_mib": 12.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.9, "cpu_pct_max_per_container": 25.8, "cpu_utilization_of_limit": 0.229, "mem_max_mib": 274.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.6, "cpu_pct_max_per_container": 52.7, "cpu_utilization_of_limit": 0.506, "mem_max_mib": 13.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 80}}, "pool": {"acquires": 24856, "empty_acquire_ratio": 0.001, "avg_acquire_wait_ms": 0.004, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1755, "b201667f0488": 1742, "ceac3545a6f4": 1755, "ffe44b74e740": 1756}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 519.056, "p50": 42.323, "p95": 309.602, "p99": 361.022}, "mode": "closed", "ok": 7008, "ok_read_rps": 236.33333333333334, "ok_rps": 467.2, "ok_write_rps": 230.86666666666667, "rate": 0, "read_ms": {"max": 75.554, "p50": 11.324, "p95": 28.255, "p99": 45.025}, "requests": 7008, "timestamp": "2026-10-23T23:55:47Z", "warmup_s": 3, "write_ms": {"max": 519.056, "p50": 260.315, "p95": 329.804, "p99": 394.129}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.7, "cpu_pct_max_per_container": 25.3, "cpu_utilization_of_limit": 0.434, "mem_max_mib": 63.1}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.1, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 12.2}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.8, "cpu_pct_max_per_container": 25.5, "cpu_utilization_of_limit": 0.228, "mem_max_mib": 277.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.6, "cpu_pct_max_per_container": 51.2, "cpu_utilization_of_limit": 0.486, "mem_max_mib": 13.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 80}}, "pool": {"acquires": 24273, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 3, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1797, "b201667f0488": 1786, "ceac3545a6f4": 1799, "ffe44b74e740": 1787}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 391.618, "p50": 44.717, "p95": 309.527, "p99": 339.627}, "mode": "closed", "ok": 7169, "ok_read_rps": 241.6, "ok_rps": 477.93333333333334, "ok_write_rps": 236.33333333333334, "rate": 0, "read_ms": {"max": 94.147, "p50": 10.995, "p95": 25.454, "p99": 45.857}, "requests": 7169, "timestamp": "2026-10-23T23:56:08Z", "warmup_s": 3, "write_ms": {"max": 391.618, "p50": 254.576, "p95": 324.579, "p99": 355.155}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.7, "cpu_pct_max_per_container": 23.3, "cpu_utilization_of_limit": 0.433, "mem_max_mib": 63.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 12.0}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.9, "cpu_pct_max_per_container": 24.6, "cpu_utilization_of_limit": 0.229, "mem_max_mib": 281.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.9, "cpu_pct_max_per_container": 52.2, "cpu_utilization_of_limit": 0.489, "mem_max_mib": 13.7}, "postgres_connections": {"active_max": 1, "active_mean": 0.6, "total_max": 80}}, "pool": {"acquires": 24731, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "redis1", "concurrency": 64, "repeat": 4, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "1.00", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1793, "b201667f0488": 1793, "ceac3545a6f4": 1793, "ffe44b74e740": 1798}, "label": "C_shared_resources/redis1", "latency_ms": {"max": 384.062, "p50": 152.738, "p95": 306.205, "p99": 341.908}, "mode": "closed", "ok": 7177, "ok_read_rps": 235.66666666666666, "ok_rps": 478.46666666666664, "ok_write_rps": 242.8, "rate": 0, "read_ms": {"max": 77.74, "p50": 10.983, "p95": 23.927, "p99": 38.208}, "requests": 7177, "timestamp": "2026-10-23T23:56:28Z", "warmup_s": 3, "write_ms": {"max": 384.062, "p50": 248.681, "p95": 323.377, "p99": 350.278}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.0, "cpu_pct_max_per_container": 25.4, "cpu_utilization_of_limit": 0.439, "mem_max_mib": 63.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.1, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 23.1, "cpu_pct_max_per_container": 26.3, "cpu_utilization_of_limit": 0.231, "mem_max_mib": 285.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 50.9, "cpu_pct_max_per_container": 52.8, "cpu_utilization_of_limit": 0.509, "mem_max_mib": 13.9}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 80}}, "pool": {"acquires": 24631, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "baseline_again", "concurrency": 16, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1644, "b201667f0488": 1639, "ceac3545a6f4": 1638, "ffe44b74e740": 1636}, "label": "C_shared_resources/baseline_again", "latency_ms": {"max": 183.668, "p50": 20.508, "p95": 88.881, "p99": 109.676}, "mode": "closed", "ok": 6557, "ok_read_rps": 221.93333333333334, "ok_rps": 437.1333333333333, "ok_write_rps": 215.2, "rate": 0, "read_ms": {"max": 56.112, "p50": 4.528, "p95": 14.623, "p99": 23.039}, "requests": 6557, "timestamp": "2026-10-23T23:56:55Z", "warmup_s": 3, "write_ms": {"max": 183.668, "p50": 66.115, "p95": 97.061, "p99": 123.454}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.5, "cpu_pct_max_per_container": 24.7, "cpu_utilization_of_limit": 0.449, "mem_max_mib": 64.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.093, "mem_max_mib": 11.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.0, "cpu_pct_max_per_container": 23.2, "cpu_utilization_of_limit": 0.21, "mem_max_mib": 288.3}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 49.1, "cpu_pct_max_per_container": 50.2, "cpu_utilization_of_limit": 0.982, "mem_max_mib": 12.2}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 80}}, "pool": {"acquires": 22524, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "baseline_again", "concurrency": 16, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1602, "b201667f0488": 1597, "ceac3545a6f4": 1600, "ffe44b74e740": 1599}, "label": "C_shared_resources/baseline_again", "latency_ms": {"max": 172.291, "p50": 28.713, "p95": 89.005, "p99": 110.155}, "mode": "closed", "ok": 6398, "ok_read_rps": 212.2, "ok_rps": 426.53333333333336, "ok_write_rps": 214.33333333333334, "rate": 0, "read_ms": {"max": 52.195, "p50": 4.221, "p95": 11.897, "p99": 21.647}, "requests": 6398, "timestamp": "2026-10-23T23:57:15Z", "warmup_s": 3, "write_ms": {"max": 172.291, "p50": 67.29, "p95": 99.109, "p99": 120.43}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 25.7, "cpu_utilization_of_limit": 0.444, "mem_max_mib": 64.0}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 4.9, "cpu_utilization_of_limit": 0.093, "mem_max_mib": 11.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.4, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.204, "mem_max_mib": 295.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.7, "cpu_pct_max_per_container": 48.8, "cpu_utilization_of_limit": 0.954, "mem_max_mib": 18.2}, "postgres_connections": {"active_max": 3, "active_mean": 0.9, "total_max": 80}}, "pool": {"acquires": 21917, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "baseline_again", "concurrency": 16, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1625, "b201667f0488": 1622, "ceac3545a6f4": 1621, "ffe44b74e740": 1623}, "label": "C_shared_resources/baseline_again", "latency_ms": {"max": 194.758, "p50": 15.848, "p95": 91.807, "p99": 117.037}, "mode": "closed", "ok": 6491, "ok_read_rps": 223.53333333333333, "ok_rps": 432.73333333333335, "ok_write_rps": 209.2, "rate": 0, "read_ms": {"max": 54.252, "p50": 4.406, "p95": 13.977, "p99": 24.307}, "requests": 6491, "timestamp": "2026-10-23T23:57:35Z", "warmup_s": 3, "write_ms": {"max": 194.758, "p50": 68.504, "p95": 104.278, "p99": 123.891}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.1, "cpu_pct_max_per_container": 24.0, "cpu_utilization_of_limit": 0.441, "mem_max_mib": 63.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.1, "cpu_utilization_of_limit": 0.095, "mem_max_mib": 11.6}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 21.5, "cpu_pct_max_per_container": 23.1, "cpu_utilization_of_limit": 0.215, "mem_max_mib": 300.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.7, "cpu_pct_max_per_container": 49.9, "cpu_utilization_of_limit": 0.954, "mem_max_mib": 12.3}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 80}}, "pool": {"acquires": 22160, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "baseline_again", "concurrency": 16, "repeat": 3, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1602, "b201667f0488": 1603, "ceac3545a6f4": 1601, "ffe44b74e740": 1603}, "label": "C_shared_resources/baseline_again", "latency_ms": {"max": 166.728, "p50": 22.914, "p95": 93.445, "p99": 118.505}, "mode": "closed", "ok": 6409, "ok_read_rps": 215.06666666666666, "ok_rps": 427.26666666666665, "ok_write_rps": 212.2, "rate": 0, "read_ms": {"max": 53.17, "p50": 4.238, "p95": 14.903, "p99": 23.51}, "requests": 6409, "timestamp": "2026-10-23T23:57:55Z", "warmup_s": 3, "write_ms": {"max": 166.728, "p50": 67.198, "p95": 105.626, "p99": 128.721}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 24.2, "cpu_utilization_of_limit": 0.444, "mem_max_mib": 64.2}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.7, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.093, "mem_max_mib": 11.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 20.2, "cpu_pct_max_per_container": 21.4, "cpu_utilization_of_limit": 0.202, "mem_max_mib": 297.2}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.1, "cpu_pct_max_per_container": 49.2, "cpu_utilization_of_limit": 0.961, "mem_max_mib": 12.7}, "postgres_connections": {"active_max": 2, "active_mean": 0.4, "total_max": 80}}, "pool": {"acquires": 22065, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "baseline_again", "concurrency": 16, "repeat": 4, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 16, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1546, "b201667f0488": 1544, "ceac3545a6f4": 1544, "ffe44b74e740": 1549}, "label": "C_shared_resources/baseline_again", "latency_ms": {"max": 184.013, "p50": 38.647, "p95": 94.242, "p99": 115.106}, "mode": "closed", "ok": 6183, "ok_read_rps": 202.26666666666668, "ok_rps": 412.2, "ok_write_rps": 209.93333333333334, "rate": 0, "read_ms": {"max": 54.497, "p50": 4.231, "p95": 12.699, "p99": 22.078}, "requests": 6183, "timestamp": "2026-10-23T23:58:16Z", "warmup_s": 3, "write_ms": {"max": 184.013, "p50": 67.744, "p95": 103.851, "p99": 125.435}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 22.0, "cpu_pct_max_per_container": 25.0, "cpu_utilization_of_limit": 0.44, "mem_max_mib": 63.7}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.6, "cpu_pct_max_per_container": 4.8, "cpu_utilization_of_limit": 0.092, "mem_max_mib": 11.8}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.3, "cpu_pct_max_per_container": 34.1, "cpu_utilization_of_limit": 0.223, "mem_max_mib": 299.7}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.3, "cpu_pct_max_per_container": 49.2, "cpu_utilization_of_limit": 0.945, "mem_max_mib": 12.4}, "postgres_connections": {"active_max": 3, "active_mean": 0.7, "total_max": 81}}, "pool": {"acquires": 21366, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "baseline_again", "concurrency": 64, "repeat": 0, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1701, "b201667f0488": 1689, "ceac3545a6f4": 1688, "ffe44b74e740": 1692}, "label": "C_shared_resources/baseline_again", "latency_ms": {"max": 421.366, "p50": 183.235, "p95": 321.999, "p99": 363.075}, "mode": "closed", "ok": 6770, "ok_read_rps": 221.4, "ok_rps": 451.3333333333333, "ok_write_rps": 229.93333333333334, "rate": 0, "read_ms": {"max": 99.653, "p50": 11.161, "p95": 29.629, "p99": 44.932}, "requests": 6770, "timestamp": "2026-10-23T23:58:36Z", "warmup_s": 3, "write_ms": {"max": 421.366, "p50": 260.955, "p95": 345.005, "p99": 374.834}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.2, "cpu_pct_max_per_container": 24.7, "cpu_utilization_of_limit": 0.425, "mem_max_mib": 65.3}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.095, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.2, "cpu_pct_max_per_container": 24.3, "cpu_utilization_of_limit": 0.222, "mem_max_mib": 303.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.4, "cpu_pct_max_per_container": 50.1, "cpu_utilization_of_limit": 0.967, "mem_max_mib": 13.7}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 80}}, "pool": {"acquires": 23311, "empty_acquire_ratio": 0.0001, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "baseline_again", "concurrency": 64, "repeat": 1, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1715, "b201667f0488": 1716, "ceac3545a6f4": 1712, "ffe44b74e740": 1712}, "label": "C_shared_resources/baseline_again", "latency_ms": {"max": 403.591, "p50": 134.214, "p95": 320.632, "p99": 355.792}, "mode": "closed", "ok": 6855, "ok_read_rps": 227, "ok_rps": 457, "ok_write_rps": 230, "rate": 0, "read_ms": {"max": 57.8, "p50": 11.029, "p95": 23.629, "p99": 34.096}, "requests": 6855, "timestamp": "2026-10-23T23:58:56Z", "warmup_s": 3, "write_ms": {"max": 403.591, "p50": 263.828, "p95": 337.266, "p99": 373.787}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.3, "cpu_pct_max_per_container": 24.0, "cpu_utilization_of_limit": 0.426, "mem_max_mib": 82.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.2, "cpu_utilization_of_limit": 0.098, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.4, "cpu_pct_max_per_container": 25.5, "cpu_utilization_of_limit": 0.224, "mem_max_mib": 308.8}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.7, "cpu_pct_max_per_container": 50.2, "cpu_utilization_of_limit": 0.975, "mem_max_mib": 13.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 80}}, "pool": {"acquires": 23777, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.0, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "baseline_again", "concurrency": 64, "repeat": 2, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1783, "b201667f0488": 1782, "ceac3545a6f4": 1790, "ffe44b74e740": 1790}, "label": "C_shared_resources/baseline_again", "latency_ms": {"max": 414.797, "p50": 41.87, "p95": 300.193, "p99": 346.586}, "mode": "closed", "ok": 7145, "ok_read_rps": 239.66666666666666, "ok_rps": 476.3333333333333, "ok_write_rps": 236.66666666666666, "rate": 0, "read_ms": {"max": 75.336, "p50": 10.851, "p95": 25.101, "p99": 37.447}, "requests": 7145, "timestamp": "2026-10-23T23:59:17Z", "warmup_s": 3, "write_ms": {"max": 414.797, "p50": 253.568, "p95": 322.246, "p99": 370.972}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.2, "cpu_pct_max_per_container": 23.3, "cpu_utilization_of_limit": 0.424, "mem_max_mib": 65.6}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.8, "cpu_pct_max_per_container": 5.0, "cpu_utilization_of_limit": 0.097, "mem_max_mib": 12.3}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.3, "cpu_pct_max_per_container": 24.1, "cpu_utilization_of_limit": 0.223, "mem_max_mib": 310.9}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.7, "cpu_pct_max_per_container": 50.0, "cpu_utilization_of_limit": 0.973, "mem_max_mib": 13.8}, "postgres_connections": {"active_max": 1, "active_mean": 0.3, "total_max": 80}}, "pool": {"acquires": 24585, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "baseline_again", "concurrency": 64, "repeat": 3, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1722, "b201667f0488": 1738, "ceac3545a6f4": 1734, "ffe44b74e740": 1727}, "label": "C_shared_resources/baseline_again", "latency_ms": {"max": 385.509, "p50": 162.009, "p95": 311.807, "p99": 339.598}, "mode": "closed", "ok": 6921, "ok_read_rps": 228.73333333333332, "ok_rps": 461.4, "ok_write_rps": 232.66666666666666, "rate": 0, "read_ms": {"max": 93.785, "p50": 11.157, "p95": 27.679, "p99": 44.07}, "requests": 6921, "timestamp": "2026-10-23T23:59:37Z", "warmup_s": 3, "write_ms": {"max": 385.509, "p50": 261.733, "p95": 324.886, "p99": 349.144}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 20.9, "cpu_pct_max_per_container": 23.3, "cpu_utilization_of_limit": 0.419, "mem_max_mib": 65.5}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 4.9, "cpu_pct_max_per_container": 5.4, "cpu_utilization_of_limit": 0.098, "mem_max_mib": 12.1}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.4, "cpu_pct_max_per_container": 24.4, "cpu_utilization_of_limit": 0.224, "mem_max_mib": 314.0}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 48.6, "cpu_pct_max_per_container": 49.6, "cpu_utilization_of_limit": 0.973, "mem_max_mib": 14.0}, "postgres_connections": {"active_max": 4, "active_mean": 0.6, "total_max": 80}}, "pool": {"acquires": 23974, "empty_acquire_ratio": 0.0002, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} +{"series": "C_shared_resources", "config": "baseline_again", "concurrency": 64, "repeat": 4, "load": {"duration": "15s", "warmup": "3s", "write_ratio": 0.5, "chats": 8}, "env": {"API_REPLICAS": "4", "API_CPUS": "0.50", "API_MEMORY": "256M", "PG_CPUS": "1.00", "LB_CPUS": "0.50", "REDIS_CPUS": "0.50", "DB_POOL_MAX": "20", "CACHE_INVALIDATION": "scan", "LB_BALANCE": "roundrobin"}, "host": {"host_cpus": 2, "docker": "28.0.4", "docker_cpus": "2", "docker_mem_bytes": "8323969024"}, "bench": {"chats": 8, "concurrency": 64, "dropped": 0, "duration_s": 15, "error_ratio": 0, "errors": 0, "errors_by_class": {}, "instances": {"63789c9bb7a0": 1721, "b201667f0488": 1713, "ceac3545a6f4": 1712, "ffe44b74e740": 1717}, "label": "C_shared_resources/baseline_again", "latency_ms": {"max": 464.893, "p50": 121.614, "p95": 313.127, "p99": 349.823}, "mode": "closed", "ok": 6863, "ok_read_rps": 228.66666666666666, "ok_rps": 457.53333333333336, "ok_write_rps": 228.86666666666667, "rate": 0, "read_ms": {"max": 121.614, "p50": 11.103, "p95": 24.68, "p99": 41.584}, "requests": 6863, "timestamp": "2026-10-23T23:59:58Z", "warmup_s": 3, "write_ms": {"max": 464.893, "p50": 263.334, "p95": 329.333, "p99": 375.998}, "write_ratio": 0.5}, "resources": {"api": {"containers": 4, "cpu_pct_mean_per_container": 21.2, "cpu_pct_max_per_container": 23.5, "cpu_utilization_of_limit": 0.424, "mem_max_mib": 65.8}, "lb": {"containers": 1, "cpu_pct_mean_per_container": 5.0, "cpu_pct_max_per_container": 5.3, "cpu_utilization_of_limit": 0.101, "mem_max_mib": 12.5}, "postgres": {"containers": 1, "cpu_pct_mean_per_container": 22.5, "cpu_pct_max_per_container": 25.0, "cpu_utilization_of_limit": 0.225, "mem_max_mib": 316.6}, "redis": {"containers": 1, "cpu_pct_mean_per_container": 47.0, "cpu_pct_max_per_container": 48.8, "cpu_utilization_of_limit": 0.941, "mem_max_mib": 14.1}, "postgres_connections": {"active_max": 1, "active_mean": 0.1, "total_max": 80}}, "pool": {"acquires": 23689, "empty_acquire_ratio": 0.0, "avg_acquire_wait_ms": 0.001, "pool_max_conns_total": 80}} diff --git a/evidence/track1/report.html b/evidence/track1/report.html index cac3f910..c172023a 100644 --- a/evidence/track1/report.html +++ b/evidence/track1/report.html @@ -24,7 +24,7 @@ th,td{border-bottom:1px solid var(--grid);padding:4px 6px;text-align:right}th:fi .wrap{overflow-x:auto} #tip{position:fixed;pointer-events:none;background:var(--surface-1);color:var(--text-primary);border:1px solid var(--border); border-radius:6px;padding:4px 8px;font-size:12px;display:none;box-shadow:0 2px 8px rgba(0,0,0,.15)} -

Трек 1 — цена масштабирования

Медианы по повторам. Наведите на точку — значение. Полные данные — таблицы под графиками и summary.csv.

A_fixed_total — Фиксированный суммарный бюджет API: 1.0 CPU / 768M

Гипотеза: При фиксированном суммарном CPU рост числа реплик не увеличивает пиковый RPS (тот же бюджет) и немного ухудшает p95 из-за накладных расходов на процесс и пул соединений; выигрыш реплик — только отказоустойчивость.

Успешные RPS
1x1.002x0.504x0.25
010020030040050041664параллелизм (closed-loop воркеры)ok RPS1x1.002x0.504x0.25
p95 задержки, мс
1x1.002x0.504x0.25
010020030040041664параллелизм (closed-loop воркеры)мс1x1.002x0.504x0.25
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
1x1.00460.31.00×6416redis (1.00) — насыщена67%0.000 / 0.00
2x0.50435.90.95×1616redis (1.00) — насыщена74%0.000 / 0.00
4x0.25474.51.03×6464api (0.53)46%0.001 / 0.05
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
1x1.0043400.0380.3409.6198.0202.09.5029.0038.000.00000.600.201.020.091.35/20.0000.001
1x1.00163431.1419.1435.1213.2214.931.9987.64114.580.00000.590.201.000.101.34/20.0000.001
1x1.00643460.3439.5466.0229.7229.9203.62323.70364.450.00000.650.210.990.101.43/20.0150.061
2x0.5043414.0376.7416.1203.9208.58.5323.9534.560.00000.750.181.020.091.49/20.0000.001
2x0.50163435.9426.3446.4217.3218.522.7193.78116.920.00000.720.211.000.101.48/20.0000.001
2x0.50643432.1390.1446.1222.3209.768.66411.81499.590.00000.720.221.000.101.49/20.0030.010
4x0.2543365.9351.5395.9182.5183.58.7424.9650.780.00000.830.190.950.091.54/20.0000.002
4x0.25163430.7405.5454.6217.2213.524.5793.21141.180.00000.860.200.930.091.56/20.0000.011
4x0.25643474.5469.9479.0231.9241.353.35326.69406.510.00000.530.130.450.050.91/20.0010.051

B_scale_out — Рост ресурсов: реплики по 0.5 CPU, БД 1.0 CPU, LB 0.5 CPU

Гипотеза: Пиковый RPS растёт почти линейно, пока узкое место — CPU API; затем рост останавливается на общей зависимости (PostgreSQL, Redis или LB), чья утилизация CPU приближается к лимиту.

Успешные RPS
1x0.502x0.504x0.50
010020030040041664параллелизм (closed-loop воркеры)ok RPS1x0.502x0.504x0.50
p95 задержки, мс
1x0.502x0.504x0.50
010020030040041664параллелизм (closed-loop воркеры)мс1x0.502x0.504x0.50
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
1x0.50395.11.00×1664api (0.99) — насыщена59%0.015 / 0.08
2x0.50426.71.08×6416redis (1.01) — насыщена75%0.000 / 0.00
4x0.50419.01.06×6416redis (1.00) — насыщена80%0.000 / 0.00
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
1x0.5043353.9345.9360.0177.0173.910.6640.4145.860.00001.000.190.870.091.17/20.0000.001
1x0.50163395.1380.5400.1195.1195.637.8593.43116.110.00001.000.200.890.101.19/20.0000.001
1x0.50643357.7355.3368.2178.9179.661.60381.45406.440.00000.990.210.830.091.17/20.0150.081
2x0.5043387.1385.9388.9194.2193.310.1526.3434.550.00000.690.221.010.101.46/20.0000.001
2x0.50163421.7416.1428.3209.1212.625.0190.25117.630.00000.670.261.010.111.50/20.0000.001
2x0.50643426.7415.9430.6210.0208.776.17404.13457.300.00000.670.271.000.101.49/20.0060.080
4x0.5043387.3371.2396.7191.5191.210.1424.8733.900.00000.390.231.000.101.56/20.0000.001
4x0.50163402.7391.3405.7200.1201.032.2695.64119.370.00000.380.261.000.111.59/20.0000.003
4x0.50643419.0407.6420.2210.3206.5213.44343.64390.490.00000.370.280.970.111.57/20.0000.003

C_shared_resources — 4×0.5 CPU API, меняем ресурсы общих зависимостей

Гипотеза: Если насыщение B вызвано общей зависимостью, увеличение её CPU поднимает пиковый RPS, а увеличение CPU других зависимостей — нет.

Успешные RPS
pg1_lb0.5_redis0.5pg2lb1redis1
01002003004001664параллелизм (closed-loop воркеры)ok RPSpg1_lb0.5_redis0.5pg2lb1redis1
p95 задержки, мс
pg1_lb0.5_redis0.5pg2lb1redis1
01002003004005001664параллелизм (closed-loop воркеры)мсpg1_lb0.5_redis0.5pg2lb1redis1
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
pg1_lb0.5_redis0.5331.21.00×1664redis (1.00) — насыщена73%0.000 / 0.01
pg2383.41.16×6464redis (0.96) — насыщена78%0.000 / 0.01
lb1410.91.24×6464redis (0.97) — насыщена78%0.001 / 0.11
redis1404.61.22×6464redis (0.50)81%0.000 / 0.01
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
pg1_lb0.5_redis0.5163331.2293.6348.9162.6168.636.93118.80150.910.00000.350.211.010.101.46/20.0000.003
pg1_lb0.5_redis0.5643322.7292.9332.1162.0158.253.27463.75550.180.00000.350.201.000.101.45/20.0000.011
pg2163320.5305.4396.8160.1160.436.26126.09148.150.00000.350.121.000.101.48/20.0000.000
pg2643383.4367.1416.1189.6193.8186.51395.19479.100.00000.390.120.960.101.56/20.0000.011
lb1163356.3353.3356.5175.9180.125.45112.79149.760.00000.380.220.960.051.53/20.0000.010
lb1643410.9374.8423.0202.8208.141.57379.46477.930.00000.400.240.970.051.57/20.0010.111
redis1163392.0372.1398.1193.8198.229.38104.05131.510.00000.430.230.490.101.62/20.0000.003
redis1643404.6374.3412.5199.3205.347.10405.32468.330.00000.420.240.500.111.63/20.0000.011

D_improvement — Кандидаты улучшения на 4×0.5 CPU

Гипотеза: Инвалидация кэша истории через SCAN (lab2) делает O(keyspace/100) запросов к Redis на каждую запись; ключ с версией чата (CACHE_INVALIDATION=version) делает 1 INCR и поднимает RPS записи при большом keyspace. Альтернативы: меньший пул на реплику, leastconn.

Успешные RPS
baseline_scancache_versionpool_8leastconn
02004006008003264параллелизм (closed-loop воркеры)ok RPSbaseline_scancache_versionpool_8leastconn
p95 задержки, мс
baseline_scancache_versionpool_8leastconn
01002003004003264параллелизм (closed-loop воркеры)мсbaseline_scancache_versionpool_8leastconn
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
baseline_scan374.51.00×3264redis (0.99) — насыщена76%0.000 / 0.01
cache_version817.62.18×6464postgres (0.76)79%0.103 / 0.65
pool_8361.70.97×6464redis (0.97) — насыщена73%0.012 / 0.39
leastconn365.30.98×3264redis (1.00) — насыщена70%0.000 / 0.00

Кандидаты против baseline_scan

кандидатcΔRPS %Δp95 %повторы b/cподтверждено
cache_version64125.8-42.13/3да
pool_864-0.1-2.03/3нет
leastconn64-13.07.03/3нет
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
baseline_scan323374.5367.3374.7185.8187.549.48210.73259.880.00000.370.220.990.101.52/20.0000.012
baseline_scan643362.1357.8391.1179.5182.749.47421.49490.890.00000.380.210.990.101.52/20.0000.012
cache_version323721.6670.7790.6357.4364.228.89131.66234.130.00000.290.820.150.171.59/20.0010.0131
cache_version643817.6781.9870.0410.5407.147.20243.84516.490.00000.310.760.210.181.59/20.1030.6558
pool_8323361.5270.6395.8181.5179.980.97213.58259.730.00000.370.221.010.091.53/20.0040.020
pool_8643361.7308.7388.8180.5181.2111.06412.93635.540.00000.360.210.970.091.46/20.0120.393
leastconn323365.3361.9366.3181.6183.549.28204.72245.420.00000.360.211.000.091.47/20.0000.002
leastconn643315.1313.0337.1157.5157.6221.25450.90512.510.00000.320.201.000.091.39/20.0000.000

E_scale_out_after_fix — Рост реплик после улучшения (CACHE_INVALIDATION=version), реплики по 0.5 CPU

Гипотеза: После снятия упора в Redis рост реплик снова увеличивает RPS, пока не насытится следующая общая зависимость (ожидаем PostgreSQL) или CPU хоста.

Успешные RPS
1x0.502x0.504x0.50
020040060041664параллелизм (closed-loop воркеры)ok RPS1x0.502x0.504x0.50
p95 задержки, мс
1x0.502x0.504x0.50
010020030040041664параллелизм (closed-loop воркеры)мс1x0.502x0.504x0.50
configпик RPSк первойc пикаc насыщенияузкое местоCPU хостаpool empty / wait ms
1x0.50527.31.00×1616api (1.01) — насыщена55%0.000 / 0.00
2x0.50598.91.14×416api (0.76)81%0.000 / 0.00
4x0.50550.31.04×416postgres (0.55)77%0.000 / 0.00
Все точки серии
configcrepeatsok_rpsrps_minrps_maxwrite_rpsread_rpsp50_msp95_msp99_mserrutil_apiutil_pgutil_redisutil_lbhost_corespool_emptypool_wait_mspg_active
1x0.5043487.9487.5495.9248.0243.45.6328.4138.240.00001.000.420.180.181.11/20.0000.002
1x0.50163527.3526.0530.6264.7265.924.3865.4982.530.00001.010.430.160.171.11/20.0000.003
1x0.50643525.9525.7549.9259.5269.3116.35179.63207.680.00001.000.490.180.181.21/20.97720.573
2x0.5043598.9593.0634.0304.7298.55.7611.8820.150.00000.770.510.270.201.53/20.0000.002
2x0.50163593.3561.6637.1296.5296.823.4857.3681.290.00000.760.570.360.191.61/20.0000.008
2x0.50643561.0531.3595.4278.7282.3101.03244.15335.720.00000.730.620.280.181.57/20.75312.0935
4x0.5043550.3548.2553.0279.0273.36.2114.1522.450.00000.410.530.210.201.54/20.0000.003
4x0.50163538.7535.8545.1266.4272.324.9564.5796.190.00000.400.550.210.201.54/20.0000.008
4x0.50643513.3465.3527.5260.6252.778.12392.00829.030.00000.370.630.190.171.57/20.1201.5759