From 029bf9b377ee0d9990365706522f2abff51bcfaa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=92=D0=B0=D1=81=D0=B8=D0=BB=D1=8C=D0=B5=D0=B2=20=D0=9D?= =?UTF-8?q?=D0=B8=D0=BA=D0=B8=D1=82=D0=B0?= Date: Fri, 6 Nov 2026 17:58:43 +0300 Subject: [PATCH 1/4] Implement shared idempotency, health-aware balancing and replica lifecycle checks --- .dockerignore | 27 +- .gitignore | 2 + Dockerfile | 18 + Makefile | 24 + REVIEW_NOTES.md | 15 + SCHEMA.md | 37 ++ compose.yaml | 94 ++++ infra/haproxy.cfg | 35 ++ migrations/001_initial.sql | 35 ++ migrations/002_idempotency.sql | 10 + migrations/003_unicode_storage.sql | 13 + pyproject.toml | 21 + scripts/bootstrap.py | 30 ++ scripts/container_snapshot.py | 14 + scripts/restart.sh | 7 + scripts/rolling-update.sh | 14 + scripts/stop-one.sh | 4 + scripts/stop_one.py | 19 + scripts/verify_readiness.py | 53 +++ scripts/verify_replicas.py | 95 ++++ scripts/verify_rolling.py | 79 ++++ scripts/wait_replicas.py | 21 + src/messenger/__init__.py | 1 + src/messenger/__main__.py | 12 + src/messenger/app.py | 220 +++++++++ src/messenger/config.py | 10 + src/messenger/domain.py | 54 +++ src/messenger/migrate.py | 32 ++ src/messenger/models.py | 52 +++ src/messenger/postgres.py | 292 ++++++++++++ student-tests/test_api.py | 187 ++++++++ student-tests/test_edgecases.py | 99 ++++ student-tests/test_lab3.py | 101 +++++ student-tests/test_sessions.py | 62 +++ uv.lock | 701 +++++++++++++++++++++++++++++ 35 files changed, 2470 insertions(+), 20 deletions(-) create mode 100644 Dockerfile create mode 100644 REVIEW_NOTES.md create mode 100644 SCHEMA.md create mode 100644 compose.yaml create mode 100644 infra/haproxy.cfg create mode 100644 migrations/001_initial.sql create mode 100644 migrations/002_idempotency.sql create mode 100644 migrations/003_unicode_storage.sql create mode 100644 pyproject.toml create mode 100644 scripts/bootstrap.py create mode 100644 scripts/container_snapshot.py create mode 100755 scripts/restart.sh create mode 100755 scripts/rolling-update.sh create mode 100755 scripts/stop-one.sh create mode 100644 scripts/stop_one.py create mode 100644 scripts/verify_readiness.py create mode 100644 scripts/verify_replicas.py create mode 100644 scripts/verify_rolling.py create mode 100644 scripts/wait_replicas.py create mode 100644 src/messenger/__init__.py create mode 100644 src/messenger/__main__.py create mode 100644 src/messenger/app.py create mode 100644 src/messenger/config.py create mode 100644 src/messenger/domain.py create mode 100644 src/messenger/migrate.py create mode 100644 src/messenger/models.py create mode 100644 src/messenger/postgres.py create mode 100644 student-tests/test_api.py create mode 100644 student-tests/test_edgecases.py create mode 100644 student-tests/test_lab3.py create mode 100644 student-tests/test_sessions.py create mode 100644 uv.lock diff --git a/.dockerignore b/.dockerignore index bc16e556..438f5083 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,20 +1,7 @@ -.git -.github -.env -.env.* -!.env.example -secrets -certs -volumes -data -backups -*.key -*.pem -*.p12 -*.pfx -*.jks -.venv -__pycache__ -node_modules -evidence -.DS_Store +* +!pyproject.toml +!uv.lock +!src/ +!src/** +!migrations/ +!migrations/** diff --git a/.gitignore b/.gitignore index b5a71896..94fbfc4c 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,5 @@ coverage/ .vscode/ # Keep small, sanitized evidence summaries in evidence/ under version control. # Inspect git diff --cached: ignore rules are not a secret scanner. +.pytest_cache/ +.ruff_cache/ diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..4ebc215c --- /dev/null +++ b/Dockerfile @@ -0,0 +1,18 @@ +FROM python:3.12-slim@sha256:646fb0bca3dd3ea1bcc6feb72c17ed16eed6e10cffc732fcc1478bd3e7f02d7b AS build +COPY --from=ghcr.io/astral-sh/uv:0.11.7 /uv /usr/local/bin/uv +WORKDIR /app +COPY pyproject.toml uv.lock ./ +RUN uv sync --locked --no-dev --no-install-project --python /usr/local/bin/python + +FROM python:3.12-slim@sha256:646fb0bca3dd3ea1bcc6feb72c17ed16eed6e10cffc732fcc1478bd3e7f02d7b +ARG VCS_REF=uncommitted +LABEL org.opencontainers.image.revision=$VCS_REF +ENV PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=/app/src PATH=/app/.venv/bin:$PATH +WORKDIR /app +COPY --from=build /app/.venv /app/.venv +COPY src ./src +COPY migrations ./migrations +USER 10001:10001 +EXPOSE 8080 +HEALTHCHECK --interval=3s --timeout=2s --start-period=5s --retries=5 CMD ["python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=1)"] +CMD ["python", "-m", "messenger"] diff --git a/Makefile b/Makefile index 5d86d171..f85dedb5 100644 --- a/Makefile +++ b/Makefile @@ -28,3 +28,27 @@ 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) + +# Student commands; original teacher targets above remain unchanged. +PUBLIC_PORT ?= 8083 +BASE_URL = http://127.0.0.1:$(PUBLIC_PORT) + +bootstrap: + python3 scripts/bootstrap.py + +up: bootstrap + VCS_REF=$$(git rev-parse HEAD) docker compose up -d --build --wait + +down: + docker compose down + +migrate: + docker compose run --rm migrate + +lint: + uv run --locked ruff check src student-tests research + +student-test test-student: + BASE_URL=$(BASE_URL) uv run --locked pytest -q + +.PHONY: bootstrap up down migrate lint student-test test-student diff --git a/REVIEW_NOTES.md b/REVIEW_NOTES.md new file mode 100644 index 00000000..5c0e9b95 --- /dev/null +++ b/REVIEW_NOTES.md @@ -0,0 +1,15 @@ +# Замечания преподавателя, учтённые до реализации + +Проверены публичные замечания в чужих PR. Они используются как перечень регрессий; код и результаты чужих решений не заимствовались. Отсутствие комментариев само по себе не доказывает соответствие заданию. + +| Источник | Что учтено | +|---|---| +| [PR2#233](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab3/pulls/2#issuecomment-233) | Сообщение и результат идемпотентности в одной транзакции; корректный Unicode-пароль; обязательные заголовки | +| [PR4#236](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab3/pulls/4#issuecomment-236) | Отсутствующий attachment_ids эквивалентен []; CPU/RAM у LB и migrate; успешный RPS отдельно от попыток | +| [PR8#354](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab3/pulls/8#issuecomment-354) | Пустой cursor даёт 400 | +| [PR7#358](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab3/pulls/7#issuecomment-358) | Неверный Bearer и UTF-8 JSON дают контрактную ошибку; readiness действительно управляет LB | +| [PR12#408](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab3/pulls/12#issuecomment-408) | Нет прозрачного повтора неидемпотентных POST; ресурсы суммируются по репликам, фактические квоты сохраняются | +| [PR24#538](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab3/pulls/24#issuecomment-538) | Basic login отклоняет тело; максимум 100 участников | +| [PR23#534](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab3/pulls/23#issuecomment-534) | Logout не подтверждается при неудачном удалении; доступ проверяется перед replay | + +Также в общих регрессиях проверены потеря доступа только одной API, зависшая PostgreSQL, отсутствие обязательной таблицы, Unicode U+0000 и область ключа по пользователю/чату. Подробные результаты находятся в evidence, автоматические HTTP-регрессии — student-tests. diff --git a/SCHEMA.md b/SCHEMA.md new file mode 100644 index 00000000..bedfaa88 --- /dev/null +++ b/SCHEMA.md @@ -0,0 +1,37 @@ +# Схема и транзакционные границы ЛР3 + +Основные таблицы: users, chats, members, messages, sessions. PostgreSQL — источник истины. Valkey содержит только публичные карточки пользователей TTL60s, не историю и не сессии. + +## Схема + +- users: UUID PK, username UNIQUE, display_name UTF-8 bytea, password_hash Argon2id, created_at timestamptz. +- chats: UUID PK, title UTF-8 bytea, created_at. +- members: PK(chat_id,user_id), FK к users/chats, UNIQUE(chat_id,position). +- messages: UUID PK, chat_id, sender_id, text UTF-8 bytea, created_at; составной FK(chat_id,sender_id) к members. +- sessions: token_digest PK, user_id FK, expires_at; случайный token256bit хранится у клиента, только SHA256digest в БД. +- message_requests: PK(actor_id,chat_id,key), body_digest, response bytea, expires_at. HTTP-метод и маршрут фиксированы единственным поддерживаемым POST сообщения; область дополнительно включает actor и chat. +- schema_migrations: имя и SHA256 SQL-файла, контроль изменённых применённых миграций. + +Индексы: messages(chat_id,created_at,id), members(user_id,chat_id), sessions(expires_at), message_requests(expires_at), автоматически созданные PK/UNIQUE. + +## Unicode + +PostgreSQL text не принимает U+0000. Контракт не разрешает терять или заменять этот символ. Поэтому display_name/title/message.text и сериализованный replay-ответ хранятся как UTF-8 bytes. API проверяет длину в Unicode code points, БД дополнительно ограничивает octet_length. Чтение lossless декодирует UTF-8. Username ограничен ASCII и остаётся text. + +## Идемпотентность + +Одна транзакция: текущий ACL → advisory lock на hash(actor,POST,chat,key) → действительный replay либо конфликт body → INSERT message → INSERT сохранённого ответа → COMMIT. Ключ живёт 24 часа. Сбой до COMMIT отменяет оба эффекта. После COMMIT повтор возвращает тот же Message и201. 5xx не сохраняется как результат. Старый ключ, сессия и ACL проверяются заново. Канонический digest учитывает text и attachment_ids=[]; отсутствие массива и пустой массив эквивалентны. + +64-битная advisory hash-коллизия может только лишний раз сериализовать два разных запроса: чтение результата всё равно использует полный PK, поэтому не смешивает ответы. + +## Миграции и обновление + +Мигратор запускается отдельным service, берёт advisory transaction lock; API запускается после успеха. Повтор не дублирует объекты. Миграция003 меняет типы наbytea и **не совместима со старым runtime ЛР2**: первоначальный переход требует остановки старой версии. Проверенный rolling update заменяет реплики с одной и той же схемой. Автоматическую безопасную миграцию произвольных будущих схем мы не заявляем. + +Транзакция создания чата включает всех участников. Неизвестный участник откатывает весь чат. UNIQUE username разрешает гонку регистрации в самой БД. + +## Отказы и ограничения + +Client-side wait deadline3s на закреплённой psycopg3.3.6 закрывает зависшее соединение. Пул1..8, очередь32, timeout2s; connect2s, SQL2.5s, lock1.5s. Это отдельные бюджеты, не единыйHTTPdeadline. При неопределённом POST клиент повторяет исходный Idempotency-Key. + +Readiness проверяет доступность всех обязательных таблиц/полей; liveness — только жизнь процесса. API не имеют опубликованных портов. LB имеет доступ к frontend, PostgreSQL/Valkey — к backend, API — к обеим сетям. Один LB, одна PostgreSQL, storage и один host остаются SPOF. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..f468d13a --- /dev/null +++ b/compose.yaml @@ -0,0 +1,94 @@ +name: mtusi-vasilev-lab3 +x-application: &application + networks: [backend] + image: ${API_IMAGE:-mtusi-vasilev:lab3} + build: + context: . + args: + VCS_REF: ${VCS_REF:-uncommitted} + environment: + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + POOL_MAX_SIZE: ${POOL_MAX_SIZE:-8} + secrets: [database_url, cache_url] + cpus: ${API_CPUS:-0.5} + mem_limit: ${API_MEMORY:-256m} + pids_limit: 96 + read_only: true + tmpfs: ["/tmp:size=16m,noexec,nosuid"] + cap_drop: [ALL] + security_opt: [no-new-privileges:true] + stop_grace_period: 8s +services: + postgres: + networks: [backend] + image: postgres:17.10-alpine + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: [postgres_password] + volumes: [postgres_data:/var/lib/postgresql/data] + healthcheck: + test: [CMD-SHELL, "pg_isready -U messenger -d messenger"] + interval: 2s + timeout: 2s + retries: 15 + cpus: ${PG_CPUS:-1} + mem_limit: ${PG_MEMORY:-768m} + command: [postgres, -c, fsync=on, -c, synchronous_commit=on, -c, full_page_writes=on] + cache: + networks: [backend] + image: valkey/valkey:8.1.3-alpine + command: [valkey-server, --save, "", --appendonly, "no", --maxmemory, 64mb, --maxmemory-policy, allkeys-lru] + healthcheck: + test: [CMD, valkey-cli, ping] + interval: 2s + timeout: 2s + retries: 15 + cpus: 0.5 + mem_limit: 128m + migrate: + <<: *application + command: [python, -m, messenger.migrate] + healthcheck: + disable: true + depends_on: + postgres: {condition: service_healthy} + api: + <<: *application + networks: [frontend, backend] + deploy: + replicas: ${API_REPLICAS:-2} + depends_on: + migrate: {condition: service_completed_successfully} + cache: {condition: service_healthy} + lb: + networks: [frontend] + image: haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0 + ports: ["127.0.0.1:${PUBLIC_PORT:-8083}:8080"] + volumes: ["./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro"] + depends_on: + api: {condition: service_healthy} + cpus: 0.5 + mem_limit: 128m + read_only: true + tmpfs: ["/tmp:size=8m"] + cap_drop: [ALL] + security_opt: [no-new-privileges:true] + healthcheck: + test: [CMD-SHELL, "wget -q -O /dev/null http://127.0.0.1:8080/health/ready"] + interval: 2s + timeout: 2s + retries: 10 +volumes: + postgres_data: +secrets: + postgres_password: {file: ./secrets/postgres_password} + database_url: {file: ./secrets/database_url} + cache_url: {file: ./secrets/cache_url} + +networks: + frontend: + backend: diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg new file mode 100644 index 00000000..ae5f764a --- /dev/null +++ b/infra/haproxy.cfg @@ -0,0 +1,35 @@ +global + log stdout format raw local0 + maxconn 256 + stats socket /tmp/haproxy.sock mode 600 level admin + +defaults + mode http + log global + timeout connect 1s + timeout client 10s + timeout server 8s + timeout check 1s + timeout queue 2s + retries 0 + option httplog + +resolvers docker + nameserver dns 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + hold valid 1s + hold obsolete 1s + hold nx 1s + +frontend public + bind :8080 + default_backend apis + +backend apis + balance roundrobin + option httpchk GET /health/ready + http-check expect status 200 + default-server inter 1s fastinter 500ms downinter 1s fall 2 rise 2 + server-template api 1-8 api:8080 check resolvers docker resolve-prefer ipv4 init-addr libc,none diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..2d05d335 --- /dev/null +++ b/migrations/001_initial.sql @@ -0,0 +1,35 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100), + password_hash text NOT NULL, + created_at timestamptz NOT NULL +); +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100), + created_at timestamptz NOT NULL +); +CREATE TABLE members ( + chat_id uuid NOT NULL REFERENCES chats(id), + user_id uuid NOT NULL REFERENCES users(id), + position integer NOT NULL CHECK (position >= 0), + PRIMARY KEY(chat_id,user_id), + UNIQUE(chat_id,position) +); +CREATE INDEX members_user_idx ON members(user_id,chat_id); +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL, + sender_id uuid NOT NULL, + text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000), + created_at timestamptz NOT NULL, + FOREIGN KEY(chat_id,sender_id) REFERENCES members(chat_id,user_id) +); +CREATE INDEX messages_history_idx ON messages(chat_id,created_at,id); +CREATE TABLE sessions ( + token_digest text PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users(id), + expires_at timestamptz NOT NULL +); +CREATE INDEX sessions_expiry_idx ON sessions(expires_at); diff --git a/migrations/002_idempotency.sql b/migrations/002_idempotency.sql new file mode 100644 index 00000000..3ca43082 --- /dev/null +++ b/migrations/002_idempotency.sql @@ -0,0 +1,10 @@ +CREATE TABLE message_requests ( + actor_id uuid NOT NULL REFERENCES users(id), + chat_id uuid NOT NULL REFERENCES chats(id), + key text NOT NULL, + body_digest text NOT NULL, + response jsonb NOT NULL, + expires_at timestamptz NOT NULL, + PRIMARY KEY(actor_id,chat_id,key) +); +CREATE INDEX message_requests_expiry_idx ON message_requests(expires_at); diff --git a/migrations/003_unicode_storage.sql b/migrations/003_unicode_storage.sql new file mode 100644 index 00000000..c79d6b9a --- /dev/null +++ b/migrations/003_unicode_storage.sql @@ -0,0 +1,13 @@ +-- PostgreSQL text rejects U+0000, while the API accepts Unicode code points. +-- Preserve UTF-8 losslessly. API validation enforces code point limits; the DB +-- additionally bounds byte lengths, without stripping or replacing characters. +ALTER TABLE users DROP CONSTRAINT users_display_name_check; +ALTER TABLE users ALTER COLUMN display_name TYPE bytea USING convert_to(display_name,'UTF8'); +ALTER TABLE users ADD CHECK (octet_length(display_name) BETWEEN 1 AND 400); +ALTER TABLE chats DROP CONSTRAINT chats_title_check; +ALTER TABLE chats ALTER COLUMN title TYPE bytea USING convert_to(title,'UTF8'); +ALTER TABLE chats ADD CHECK (octet_length(title) BETWEEN 1 AND 400); +ALTER TABLE messages DROP CONSTRAINT messages_text_check; +ALTER TABLE messages ALTER COLUMN text TYPE bytea USING convert_to(text,'UTF8'); +ALTER TABLE messages ADD CHECK (octet_length(text) BETWEEN 1 AND 16000); +ALTER TABLE message_requests ALTER COLUMN response TYPE bytea USING convert_to(response::text,'UTF8'); diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..88cce7c2 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,21 @@ +[project] +name = "mtusi-messenger" +version = "1.0.0" +requires-python = ">=3.12,<3.13" +dependencies = ["fastapi", "uvicorn", "psycopg[binary,pool]", "redis", "argon2-cffi"] + +[dependency-groups] +dev = ["pytest", "httpx", "ruff", "openapi-spec-validator", "jsonschema"] + +[tool.ruff] +target-version = "py312" +line-length = 100 +include = ["src/**/*.py", "student-tests/**/*.py", "research/**/*.py"] + +[tool.pytest.ini_options] +testpaths = ["student-tests"] +pythonpath = ["src", "tests"] + +[tool.ruff.lint] +select = ["E4", "E7", "E9", "F", "I", "UP", "B"] +ignore = ["B008"] # FastAPI dependencies are declared in endpoint signatures. diff --git a/scripts/bootstrap.py b/scripts/bootstrap.py new file mode 100644 index 00000000..e8acc145 --- /dev/null +++ b/scripts/bootstrap.py @@ -0,0 +1,30 @@ +#!/usr/bin/env python3 +"""Create a private local secret directory once; never rotate existing volumes implicitly.""" + +import os +import secrets +from pathlib import Path + +root = Path(__file__).resolve().parents[1] +private = root / "secrets" +private.mkdir(mode=0o700, exist_ok=True) +os.chmod(private, 0o700) +password_file = private / "postgres_password" +if not password_file.exists(): + password_file.write_text(secrets.token_urlsafe(32)) +password = password_file.read_text().strip() +values = { + "database_url": "postgresql://messenger:" + password + "@postgres:5432/messenger", + "cache_url": "redis://cache:6379/0", +} +for name, value in values.items(): + path = private / name + if not path.exists(): + path.write_text(value) +# The parent directory is private on the host; files must be readable by non-root API +# through Compose's file-backed secret mount (uid/mode mapping is not portable). +for path in private.iterdir(): + os.chmod(path, 0o644) +if not (root / ".env").exists(): + (root / ".env").write_text("PUBLIC_PORT=8083\nSESSION_TTL_SECONDS=3600\n") +print("Local configuration ready; existing secret values preserved.") diff --git a/scripts/container_snapshot.py b/scripts/container_snapshot.py new file mode 100644 index 00000000..3c84fd55 --- /dev/null +++ b/scripts/container_snapshot.py @@ -0,0 +1,14 @@ +"""Record non-secret container identity/lifecycle fields for restart evidence.""" +import json +import subprocess +import sys +from pathlib import Path + +ids = subprocess.check_output(["docker", "compose", "ps", "-q"], text=True).split() +rows = [] +for cid in ids: + raw = json.loads(subprocess.check_output(["docker", "inspect", cid], text=True))[0] + rows.append({"id": cid, "service": raw["Config"]["Labels"]["com.docker.compose.service"], + "image_id": raw["Image"], "started_at": raw["State"]["StartedAt"], + "cpu_quota": raw["HostConfig"]["NanoCpus"], "memory": raw["HostConfig"]["Memory"]}) +Path(sys.argv[1]).write_text(json.dumps(rows, indent=2) + "\n") diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..1ca13129 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,7 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +python3 scripts/container_snapshot.py evidence/restart-before.json +docker compose restart postgres cache api lb +docker compose up -d --wait --no-recreate +python3 scripts/container_snapshot.py evidence/restart-after.json diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100755 index 00000000..2d4e8376 --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,14 @@ +#!/bin/sh +# Sequential replacement; never stop the surviving healthy replica. +set -eu +cd "$(dirname "$0")/.." +: "${API_IMAGE:?Set API_IMAGE to the already built target image}" +export API_IMAGE +ids=$(docker compose ps -q api) +for id in $ids; do + python3 scripts/wait_replicas.py 2 + docker stop --time 8 "$id" >/dev/null + docker rm "$id" >/dev/null + docker compose up -d --no-deps --no-recreate --scale api=2 --wait api + python3 scripts/wait_replicas.py 2 +done diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..3d9eb6a1 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +python3 scripts/stop_one.py diff --git a/scripts/stop_one.py b/scripts/stop_one.py new file mode 100644 index 00000000..8daf4e0c --- /dev/null +++ b/scripts/stop_one.py @@ -0,0 +1,19 @@ +"""Map a process alias to its real container, then leave exactly it stopped.""" +import json +import os +import subprocess + +wanted = os.environ["TARGET_INSTANCE_ID"] +ids = subprocess.check_output(["docker", "compose", "ps", "-q", "api"], text=True).split() +for cid in ids: + result = subprocess.run( + ["docker", "exec", cid, "python", "-c", + "import urllib.request; r=urllib.request.urlopen('http://127.0.0.1:8080/health/live'); print(r.headers['X-Instance-Id'])"], + text=True, capture_output=True, check=False, + ) + if result.returncode == 0 and result.stdout.strip() == wanted: + subprocess.run(["docker", "stop", "--time", "8", cid], check=True, stdout=subprocess.DEVNULL) + print(json.dumps({"stopped_container": cid, "instance_id": wanted})) + break +else: + raise SystemExit("Target instance not found among this project's API containers") diff --git a/scripts/verify_readiness.py b/scripts/verify_readiness.py new file mode 100644 index 00000000..7920ec46 --- /dev/null +++ b/scripts/verify_readiness.py @@ -0,0 +1,53 @@ +"""A live process with lost DB network must be excluded by the LB.""" +import json +import subprocess +import sys +import time +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) +from client import Client + + +def cmd(*args): + return subprocess.check_output(args, cwd=ROOT, text=True).strip() + + +def main(): + c = Client("http://127.0.0.1:8083") + actor = c.user("readiness") + target = cmd("docker", "compose", "ps", "-q", "api").split()[0] + raw = json.loads(cmd("docker", "inspect", target))[0] + backend = next(n for n in raw["NetworkSettings"]["Networks"] if n.endswith("_backend")) + probe = """import json,urllib.request,urllib.error +try: r=urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=8) +except urllib.error.HTTPError as e: r=e +print(json.dumps({'status':r.code,'alias':r.headers['X-Instance-Id']}))""" + initial = json.loads(cmd("docker", "exec", target, "python", "-c", probe)) + assert initial["status"] == 200 + started = time.monotonic() + cmd("docker", "network", "disconnect", backend, target) + try: + failed = json.loads(cmd("docker", "exec", target, "python", "-c", probe)) + assert failed["status"] == 503 + time.sleep(4) + observations = [] + for _ in range(30): + response = c.call("GET", "/api/v1/users/me", actor=actor, schema="User") + alias = response["headers"]["X-Instance-Id"] + assert alias != initial["alias"] + observations.append(alias) + result = {"target": target, "failed_instance": initial["alias"], "direct_readiness": 503, + "seconds_until_verification": time.monotonic() - started, + "lb_successful_requests": len(observations), "lb_instances": sorted(set(observations))} + finally: + cmd("docker", "network", "connect", "--alias", "api", backend, target) + subprocess.run([sys.executable, "scripts/wait_replicas.py", "2"], cwd=ROOT, check=True) + result["recovered_two_instances"] = True + (ROOT / "evidence/readiness-isolation.json").write_text(json.dumps(result, indent=2) + "\n") + print(json.dumps(result, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/scripts/verify_replicas.py b/scripts/verify_replicas.py new file mode 100644 index 00000000..ecb84282 --- /dev/null +++ b/scripts/verify_replicas.py @@ -0,0 +1,95 @@ +"""Stop each real API process under traffic; retain confirmed writes and source aliases.""" +import json +import os +import subprocess +import sys +import threading +import time +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) +from client import Client, Failure + + +def compose(*args): + return subprocess.check_output(["docker", "compose", *args], cwd=ROOT, text=True) + + +def aliases(): + result = {} + for cid in compose("ps", "-q", "api").split(): + alias = subprocess.check_output([ + "docker", "exec", cid, "python", "-c", + "import urllib.request; print(urllib.request.urlopen('http://127.0.0.1:8080/health/live').headers['X-Instance-Id'])", + ], text=True).strip() + result[cid] = alias + return result + + +def main(): + compose("up", "-d", "--no-recreate", "--wait") + subprocess.run([sys.executable, "scripts/wait_replicas.py", "2"], cwd=ROOT, check=True) + c = Client("http://127.0.0.1:8083") + actor, _, _, chat = c.bootstrap() + initial = aliases() + runs = [] + for target_container, target_alias in initial.items(): + successful, errors = [], [] + stop = threading.Event() + stopped_at = None + + def traffic(): + while not stop.is_set(): + try: + response = c.message(actor, chat, "failover-proof") + successful.append({"at": time.monotonic(), "id": response["json"]["id"], + "instance": response["headers"]["X-Instance-Id"]}) + except Failure: + errors.append(time.monotonic()) + + started = time.monotonic() + thread = threading.Thread(target=traffic) + thread.start() + time.sleep(1) + stopped_at = time.monotonic() + subprocess.run(["scripts/stop-one.sh"], cwd=ROOT, + env={**os.environ, "TARGET_INSTANCE_ID": target_alias}, check=True) + time.sleep(4) + stop.set() + thread.join() + elapsed = time.monotonic() - started + after = [x for x in successful if x["at"] > stopped_at] + assert after and all(x["instance"] != target_alias for x in after[-5:]) + assert min(x["at"] for x in after) - stopped_at <= 10 + state = json.loads(subprocess.check_output(["docker", "inspect", target_container], text=True))[0]["State"] + assert not state["Running"] + runs.append({"target_container": target_container, "target_alias": target_alias, + "successful_writes": len(successful), "failed_attempts": len(errors), + "successful_rps": len(successful) / elapsed, + "recovery_seconds": min(x["at"] for x in after) - stopped_at, + "observed_after": sorted({x["instance"] for x in after[-5:]}), + "target_running_after_hook": state["Running"]}) + subprocess.run(["docker", "start", target_container], check=True, stdout=subprocess.DEVNULL) + subprocess.run([sys.executable, "scripts/wait_replicas.py", "2"], cwd=ROOT, check=True) + # Verify every acknowledged write, without assuming failed requests did not commit. + items, cursor = [], None + while True: + path = f"/api/v1/chats/{chat['id']}/messages?limit=100" + if cursor: + path += "&cursor=" + cursor + page = c.call("GET", path, actor=actor, schema="MessagePage")["json"] + items.extend(page["items"]) + cursor = page["next_cursor"] + if cursor is None: + break + ids = {x["id"] for x in items} + assert all(x["id"] in ids for x in successful) + runs[-1]["all_confirmed_present"] = True + report = {"real_instances_before": initial, "runs": runs, "pass": True} + (ROOT / "evidence/replica-failures.json").write_text(json.dumps(report, indent=2) + "\n") + print(json.dumps(report, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/scripts/verify_rolling.py b/scripts/verify_rolling.py new file mode 100644 index 00000000..f7e0679b --- /dev/null +++ b/scripts/verify_rolling.py @@ -0,0 +1,79 @@ +"""Sequential real image replacement under message traffic.""" +import json +import os +import subprocess +import sys +import threading +import time +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) +from client import Client, Failure + + +def snapshots(): + ids = subprocess.check_output(["docker", "compose", "ps", "-q", "api"], cwd=ROOT, text=True).split() + rows = [] + for cid in ids: + raw = json.loads(subprocess.check_output(["docker", "inspect", cid], text=True))[0] + rows.append({"id": cid, "image_id": raw["Image"], "started_at": raw["State"]["StartedAt"]}) + return rows + + +def main(): + subprocess.run(["docker", "build", "-t", "mtusi-vasilev:lab3-rolling", "-"], + input="FROM mtusi-vasilev:lab3\nLABEL org.mtusi.rolling-proof=revision-2\n", text=True, check=True) + before = snapshots() + c = Client("http://127.0.0.1:8083") + actor, _, _, chat = c.bootstrap() + stop = threading.Event() + successes, errors = [], [] + def traffic(): + while not stop.is_set(): + try: + response = c.message(actor, chat, "rolling-proof") + successes.append({"id": response["json"]["id"], "at": time.monotonic(), + "instance": response["headers"]["X-Instance-Id"]}) + except Failure: + errors.append(time.monotonic()) + started = time.monotonic() + thread = threading.Thread(target=traffic) + thread.start() + try: + time.sleep(1) + subprocess.run(["scripts/rolling-update.sh"], cwd=ROOT, + env={**os.environ, "API_IMAGE": "mtusi-vasilev:lab3-rolling"}, check=True) + time.sleep(2) + finally: + stop.set() + thread.join() + elapsed = time.monotonic() - started + after = snapshots() + assert not {x["id"] for x in before} & {x["id"] for x in after} + assert {x["image_id"] for x in before} != {x["image_id"] for x in after} + items, cursor = [], None + while True: + path = f"/api/v1/chats/{chat['id']}/messages?limit=100" + if cursor: + path += "&cursor=" + cursor + page = c.call("GET", path, actor=actor, schema="MessagePage")["json"] + items.extend(page["items"]) + cursor = page["next_cursor"] + if cursor is None: + break + assert {x["id"] for x in successes} <= {x["id"] for x in items} + times = [started, *[x["at"] for x in successes], started + elapsed] + result = {"before": before, "after": after, "successful_writes": len(successes), + "failed_attempts": len(errors), "elapsed_seconds": elapsed, + "successful_rps": len(successes) / elapsed, + "observed_instances": sorted({x["instance"] for x in successes}), + "largest_success_gap_seconds": max(b-a for a,b in zip(times,times[1:])), + "all_confirmed_present": True, + "note": "Target image differs by revision label; same API/schema. This verifies sequential replacement, not arbitrary schema compatibility."} + (ROOT / "evidence/rolling-update.json").write_text(json.dumps(result, indent=2) + "\n") + print(json.dumps(result, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/scripts/wait_replicas.py b/scripts/wait_replicas.py new file mode 100644 index 00000000..8fa1ff51 --- /dev/null +++ b/scripts/wait_replicas.py @@ -0,0 +1,21 @@ +import os +import sys +import time +import urllib.error +import urllib.request + +wanted = int(sys.argv[1]) +url = "http://127.0.0.1:" + os.environ.get("PUBLIC_PORT", "8083") + "/health/ready" +deadline = time.monotonic() + 40 +seen = set() +while time.monotonic() < deadline: + try: + with urllib.request.urlopen(url, timeout=2) as response: + seen.add(response.headers["X-Instance-Id"]) + if len(seen) >= wanted: + break + except (urllib.error.URLError, TimeoutError): + seen.clear() + time.sleep(0.1) +else: + raise SystemExit("LB did not expose enough healthy replicas") diff --git a/src/messenger/__init__.py b/src/messenger/__init__.py new file mode 100644 index 00000000..58ffea15 --- /dev/null +++ b/src/messenger/__init__.py @@ -0,0 +1 @@ +"""Учебный REST-мессенджер.""" diff --git a/src/messenger/__main__.py b/src/messenger/__main__.py new file mode 100644 index 00000000..5b5cda10 --- /dev/null +++ b/src/messenger/__main__.py @@ -0,0 +1,12 @@ +import os + +import uvicorn + +uvicorn.run( + "messenger.app:app", + host=os.getenv("APP_HOST", "0.0.0.0"), + port=int(os.getenv("APP_PORT", "8080")), + workers=1, + access_log=False, + timeout_graceful_shutdown=5, +) diff --git a/src/messenger/app.py b/src/messenger/app.py new file mode 100644 index 00000000..7f1a820f --- /dev/null +++ b/src/messenger/app.py @@ -0,0 +1,220 @@ +import base64 +import binascii +import json +import logging +import os +import re +import time +from contextlib import asynccontextmanager +from uuid import uuid4 + +from fastapi import Depends, FastAPI, Request, Response +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from starlette.exceptions import HTTPException + +from .domain import Failure, boundary, identifier, page +from .models import CreateChat, CreateMessage, CreateUser +from .postgres import PostgresStore + +logger = logging.getLogger("messenger") +logging.basicConfig(level=os.getenv("LOG_LEVEL", "INFO"), format="%(message)s") +INSTANCE_ID = str(uuid4()) + +CODES = { + 400: "invalid_request", + 401: "unauthorized", + 404: "not_found", + 409: "conflict", + 413: "payload_too_large", + 415: "unsupported_media_type", + 429: "rate_limited", + 503: "unavailable", + 500: "internal_error", +} + + +@asynccontextmanager +async def lifespan(app): + app.state.store = PostgresStore() + logger.info(json.dumps({"event": "started", "storage": "postgres"})) + yield + app.state.store.close() + logger.info(json.dumps({"event": "stopped"})) + + +app = FastAPI(lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None) + + +def error(request, status, message, headers=None): + return JSONResponse( + { + "error": { + "code": CODES.get(status, "invalid_request"), + "message": message, + "request_id": request.state.request_id, + } + }, + status_code=status, + headers=headers, + ) + + +@app.middleware("http") +async def request_log(request: Request, call_next): + request.state.request_id = str(uuid4()) + start = time.perf_counter() + try: + if request.method == "POST" and request.url.path == "/api/v1/auth/sessions" and await request.body(): + response = error(request, 400, "Вход не принимает тело запроса") + else: + response = await call_next(request) + except Exception: + logger.error( + json.dumps({"event": "unexpected_error", "request_id": request.state.request_id}) + ) + response = error(request, 500, "Внутренняя ошибка") + response.headers["X-Request-Id"] = request.state.request_id + response.headers["X-Instance-Id"] = INSTANCE_ID + route = request.scope.get("route") + logger.info( + json.dumps( + { + "event": "request", + "request_id": request.state.request_id, + "method": request.method, + "route": getattr(route, "path", "unknown"), + "status": response.status_code, + "duration_ms": round((time.perf_counter() - start) * 1000, 3), + } + ) + ) + return response + + +@app.exception_handler(Failure) +async def domain_error(request, exc): + return error(request, exc.status, exc.message, exc.headers) + + +@app.exception_handler(RequestValidationError) +async def validation_error(request, exc): + return error(request, 400, "Неверный JSON или поля запроса") + + +@app.exception_handler(HTTPException) +async def http_error(request, exc): + return error(request, exc.status_code, "Неверный запрос", exc.headers) + + +def bearer_failure(): + return Failure( + 401, "Требуется действующая сессия", {"WWW-Authenticate": 'Bearer realm="messenger"'} + ) + + +def bearer(request): + parts = request.headers.get("Authorization", "").split() + if len(parts) != 2 or parts[0].lower() != "bearer": + raise bearer_failure() + return parts[1] + + +def actor(request: Request): + user = request.app.state.store.authenticate(bearer(request)) + if user is None: + raise bearer_failure() + return user + + +@app.post("/api/v1/auth/sessions", status_code=201) +def login(request: Request): + headers = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'} + parts = request.headers.get("Authorization", "").split() + try: + if len(parts) != 2 or parts[0].lower() != "basic" or len(parts[1]) > 2048: + raise ValueError + decoded = base64.b64decode(parts[1], validate=True).decode("utf-8") + username, password = decoded.split(":", 1) + if not re.fullmatch(r"[a-z0-9_]{3,32}", username) or not 12 <= len(password) <= 128: + raise ValueError + except (ValueError, UnicodeError, binascii.Error): + raise Failure(401, "Неверные учётные данные", headers) from None + session = request.app.state.store.login(username, password) + if session is None: + raise Failure(401, "Неверные учётные данные", headers) + return session + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def logout(request: Request, user=Depends(actor)): + if not request.app.state.store.logout(bearer(request)): + raise bearer_failure() + return Response(status_code=204) + + +def pagination(request, scope): + allowed = {"limit", "cursor"} + if any(k not in allowed for k in request.query_params): + raise Failure(400, "Неизвестный параметр запроса") + if any(len(request.query_params.getlist(k)) > 1 for k in allowed): + raise Failure(400, "Повторный параметр запроса") + value = request.query_params.get("limit", "50") + if len(value) > 3 or not re.fullmatch(r"[0-9]+", value) or not 1 <= int(value) <= 100: + raise Failure(400, "limit должен быть целым от 1 до 100") + return int(value), boundary(scope, request.query_params.get("cursor")) + + +@app.get("/health/live") +def live(): + return {"status": "ok"} + + +@app.get("/health/ready") +def ready(request: Request): + if not request.app.state.store.ready(): + raise Failure(503, "Хранилище недоступно") + return {"status": "ok"} + + +@app.post("/api/v1/users", status_code=201) +def register(data: CreateUser, request: Request): + return request.app.state.store.register(data.model_dump(mode="json")) + + +@app.get("/api/v1/users/me") +def me(user=Depends(actor)): + return user + + +@app.post("/api/v1/chats", status_code=201) +def create_chat(data: CreateChat, request: Request, user=Depends(actor)): + return request.app.state.store.create_chat(user["id"], data.model_dump(mode="json")) + + +@app.get("/api/v1/chats") +def chats(request: Request, user=Depends(actor)): + scope = "chats:" + user["id"] + limit, after = pagination(request, scope) + return page(request.app.state.store.list_chats(user["id"], after, limit), limit, scope) + + +@app.get("/api/v1/chats/{chat_id}") +def chat(chat_id: str, request: Request, user=Depends(actor)): + return request.app.state.store.chat(user["id"], identifier(chat_id)) + + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +def send(chat_id: str, data: CreateMessage, request: Request, user=Depends(actor)): + key = request.headers.get("Idempotency-Key", "") + if not re.fullmatch(r"[A-Za-z0-9._:-]{1,128}", key): + raise Failure(400, "Требуется корректный Idempotency-Key") + return request.app.state.store.send(user["id"], identifier(chat_id), data.text, key) + + +@app.get("/api/v1/chats/{chat_id}/messages") +def history(chat_id: str, request: Request, user=Depends(actor)): + cid = identifier(chat_id) + scope = "messages:" + cid + limit, after = pagination(request, scope) + return page(request.app.state.store.history(user["id"], cid, after, limit), limit, scope) diff --git a/src/messenger/config.py b/src/messenger/config.py new file mode 100644 index 00000000..a4b08821 --- /dev/null +++ b/src/messenger/config.py @@ -0,0 +1,10 @@ +import os +from pathlib import Path + + +def secret(name: str) -> str: + filename = os.environ.get(name + "_FILE") + value = Path(filename).read_text().strip() if filename else os.environ.get(name, "") + if not value: + raise RuntimeError("Отсутствует настройка " + name) + return value diff --git a/src/messenger/domain.py b/src/messenger/domain.py new file mode 100644 index 00000000..1415db7e --- /dev/null +++ b/src/messenger/domain.py @@ -0,0 +1,54 @@ +import base64 +import json +import re +from datetime import UTC, datetime +from uuid import UUID + + +class Failure(Exception): + def __init__(self, status: int, message: str, headers: dict | None = None): + self.status = status + self.message = message + self.headers = headers or {} + + +def timestamp() -> str: + return datetime.now(UTC).isoformat(timespec="microseconds").replace("+00:00", "Z") + + +def identifier(value: str) -> str: + try: + return str(UUID(value)) + except (ValueError, TypeError, AttributeError): + raise Failure(400, "Некорректный UUID") from None + + +def boundary(scope: str, cursor: str | None) -> tuple[str, str] | None: + if cursor is None: + return None + try: + if not cursor or len(cursor) > 1024 or not re.fullmatch(r"[A-Za-z0-9_-]+", cursor): + raise ValueError + data = json.loads(base64.urlsafe_b64decode(cursor + "=" * (-len(cursor) % 4))) + if not isinstance(data, list) or len(data) != 4 or data[:2] != [1, scope]: + raise ValueError + date, uid = data[2:] + if not isinstance(date, str) or not date.endswith("Z"): + raise ValueError + datetime.fromisoformat(date.replace("Z", "+00:00")) + if not isinstance(uid, str) or str(UUID(uid)) != uid: + raise ValueError + return date, uid + except (ValueError, TypeError, KeyError, UnicodeError): + raise Failure(400, "Некорректный cursor или область запроса") from None + + +def page(items: list[dict], limit: int, scope: str) -> dict: + more = len(items) > limit + selected = items[:limit] + cursor = None + if more: + last = selected[-1] + payload = json.dumps([1, scope, last["created_at"], last["id"]], separators=(",", ":")) + cursor = base64.urlsafe_b64encode(payload.encode()).decode().rstrip("=") + return {"items": selected, "next_cursor": cursor} diff --git a/src/messenger/migrate.py b/src/messenger/migrate.py new file mode 100644 index 00000000..f4486882 --- /dev/null +++ b/src/messenger/migrate.py @@ -0,0 +1,32 @@ +import hashlib +from pathlib import Path + +import psycopg + +from .config import secret + + +def migrate(): + with psycopg.connect(secret("DATABASE_URL")) as conn: + # Serialize independent migration processes without changing application data. + conn.execute("SELECT pg_advisory_xact_lock(2301002)") + conn.execute( + "CREATE TABLE IF NOT EXISTS schema_migrations " + "(name text PRIMARY KEY, checksum text NOT NULL)" + ) + for path in sorted(Path("migrations").glob("*.sql")): + checksum = hashlib.sha256(path.read_bytes()).hexdigest() + old = conn.execute( + "SELECT checksum FROM schema_migrations WHERE name=%s", (path.name,) + ).fetchone() + if old: + if old[0] != checksum: + raise RuntimeError("Изменена применённая миграция: " + path.name) + continue + conn.execute(path.read_text()) + conn.execute("INSERT INTO schema_migrations VALUES (%s,%s)", (path.name, checksum)) + print("Applied", path.name) + + +if __name__ == "__main__": + migrate() diff --git a/src/messenger/models.py b/src/messenger/models.py new file mode 100644 index 00000000..2211208b --- /dev/null +++ b/src/messenger/models.py @@ -0,0 +1,52 @@ +import re +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator + + +class RequestModel(BaseModel): + model_config = ConfigDict(extra="forbid") + + @field_validator("*", mode="after") + @classmethod + def nonblank(cls, value): + if isinstance(value, str) and not value.strip(): + raise ValueError("Строка не может состоять из пробелов") + return value + + +class CreateUser(RequestModel): + username: StrictStr = Field(pattern=r"^[a-z0-9_]{3,32}$") + display_name: StrictStr = Field(min_length=1, max_length=100) + password: StrictStr = Field(min_length=12, max_length=128) + + @field_validator("username") + @classmethod + def full_username(cls, value): + if not re.fullmatch(r"[a-z0-9_]{3,32}", value): + raise ValueError("Неверное имя пользователя") + return value + + +class CreateChat(RequestModel): + title: StrictStr = Field(min_length=1, max_length=100) + member_ids: list[UUID] = Field(min_length=1, max_length=100) + + @field_validator("member_ids", mode="before") + @classmethod + def string_ids(cls, value): + if not isinstance(value, list) or any(not isinstance(x, str) for x in value): + raise ValueError("Ожидается массив UUID-строк") + return value + + @field_validator("member_ids") + @classmethod + def unique_ids(cls, value): + if len(set(value)) != len(value): + raise ValueError("Участники не должны повторяться") + return value + + +class CreateMessage(RequestModel): + text: StrictStr = Field(min_length=1, max_length=4000) + attachment_ids: list[UUID] = Field(default_factory=list, max_length=0) diff --git a/src/messenger/postgres.py b/src/messenger/postgres.py new file mode 100644 index 00000000..69f76952 --- /dev/null +++ b/src/messenger/postgres.py @@ -0,0 +1,292 @@ +import hashlib +import json +import logging +import os +import secrets +from contextlib import contextmanager +from datetime import UTC, datetime, timedelta +from threading import BoundedSemaphore +from uuid import UUID, uuid4 + +import psycopg +import redis +from argon2 import PasswordHasher +from argon2.exceptions import VerificationError +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool, PoolTimeout, TooManyRequests + +from .config import secret +from .domain import Failure, timestamp + +logger = logging.getLogger("messenger") +KDF_SLOTS = BoundedSemaphore(2) +KDF = PasswordHasher(time_cost=2, memory_cost=65536, parallelism=1) +DUMMY_HASH = KDF.hash("invalid-user-dummy-password") + + +class DeadlineConnection(psycopg.Connection): + def wait(self, gen, interval=0.1, timeout=None): + try: + return super().wait(gen, interval=interval, timeout=timeout or 3.0) + except psycopg.errors._WaitTimeout: + # A paused server cannot complete cancellation. Discard an uncertain + # connection instead of returning it to the pool or waiting forever. + self.pgconn.finish() + raise + + +def public(row): + return { + k: ( + str(v) + if isinstance(v, UUID) + else v.astimezone(UTC).isoformat(timespec="microseconds").replace("+00:00", "Z") + if isinstance(v, datetime) + else bytes(v).decode("utf-8") + if isinstance(v, (bytes, memoryview)) + else v + ) + for k, v in row.items() + if k not in {"password_hash", "token_digest"} + } + + +class PostgresStore: + def __init__(self): + self.pool = ConnectionPool( + secret("DATABASE_URL"), + connection_class=DeadlineConnection, + min_size=1, + max_size=int(os.getenv("POOL_MAX_SIZE", "8")), + timeout=2, + max_waiting=32, + kwargs={ + "autocommit": True, + "row_factory": dict_row, + "connect_timeout": 2, + "options": "-c statement_timeout=2500 -c lock_timeout=1500", + }, + check=ConnectionPool.check_connection, + ) + self.pool.wait(timeout=15) + self.cache = redis.Redis.from_url( + secret("CACHE_URL"), + socket_connect_timeout=0.2, + socket_timeout=0.2, + decode_responses=True, + ) + self.ttl = int(os.getenv("SESSION_TTL_SECONDS", "3600")) + if self.ttl < 1: + raise RuntimeError("SESSION_TTL_SECONDS должен быть положительным") + + @contextmanager + def connection(self): + try: + with self.pool.connection() as conn: + yield conn + except ( + psycopg.OperationalError, + psycopg.InterfaceError, + PoolTimeout, + TooManyRequests, + psycopg.errors.QueryCanceled, + psycopg.errors.LockNotAvailable, + ): + raise Failure(503, "Хранилище временно недоступно") from None + + def close(self): + self.cache.close() + self.pool.close() + + def ready(self): + try: + with self.connection() as conn: + conn.execute( + "SELECT u.id,c.id,m.chat_id,msg.id,s.token_digest,r.key " + "FROM users u,chats c,members m,messages msg,sessions s,message_requests r " + "WHERE false" + ) + return True + except (Failure, psycopg.Error): + return False + + def _cached_user(self, uid): + key = "user:v1:" + uid + try: + value = self.cache.get(key) + if value: + cached = json.loads(value) + if ( + isinstance(cached, dict) + and cached.get("id") == uid + and set(cached) == {"id", "username", "display_name", "created_at"} + ): + return cached + except (redis.RedisError, ValueError, TypeError): + logger.warning(json.dumps({"event": "cache_bypass"})) + user = self.user(uid) + if user: + try: + self.cache.setex(key, 60, json.dumps(user)) + except redis.RedisError: + logger.warning(json.dumps({"event": "cache_bypass"})) + return user + + def user(self, uid): + with self.connection() as conn: + row = conn.execute( + "SELECT id,username,display_name,created_at FROM users WHERE id=%s", (uid,) + ).fetchone() + return public(row) if row else None + + def register(self, data): + with KDF_SLOTS: + hashed = KDF.hash(data.pop("password")) + uid = str(uuid4()) + try: + with self.connection() as conn: + row = conn.execute( + "INSERT INTO users VALUES (%s,%s,%s,%s,%s) " + "RETURNING id,username,display_name,created_at", + (uid, data["username"], data["display_name"].encode("utf-8"), hashed, timestamp()), + ).fetchone() + return public(row) + except psycopg.errors.UniqueViolation: + raise Failure(409, "Имя пользователя занято") from None + + def login(self, username, password): + with self.connection() as conn: + row = conn.execute("SELECT * FROM users WHERE username=%s", (username,)).fetchone() + try: + with KDF_SLOTS: + KDF.verify(row["password_hash"] if row else DUMMY_HASH, password) + except VerificationError: + return None + if row is None: + return None + token = secrets.token_urlsafe(32) + digest = hashlib.sha256(token.encode()).hexdigest() + expires = datetime.now(UTC) + timedelta(seconds=self.ttl) + with self.connection() as conn: + conn.execute("INSERT INTO sessions VALUES (%s,%s,%s)", (digest, row["id"], expires)) + return { + "token": token, + "token_type": "Bearer", + "expires_at": public({"v": expires})["v"], + "user": public(row), + } + + def authenticate(self, token): + if not token or len(token) > 512: + return None + digest = hashlib.sha256(token.encode()).hexdigest() + # Session validity always comes from PostgreSQL, including on a cache hit. + with self.connection() as conn: + row = conn.execute( + "SELECT s.user_id FROM sessions s WHERE s.token_digest=%s AND s.expires_at>now()", + (digest,), + ).fetchone() + return self._cached_user(str(row["user_id"])) if row else None + + def logout(self, token): + with self.connection() as conn: + row = conn.execute( + "DELETE FROM sessions WHERE token_digest=%s AND expires_at>now() RETURNING user_id", + (hashlib.sha256(token.encode()).hexdigest(),), + ).fetchone() + return row is not None + + def create_chat(self, actor, data): + if actor not in data["member_ids"]: + raise Failure(400, "Вызывающий должен входить в чат") + cid = str(uuid4()) + try: + with self.connection() as conn, conn.transaction(): + row = conn.execute( + "INSERT INTO chats VALUES (%s,%s,%s) RETURNING *", + (cid, data["title"].encode("utf-8"), timestamp()), + ).fetchone() + for index, uid in enumerate(data["member_ids"]): + conn.execute("INSERT INTO members VALUES (%s,%s,%s)", (cid, uid, index)) + return {**public(row), "member_ids": data["member_ids"]} + except psycopg.errors.ForeignKeyViolation: + raise Failure(400, "Неизвестный участник") from None + + @staticmethod + def _chat(conn, actor, cid): + row = conn.execute( + "SELECT c.* FROM chats c JOIN members m ON m.chat_id=c.id " + "WHERE c.id=%s AND m.user_id=%s", + (cid, actor), + ).fetchone() + if row is None: + raise Failure(404, "Объект не найден") + members = conn.execute( + "SELECT user_id FROM members WHERE chat_id=%s ORDER BY position", (cid,) + ).fetchall() + return {**public(row), "member_ids": [str(m["user_id"]) for m in members]} + + def chat(self, actor, cid): + with self.connection() as conn: + return self._chat(conn, actor, cid) + + def list_chats(self, actor, after, limit): + with self.connection() as conn: + sql = "SELECT c.* FROM chats c JOIN members m ON m.chat_id=c.id WHERE m.user_id=%s" + params = [actor] + if after: + sql += " AND (c.created_at,c.id)>(%s,%s)" + params.extend(after) + sql += " ORDER BY c.created_at,c.id LIMIT %s" + params.append(limit + 1) + rows = conn.execute(sql, params).fetchall() + return [self._chat(conn, actor, str(row["id"])) for row in rows] + + def send(self, actor, cid, text, key): + body_digest = hashlib.sha256( + json.dumps({"text": text, "attachment_ids": []}, sort_keys=True, + ensure_ascii=False, separators=(",", ":")).encode() + ).hexdigest() + with self.connection() as conn, conn.transaction(): + self._chat(conn, actor, cid) + # Serializes exactly this semantic key across all API processes. Hash + # collisions can only serialize unrelated requests, never mix results. + scope = json.dumps([actor, "POST", cid, key], separators=(",", ":")) + lock = int.from_bytes(hashlib.sha256(scope.encode()).digest()[:8], "big", signed=True) + conn.execute("SELECT pg_advisory_xact_lock(%s)", (lock,)) + old = conn.execute( + "SELECT body_digest,response FROM message_requests " + "WHERE actor_id=%s AND chat_id=%s AND key=%s AND expires_at>now()", + (actor, cid, key), + ).fetchone() + if old: + if old["body_digest"] != body_digest: + raise Failure(409, "Ключ уже использован для другого сообщения") + return json.loads(bytes(old["response"]).decode("utf-8")) + conn.execute( + "DELETE FROM message_requests WHERE actor_id=%s AND chat_id=%s AND key=%s", + (actor, cid, key), + ) + row = conn.execute( + "INSERT INTO messages VALUES (%s,%s,%s,%s,%s) RETURNING *", + (str(uuid4()), cid, actor, text.encode("utf-8"), timestamp()), + ).fetchone() + response = public(row) + conn.execute( + "INSERT INTO message_requests(actor_id,chat_id,key,body_digest,response,expires_at) " + "VALUES (%s,%s,%s,%s,%s,now()+interval '24 hours')", + (actor, cid, key, body_digest, json.dumps(response).encode("utf-8")), + ) + return response + + def history(self, actor, cid, after, limit): + with self.connection() as conn: + self._chat(conn, actor, cid) + sql = "SELECT * FROM messages WHERE chat_id=%s" + params = [cid] + if after: + sql += " AND (created_at,id)>(%s,%s)" + params.extend(after) + sql += " ORDER BY created_at,id LIMIT %s" + params.append(limit + 1) + return [public(row) for row in conn.execute(sql, params).fetchall()] diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 00000000..6802a43b --- /dev/null +++ b/student-tests/test_api.py @@ -0,0 +1,187 @@ +import base64 +import os +import threading +import uuid +from concurrent.futures import ThreadPoolExecutor +from urllib.parse import quote + +import pytest +from client import LAB, Client + + +@pytest.fixture +def scenario(): + c = Client(os.environ.get("BASE_URL", "http://127.0.0.1:8081")) + return c, *c.bootstrap() + + +@pytest.mark.parametrize( + "body", + [ + {"text": ""}, + {"text": " \n\t"}, + {"text": 1}, + {"text": True}, + {"text": None}, + {"text": "x", "sender_id": str(uuid.uuid4())}, + {"text": "x", "unknown": 1}, + {"text": "x" * 4001}, + {}, + [], + ], +) +def test_invalid_message(scenario, body): + c, alice, _, _, chat = scenario + c.call("POST", f"/api/v1/chats/{chat['id']}/messages", 400, actor=alice, body=body) + + +def test_malformed_json(scenario): + c, alice, _, _, chat = scenario + c.call( + "POST", + f"/api/v1/chats/{chat['id']}/messages", + 400, + actor=alice, + raw=b'{"text":', + headers={"Content-Type": "application/json"}, + ) + + +def test_acl_and_unknown_chat(scenario): + c, alice, _, eve, chat = scenario + for cid in [chat["id"], str(uuid.uuid4())]: + for suffix in ["", "/messages"]: + c.call("GET", f"/api/v1/chats/{cid}{suffix}", 404, actor=eve) + c.call("POST", f"/api/v1/chats/{cid}/messages", 404, actor=eve, body={"text": "x"}, headers={"Idempotency-Key": str(uuid.uuid4())}) + c.call("GET", "/api/v1/chats/not-a-uuid", 400, actor=alice) + + +@pytest.mark.parametrize("name", ["ab", "UPPER", "a-b", "a" * 33, "имя", "abc\n"]) +def test_username_validation(scenario, name): + c, alice, *_ = scenario + body = {**alice["registration"], "username": name} + c.call("POST", "/api/v1/users", 400, body=body) + + +def test_unicode_and_limits(scenario): + c, alice, _, _, chat = scenario + text = "Ё👩‍💻漢字" * 500 + assert c.message(alice, chat, text)["json"]["text"] == text + c.call( + "POST", + "/api/v1/users", + 400, + body={ + **alice["registration"], + "username": "u_" + uuid.uuid4().hex[:12], + "display_name": " ", + }, + ) + + +@pytest.mark.parametrize("value", ["0", "101", "1.5", "true", "-1", "", "1&limit=2"]) +def test_invalid_limit(scenario, value): + c, alice, _, _, chat = scenario + c.call("GET", f"/api/v1/chats/{chat['id']}/messages?limit={value}", 400, actor=alice) + + +def test_pagination_and_cursor_scope(scenario): + c, alice, bob, _, chat = scenario + expected = [c.message(alice, chat, str(i))["json"] for i in range(13)] + path = f"/api/v1/chats/{chat['id']}/messages" + result, cursor, first = [], None, None + for i in range(20): + url = path + f"?limit={2 if i == 0 else 3}" + if cursor: + url += "&cursor=" + quote(cursor, safe="") + data = c.call("GET", url, actor=bob, schema="MessagePage")["json"] + result += data["items"] + cursor = data["next_cursor"] + first = first or cursor + if cursor is None: + break + assert result == sorted(expected, key=lambda m: (m["created_at"], m["id"])) + other = c.call( + "POST", + "/api/v1/chats", + 201, + actor=alice, + body={"title": "другой", "member_ids": [alice["id"]]}, + schema="Chat", + )["json"] + c.call("GET", f"/api/v1/chats/{other['id']}/messages?cursor={first}", 400, actor=alice) + c.call("GET", path + "?cursor=broken", 400, actor=alice) + + +def test_chat_validation_and_atomicity(scenario): + c, alice, bob, _, _ = scenario + before = c.call("GET", "/api/v1/chats?limit=100", actor=alice, schema="ChatPage")["json"] + for members in [ + [bob["id"]], + [alice["id"], alice["id"]], + [alice["id"], str(uuid.uuid4())], + [], + [123], + ]: + c.call( + "POST", + "/api/v1/chats", + 400, + actor=alice, + body={"title": "не должен появиться", "member_ids": members}, + ) + after = c.call("GET", "/api/v1/chats?limit=100", actor=alice, schema="ChatPage")["json"] + assert before == after + + +def test_concurrent_messages(scenario): + c, alice, bob, _, chat = scenario + barrier = threading.Barrier(10) + + def sender(i): + local = Client(c.base) + barrier.wait() + return [local.message(alice, chat, f"{i}:{j}")["json"] for j in range(10)] + + with ThreadPoolExecutor(max_workers=10) as pool: + sent = [m for batch in pool.map(sender, range(10)) for m in batch] + data = c.call( + "GET", f"/api/v1/chats/{chat['id']}/messages?limit=100", actor=bob, schema="MessagePage" + )["json"] + assert len(sent) == len({m["id"] for m in sent}) == len(data["items"]) == 100 + assert {m["id"] for m in sent} == {m["id"] for m in data["items"]} + assert data["next_cursor"] is None + + +def test_registration_race(scenario): + c, alice, *_ = scenario + body = {**alice["registration"], "username": "race_" + uuid.uuid4().hex[:12]} + barrier = threading.Barrier(10) + + def register(_): + local = Client(c.base) + barrier.wait() + return local.call("POST", "/api/v1/users", [201, 409], body=body)["status"] + + with ThreadPoolExecutor(max_workers=10) as pool: + statuses = list(pool.map(register, range(10))) + assert statuses.count(201) == 1 + assert statuses.count(409) == 9 + + +@pytest.mark.skipif(LAB < 2, reason="Сессии появляются в ЛР2") +def test_sessions(scenario): + c, alice, _, eve, _ = scenario + credential = base64.b64encode( + (alice["registration"]["username"] + ":wrong-password").encode() + ).decode() + c.call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": "Basic " + credential}) + c.call("GET", "/api/v1/users/me", 401, headers={"X-User-Id": alice["id"]}) + assert ( + c.call( + "GET", "/api/v1/users/me", actor=alice, headers={"X-User-Id": eve["id"]}, schema="User" + )["json"] + == alice["user"] + ) + c.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=alice) + c.call("GET", "/api/v1/users/me", 401, actor=alice) diff --git a/student-tests/test_edgecases.py b/student-tests/test_edgecases.py new file mode 100644 index 00000000..88ead657 --- /dev/null +++ b/student-tests/test_edgecases.py @@ -0,0 +1,99 @@ +import base64 +import json +import os +import uuid +from urllib.parse import quote + +import pytest +from client import LAB, Client + + +@pytest.fixture +def edge_scenario(): + client = Client(os.environ.get("BASE_URL", "http://127.0.0.1:8081")) + return client, *client.bootstrap() + + +def encoded_cursor(value): + return base64.urlsafe_b64encode(json.dumps(value).encode()).decode().rstrip("=") + + +@pytest.mark.parametrize("identity", ["missing", "malformed", "unknown"]) +def test_invalid_identity(edge_scenario, identity): + client, _, _, _, chat = edge_scenario + headers = {} + if identity == "malformed": + headers["X-User-Id"] = "not-a-uuid" + elif identity == "unknown": + headers["X-User-Id"] = str(uuid.uuid4()) + for path in ["/api/v1/users/me", "/api/v1/chats", f"/api/v1/chats/{chat['id']}/messages"]: + client.call("GET", path, 401, headers=headers) + + +@pytest.mark.parametrize("uid", [None, [], {}, 123, True, "not-a-uuid"]) +def test_cursor_rejects_non_uuid_boundary(edge_scenario, uid): + client, alice, _, _, chat = edge_scenario + payload = [1, "messages:" + chat["id"], "2026-10-30T12:00:00.000000Z", uid] + cursor = quote(encoded_cursor(payload), safe="") + client.call("GET", f"/api/v1/chats/{chat['id']}/messages?cursor={cursor}", 400, actor=alice) + + +@pytest.mark.parametrize( + "payload", [None, {}, [], [1], [1, "wrong-scope", "2026-10-30T12:00:00Z", str(uuid.uuid4())]] +) +def test_cursor_rejects_wrong_shape(edge_scenario, payload): + client, alice, _, _, chat = edge_scenario + cursor = quote(encoded_cursor(payload), safe="") + client.call("GET", f"/api/v1/chats/{chat['id']}/messages?cursor={cursor}", 400, actor=alice) + + +def test_request_id_is_present_and_not_reused(edge_scenario): + client, alice, _, _, _ = edge_scenario + first = client.call("GET", "/health/live", schema="Health") + second = client.call("GET", "/health/ready", schema="Health") + error = client.call("GET", "/api/v1/chats/malformed", 400, actor=alice) + values = [r["headers"]["X-Request-Id"] for r in [first, second, error]] + assert len(set(values)) == 3 + assert error["json"]["error"]["request_id"] == values[-1] + + +def test_unicode_codepoint_boundaries(edge_scenario): + client, alice, _, _, chat = edge_scenario + username = "unicode_" + uuid.uuid4().hex[:12] + registration = {"username": username, "display_name": "😀" * 100} + if LAB >= 2: + registration["password"] = "unicode-test-" + uuid.uuid4().hex + user = client.call( + "POST", + "/api/v1/users", + 201, + body=registration, + schema="User", + )["json"] + assert user["display_name"] == "😀" * 100 + client.call( + "POST", "/api/v1/users", 400, body={"username": username + "x", "display_name": "😀" * 101} + ) + message = client.message(alice, chat, "😀" * 4000)["json"] + assert message["text"] == "😀" * 4000 + client.call( + "POST", f"/api/v1/chats/{chat['id']}/messages", 400, actor=alice, body={"text": "😀" * 4001} + ) + + +def test_empty_history_and_cursor_exhaustion(edge_scenario): + client, alice, _, _, chat = edge_scenario + path = f"/api/v1/chats/{chat['id']}/messages" + empty = client.call("GET", path, actor=alice, schema="MessagePage")["json"] + assert empty == {"items": [], "next_cursor": None} + message = client.message(alice, chat, "одна запись")["json"] + data = client.call("GET", path + "?limit=1", actor=alice, schema="MessagePage")["json"] + assert data == {"items": [message], "next_cursor": None} + + +def test_missing_chat_is_hidden_like_foreign_chat(edge_scenario): + client, _, _, eve, chat = edge_scenario + foreign = client.call("GET", f"/api/v1/chats/{chat['id']}", 404, actor=eve)["json"] + missing = client.call("GET", f"/api/v1/chats/{uuid.uuid4()}", 404, actor=eve)["json"] + assert foreign["error"]["code"] == missing["error"]["code"] == "not_found" + assert foreign["error"]["message"] == missing["error"]["message"] diff --git a/student-tests/test_lab3.py b/student-tests/test_lab3.py new file mode 100644 index 00000000..b3d02276 --- /dev/null +++ b/student-tests/test_lab3.py @@ -0,0 +1,101 @@ +import base64 +import json +import os +import uuid +from concurrent.futures import ThreadPoolExecutor + +import pytest +from client import Client + + +@pytest.fixture(scope="module") +def shared(): + c = Client(os.environ["BASE_URL"]) + return c, *c.bootstrap() + + +def test_concurrent_idempotency_and_semantic_empty_attachments(shared): + c, alice, _, _, chat = shared + path = f"/api/v1/chats/{chat['id']}/messages" + key = uuid.uuid4().hex + + def post(i): + return Client(os.environ["BASE_URL"]).call( + "POST", path, 201, schema="Message", actor=alice, + body={"text": "same", **({"attachment_ids": []} if i % 2 else {})}, + headers={"Idempotency-Key": key}, + ) + + with ThreadPoolExecutor(max_workers=10) as pool: + results = list(pool.map(post, range(20))) + assert len({r["json"]["id"] for r in results}) == 1 + assert len({r["headers"]["X-Instance-Id"] for r in results}) >= 2 + assert all(r["json"] == results[0]["json"] for r in results) + c.call("POST", path, 409, actor=alice, body={"text": "different"}, + headers={"Idempotency-Key": key}) + + +def test_key_scope_and_acl(shared): + c, alice, bob, eve, chat = shared + path = f"/api/v1/chats/{chat['id']}/messages" + key = uuid.uuid4().hex + first = c.call("POST", path, 201, schema="Message", actor=alice, body={"text": "a"}, + headers={"Idempotency-Key": key})["json"] + other = c.call("POST", path, 201, schema="Message", actor=bob, body={"text": "b"}, + headers={"Idempotency-Key": key})["json"] + assert first["id"] != other["id"] + for _ in range(2): + c.call("POST", path, 404, actor=eve, body={"text": "a"}, + headers={"Idempotency-Key": key}) + + +@pytest.mark.parametrize("key", [None, "", "x" * 129, "bad key", "bad/key", "é"]) +def test_invalid_idempotency_key(shared, key): + c, alice, _, _, chat = shared + c.call("POST", f"/api/v1/chats/{chat['id']}/messages", 400, actor=alice, + body={"text": "x"}, headers={} if key is None else {"Idempotency-Key": key}) + + +def test_lossless_nul_message_replay_and_history(shared): + c, alice, _, _, chat = shared + key = uuid.uuid4().hex + path = f"/api/v1/chats/{chat['id']}/messages" + body = {"text": "abc\u0000def"} + first = c.call("POST", path, 201, schema="Message", actor=alice, body=body, + headers={"Idempotency-Key": key})["json"] + repeat = c.call("POST", path, 201, schema="Message", actor=alice, body=body, + headers={"Idempotency-Key": key})["json"] + assert first == repeat + assert first["text"] == body["text"] + history = c.call("GET", path, 200, schema="MessagePage", actor=alice)["json"]["items"] + assert next(m for m in history if m["id"] == first["id"]) == first + + +@pytest.mark.parametrize("uid", [[], {}, 123, False, None]) +def test_typed_invalid_cursor(shared, uid): + c, alice, _, _, chat = shared + payload = [1, "messages:" + chat["id"], "2026-10-30T12:00:00Z", uid] + cursor = base64.urlsafe_b64encode(json.dumps(payload).encode()).decode().rstrip("=") + c.call("GET", f"/api/v1/chats/{chat['id']}/messages?cursor={cursor}", 400, actor=alice) + + +def test_empty_cursor_and_bad_utf8(shared): + c, alice, _, _, chat = shared + for path in ["/api/v1/chats", f"/api/v1/chats/{chat['id']}/messages"]: + c.call("GET", path + "?cursor=", 400, actor=alice) + response = c.call("POST", "/api/v1/users", 400, raw=b"\xff", + headers={"Content-Type": "application/json"}) + assert response["json"]["error"]["code"] == "invalid_request" + assert response["headers"]["X-Instance-Id"] + c.call("GET", "/api/v1/users/me", 401, headers={"Authorization": "Bearer é"}) + + +def test_login_body_is_rejected(shared): + c, alice, *_ = shared + registration = alice["registration"] + basic = base64.b64encode( + (registration["username"] + ":" + registration["password"]).encode() + ).decode() + for body in [b"{}", b"{bad", b"x"]: + c.call("POST", "/api/v1/auth/sessions", 400, raw=body, + headers={"Authorization": "Basic " + basic}) diff --git a/student-tests/test_sessions.py b/student-tests/test_sessions.py new file mode 100644 index 00000000..0519f812 --- /dev/null +++ b/student-tests/test_sessions.py @@ -0,0 +1,62 @@ +import base64 +import uuid + +import pytest +from client import Client + + +@pytest.mark.parametrize("password", ["x" * 11, "x" * 129, "😀" * 129, 123, None, True]) +def test_password_contract(password): + import os + + c = Client(os.environ["BASE_URL"]) + c.call( + "POST", + "/api/v1/users", + 400, + body={ + "username": "pwd_" + uuid.uuid4().hex[:12], + "display_name": "Тест", + "password": password, + }, + ) + + +def test_full_unicode_password_and_colon(): + import os + + c = Client(os.environ["BASE_URL"]) + username = "pwd_" + uuid.uuid4().hex[:12] + password = "😀" * 126 + ":Я" + user = c.call( + "POST", + "/api/v1/users", + 201, + body={"username": username, "display_name": "Пароль128", "password": password}, + schema="User", + )["json"] + good = base64.b64encode((username + ":" + password).encode()).decode() + session = c.call( + "POST", + "/api/v1/auth/sessions", + 201, + headers={"Authorization": "bAsIc " + good}, + schema="Session", + )["json"] + actor = {"id": user["id"], "token": session["token"]} + assert session["user"] == user + bad = base64.b64encode((username + ":" + password[:-1] + "Б").encode()).decode() + c.call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": "Basic " + bad}) + c.call("GET", "/api/v1/users/me", 401, headers={"Authorization": "Basic " + good}) + c.call("GET", "/api/v1/users/me", actor=actor, schema="User") + c.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=actor) + c.call("GET", "/api/v1/users/me", 401, actor=actor) + + +@pytest.mark.parametrize("credential", ["Basic !invalid", "Basic", "Bearer abc", "", "Basic YTpi"]) +def test_invalid_basic(credential): + import os + + Client(os.environ["BASE_URL"]).call( + "POST", "/api/v1/auth/sessions", 401, headers={"Authorization": credential} + ) diff --git a/uv.lock b/uv.lock new file mode 100644 index 00000000..00cd36c1 --- /dev/null +++ b/uv.lock @@ -0,0 +1,701 @@ +version = 1 +revision = 3 +requires-python = "==3.12.*" + +[[package]] +name = "annotated-doc" +version = "0.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/8e/38aa427ed5402449e226975b649c5dc73ccadfefeb95e6aecb8f8ea4b6b6/annotated_doc-0.0.5.tar.gz", hash = "sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb", size = 10758, upload-time = "2026-07-28T13:50:58.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl", hash = "sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101", size = 5302, upload-time = "2026-07-28T13:50:57.239Z" }, +] + +[[package]] +name = "annotated-types" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/56/a8120250d128bed162cd73c76d45f6ef9991f3e068f62a8ee060afa3104a/annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7", size = 15893, upload-time = "2026-07-23T20:16:13.995Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" }, +] + +[[package]] +name = "anyio" +version = "4.15.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/d2/f4d173e22df740bc37b1db102b386ba719b66e95b0f0d751f556b387e6d2/anyio-4.15.1.tar.gz", hash = "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94", size = 276966, upload-time = "2026-09-05T10:42:39.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" }, +] + +[[package]] +name = "argon2-cffi" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0b/43/bb8b6e8708d49a5ab36781333af092d9f483b198a2710d01281204640055/argon2_cffi_bindings-26.1.0.tar.gz", hash = "sha256:63505c71542a44b68b1e38060450fb006404170da375feb31af153e7f9c6205d", size = 1790807, upload-time = "2026-08-20T07:44:22.492Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/d2/0ae991f1b2181e5be49007c574710a800ad36c2978683addb3e67c474e55/argon2_cffi_bindings-26.1.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:21ca0396fe5ec995dd54431c32698189666f9224810acfa752e50d2bd94d9df2", size = 25521, upload-time = "2026-08-20T07:32:43.019Z" }, + { url = "https://files.pythonhosted.org/packages/7e/e4/ad91d8297638aa2258aad4501c306aca99480dfe76ccd638173fa3702db9/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78de2d65e0b9ea7ce9d1b1c3e87297b2d7305a02c266ee2a2d6910daddd7ee69", size = 27177, upload-time = "2026-08-20T07:32:44.158Z" }, + { url = "https://files.pythonhosted.org/packages/6f/86/5363df11b86d02cf3662208e7406496327649cc90eb365bf6f4e8a54a41f/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:27f1821903e2ceadcb88ec2b45ef190897b7682449c772f4d9b53e42c520cf29", size = 26597, upload-time = "2026-08-20T07:32:45.172Z" }, + { url = "https://files.pythonhosted.org/packages/f4/b5/a14dcc592652347dad23ee93b278a4da5d2a25c9ed3ebd10d68eea823a4f/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d88e5f7e60f28ae0b0cc6b2f16c43e87cd642a196a86f85e0d8bb6fe016fc16d", size = 27403, upload-time = "2026-08-20T07:32:46.13Z" }, + { url = "https://files.pythonhosted.org/packages/b3/81/b4a20d4902af7f796390bf9245ff83c5217dfa7367efa1d14986956c482b/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:34b7d9c24a4165a2c61cc8ae11d44d48c9ce2830fb536cb7914e11fdd9962728", size = 27132, upload-time = "2026-08-20T07:32:47.13Z" }, + { url = "https://files.pythonhosted.org/packages/7e/1b/c8de358af07b1c490e0fcb863ef98e46ddb486e45567aca5a60bd68d9daa/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:224865cbbcb7a2bd1356741dff12b0134df726b6d44bb7b500df8e303cbd9e81", size = 27588, upload-time = "2026-08-20T07:32:48.087Z" }, + { url = "https://files.pythonhosted.org/packages/48/2f/7ee62a6e79f9309f9d9982d301b22a00010adb580c05c8109b94d7b33de0/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ffff613aaa9ce6236766e2fc6dc560bb5abde7a2e2416e3db1f9ae395a2b4dd4", size = 26785, upload-time = "2026-08-20T07:32:48.977Z" }, + { url = "https://files.pythonhosted.org/packages/e9/10/960d0ee93d4897741bcaf4799c697dae2d81499f66fd1ed042a7dd54c1f4/argon2_cffi_bindings-26.1.0-cp310-abi3-win32.whl", hash = "sha256:a86c069c91a747a2c4e5c51473590aeb48172fff9b2130d23729a42d98665ecb", size = 23898, upload-time = "2026-08-20T07:32:50.114Z" }, + { url = "https://files.pythonhosted.org/packages/6d/3a/0cc14a05810e6add9bce5e87693334baa2222de5f647fa31781885b6573f/argon2_cffi_bindings-26.1.0-cp310-abi3-win_amd64.whl", hash = "sha256:2c36ff87b5dfaa477d0bd51e9d7f6abdae7c8955d2983c97419085d842154b3e", size = 25730, upload-time = "2026-08-20T07:32:51.091Z" }, + { url = "https://files.pythonhosted.org/packages/4e/db/d83cf2af140547f0b9cdaece05b2dc2dcbf991be4667331d073eff771435/argon2_cffi_bindings-26.1.0-cp310-abi3-win_arm64.whl", hash = "sha256:f9c4420a7a864fe1b86ce35befc95b8e39fb852493b81cf798671ddc265de638", size = 24478, upload-time = "2026-08-20T07:32:52.111Z" }, +] + +[[package]] +name = "attrs" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" }, +] + +[[package]] +name = "certifi" +version = "2026.10.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" }, +] + +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/69/43965eccfdead3b9220015fd1320e117be8c6ed01a62ffab76eeb752f5d5/cffi-2.1.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0", size = 184821, upload-time = "2026-08-03T21:19:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/54/7d/16e5a096677b5e313ca80cd5e5170efa3ea44624a82bb111925522da64b1/cffi-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf", size = 184719, upload-time = "2026-08-03T21:19:46.129Z" }, + { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", size = 214799, upload-time = "2026-08-03T21:19:47.218Z" }, + { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", size = 222389, upload-time = "2026-08-03T21:19:48.331Z" }, + { url = "https://files.pythonhosted.org/packages/6a/5b/717f1526b9957b34456313c31645c5b82b8fb5c3fe9e4752999be7128bfc/cffi-2.1.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50", size = 210249, upload-time = "2026-08-03T21:19:49.543Z" }, + { url = "https://files.pythonhosted.org/packages/64/b3/f8aa4f3e34986c7e4ec45072d1b1b9dd295b6b18007b45518d79726dd725/cffi-2.1.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e", size = 208775, upload-time = "2026-08-03T21:19:50.918Z" }, + { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", size = 225232, upload-time = "2026-08-03T21:19:53.109Z" }, + { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" }, + { url = "https://files.pythonhosted.org/packages/80/fb/0bb75b7039588c074b37ae99f40d9bfddf990ecb2fbc346ebccd2e56b9be/cffi-2.1.1-cp312-cp312-win32.whl", hash = "sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e", size = 175292, upload-time = "2026-08-03T21:19:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/d9/79/615cc094e2fb508cade7de88d3b4f6c4ec2bab695c97bce9153dc65aadf5/cffi-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a", size = 185919, upload-time = "2026-08-03T21:19:56.89Z" }, + { url = "https://files.pythonhosted.org/packages/70/c6/d0ea84713fe46b243a436a18fcd47d639732747e21635c8a27191b06dc30/cffi-2.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80", size = 180093, upload-time = "2026-08-03T21:19:58.155Z" }, +] + +[[package]] +name = "click" +version = "8.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/0e/7fa0ef50764b67090eca4114772a2abf8b6148198475e54c660b97caeee6/click-8.5.0.tar.gz", hash = "sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34", size = 382235, upload-time = "2026-08-26T13:33:14.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl", hash = "sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", size = 125251, upload-time = "2026-08-26T13:33:12.928Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "fastapi" +version = "0.162.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "opentelemetry-api" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/eb/2cf8c80abf09b2800aef0a83b41066fbfda8ee5495b7a08b9d1af40f7046/fastapi-0.162.0.tar.gz", hash = "sha256:6a22c1e2e6e32e0633ee7e170f00009a29b8228b16feb219ee42f32fd8d88a8f", size = 527867, upload-time = "2026-10-23T18:47:33.264Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b4/4f/3f2c25c9b43970b5e9a08beb5e04776247edea684ddc0930f4f02f0bb6cb/fastapi-0.162.0-py3-none-any.whl", hash = "sha256:3785963de305dd09912426cb81f2d230fce98ab3521cdfe97265c8d14983128c", size = 148912, upload-time = "2026-10-23T18:47:31.734Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "idna" +version = "3.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/08/8eea9d4b8302028f3abb2c0813953f7aec26d33b7a8960ed760e65ff29fa/idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", size = 216463, upload-time = "2026-09-17T14:11:04.752Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/e1/2069291243c926a2ff1cd706c7f3eeb9b62144bf60f77c9fb9ff2fb26bd3/iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960", size = 21209, upload-time = "2026-10-06T22:48:38.076Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/43/4ca9e49d27a1fcf6bece6f6aec0ea46bb9112489b93d4b688fb415457bdb/iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7", size = 7552, upload-time = "2026-10-06T22:48:36.959Z" }, +] + +[[package]] +name = "jsonschema" +version = "4.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" }, +] + +[[package]] +name = "jsonschema-path" +version = "0.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "pathable" }, + { name = "pyyaml" }, + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/39/79/cd02a4df6d9270efdc7d3feefe6edd730b0820c39eeaa107a2faee8322d5/jsonschema_path-0.5.0.tar.gz", hash = "sha256:493b156ba895c97602655b620a8456caa2ce08c1aa389f5a7addec065e6e855c", size = 19597, upload-time = "2026-05-19T20:45:00.971Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/2c/9e69d73c4297508be9e3b64a970ea3971b3eb8db64ffc5802d40bd25981f/jsonschema_path-0.5.0-py3-none-any.whl", hash = "sha256:2790a070bc7abb08ea3dbe4d340ece4efadf639223001f020c7503229ba068e2", size = 24077, upload-time = "2026-05-19T20:44:59.225Z" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, +] + +[[package]] +name = "lazy-object-proxy" +version = "1.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d4/8e/f26b09778fcb26261fdeb4cc2b011975292316529bff9b541a5a02acb976/lazy_object_proxy-1.13.0.tar.gz", hash = "sha256:ce34046cb021d69c72d05ddb83821ecfd4d2d0a5d43a93c5cd01c9e34779cf14", size = 45649, upload-time = "2026-10-17T16:38:01.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/a5/98c03827458988def73622e075486fe1ebbb85ae53ac3f21479fbfd9988c/lazy_object_proxy-1.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:087eba19ea5ce02ea9eb1749d8fdcfb229eeeaf13abaebecf00d579d306d1fd9", size = 26808, upload-time = "2026-10-17T16:37:42.616Z" }, + { url = "https://files.pythonhosted.org/packages/c3/88/30aa37866ff9122c7b00341396781d30e27ae9d863c2698d1f42bb25a8ab/lazy_object_proxy-1.13.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3df6b7db013fbbd00001a43af6b188b545442b4d125b5fddda79366108e02286", size = 71403, upload-time = "2026-10-20T01:05:33.169Z" }, + { url = "https://files.pythonhosted.org/packages/65/fa/099b2931430f87231fa31cc39893d047a1971a57fc7f90df70b9c82961a6/lazy_object_proxy-1.13.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1bdc617c7b6f58aa5e59f514c7d619d7f60b52b343b77c9149d2fbfefc412f3a", size = 70989, upload-time = "2026-10-20T01:05:34.591Z" }, + { url = "https://files.pythonhosted.org/packages/8b/17/87891d3fee9c03764691239745ee3f6b793062b88cf5d029bf515aa0836a/lazy_object_proxy-1.13.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:47d26b4c5a5ea2d3a1993a1c9509110beb030a2739ca69ebbe516fb04b6842b7", size = 65742, upload-time = "2026-10-20T01:05:36.015Z" }, + { url = "https://files.pythonhosted.org/packages/a9/9a/02acae69e1d0930f9f430d6e4ea77235c72a735672cd8d91164909815fb6/lazy_object_proxy-1.13.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e6261a9c38f629c3566ab5caec3909f5c6f3333a711c7e39f6883715aa38c566", size = 69280, upload-time = "2026-10-20T01:05:37.217Z" }, + { url = "https://files.pythonhosted.org/packages/75/0e/e697f92c1a5410bddf0571077f38684b16fcf3925bb9ba5430355028e0ba/lazy_object_proxy-1.13.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:337b25ac5b0f5103c72343f74eea438ad3216b0a3cc77a3f6e4ec54c80d0256b", size = 65028, upload-time = "2026-10-20T01:05:38.378Z" }, + { url = "https://files.pythonhosted.org/packages/f2/4f/ec5c7f4907305086a55e9372d3deccec369b30e731b92c14d34df455cf4c/lazy_object_proxy-1.13.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:faa395d97edfafd3cd0cbd8855473c4673c7e3080fccf31f97a9bcfa7218d7ec", size = 70619, upload-time = "2026-10-20T01:05:39.551Z" }, + { url = "https://files.pythonhosted.org/packages/e9/23/67edce3954b280049b87dfe914fa16400c3ce2f3fa236388cf64a1bba600/lazy_object_proxy-1.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:81437ad7883fe637620bc63a3df3e9974c9a63562e76d7e8a444fe724adccb5c", size = 25815, upload-time = "2026-10-17T16:37:43.889Z" }, + { url = "https://files.pythonhosted.org/packages/21/21/d70d4ca285bb6ed3629ac432ea0910b8f923e50580888e37990b31f3fac9/lazy_object_proxy-1.13.0-cp312-cp312-win_arm64.whl", hash = "sha256:da66d53e0c350e6e6876f2dc060b240dc06cc159ca7f279d59fe4ed48aec2ece", size = 24467, upload-time = "2026-10-17T16:37:44.82Z" }, +] + +[[package]] +name = "mtusi-messenger" +version = "1.0.0" +source = { virtual = "." } +dependencies = [ + { name = "argon2-cffi" }, + { name = "fastapi" }, + { name = "psycopg", extra = ["binary", "pool"] }, + { name = "redis" }, + { name = "uvicorn" }, +] + +[package.dev-dependencies] +dev = [ + { name = "httpx" }, + { name = "jsonschema" }, + { name = "openapi-spec-validator" }, + { name = "pytest" }, + { name = "ruff" }, +] + +[package.metadata] +requires-dist = [ + { name = "argon2-cffi" }, + { name = "fastapi" }, + { name = "psycopg", extras = ["binary", "pool"] }, + { name = "redis" }, + { name = "uvicorn" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "httpx" }, + { name = "jsonschema" }, + { name = "openapi-spec-validator" }, + { name = "pytest" }, + { name = "ruff" }, +] + +[[package]] +name = "openapi-schema-validator" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema" }, + { name = "jsonschema-specifications" }, + { name = "pydantic" }, + { name = "pydantic-settings" }, + { name = "referencing" }, + { name = "rfc3339-validator" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/98/e8/ab3f27dbca54ec645f7fab714b640907d5d36c2ebb07e87eebd30bd5c81b/openapi_schema_validator-0.9.0.tar.gz", hash = "sha256:b72db64315b89d21834cd3ffef37e3e6893bc876327be2d366e8424b1029afd3", size = 24686, upload-time = "2026-04-27T17:31:27.606Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/c0/5467967d95378b2cfce312e09cbd0c9ab64354a0922379b734f793edd04f/openapi_schema_validator-0.9.0-py3-none-any.whl", hash = "sha256:faa3bbe7c3aa8ca2087ad83f709dc3b7d920283153a570c03e24ea182558aa25", size = 19980, upload-time = "2026-04-27T17:31:25.965Z" }, +] + +[[package]] +name = "openapi-spec-validator" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema" }, + { name = "jsonschema-path" }, + { name = "lazy-object-proxy" }, + { name = "openapi-schema-validator" }, + { name = "pydantic" }, + { name = "pydantic-settings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8f/d2/640b5149cd5688bc0ad1fdbb4df6a2f7b84a093c8d787c27d566132f8b8b/openapi_spec_validator-0.9.0.tar.gz", hash = "sha256:6d648cff6490ebb799dcfe273792f2941c050158854c721f086599d845da78b8", size = 1756839, upload-time = "2026-05-20T09:23:18.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/d8/321ff889330acca2e3097f3d4f80a40bcc41b6d34d302978ab32c449520b/openapi_spec_validator-0.9.0-py3-none-any.whl", hash = "sha256:222fecffc7714f6d0a6ad62c0e4b66cc2b7dbfafb7b93acfc6c308abbdb51af8", size = 50328, upload-time = "2026-05-20T09:23:17.017Z" }, +] + +[[package]] +name = "opentelemetry-api" +version = "1.45.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/14/cf3a6b6448849656e1e5f4e2101f3988dc6789724050096aba1bc5ccf592/opentelemetry_api-1.45.2.tar.gz", hash = "sha256:d7b0008e21e5fd61cbe7a7f34ca3b6905a78ab677d9bc395e299359c75cda6b4", size = 73277, upload-time = "2026-10-29T17:29:37.888Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/2d/610db864d7513158cebb8f36cc88e67e73bd6c7aa1905ef18d89e1281c81/opentelemetry_api-1.45.2-py3-none-any.whl", hash = "sha256:2cbd737377e710ee740d261c94e93fa0f08e6d037c18f17513cc0a2d94479a34", size = 60335, upload-time = "2026-10-29T17:29:06.955Z" }, +] + +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[package]] +name = "pathable" +version = "0.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/f3/5a20387de9bcd0607871bfc2198ee0e15836da7baa4592ccd7f24c27c986/pathable-0.6.0.tar.gz", hash = "sha256:6404b8b82aef5ff0fd478934137128b99b12212ba35afdde5525ca4f8388ea58", size = 18970, upload-time = "2026-05-19T18:15:11.911Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/e8/6d75ffd9784bce2e93d1ae4415649427e39a53bb172d4672b2b59c6f0a7b/pathable-0.6.0-py3-none-any.whl", hash = "sha256:82c4ca6c98c502ad12e0d4e9779b6210afee93c38990988c8c5d1b49bdcdf566", size = 18983, upload-time = "2026-05-19T18:15:10.728Z" }, +] + +[[package]] +name = "pluggy" +version = "1.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/db/7fc19e6f2dc92a966727031389fc2e08b558f0f25eb7403c1119ad4713cd/pluggy-1.7.0.tar.gz", hash = "sha256:d1eaa46ebb595891b860ab086b4d09c8588af65ebd4361b8e8f4bb8920b90ba8", size = 123304, upload-time = "2026-10-15T09:50:58.343Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/9e/2b38731e0fc536806f16490e1a12d7f0dc2a1235aa8cc07bcc75416a7daa/pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec", size = 27082, upload-time = "2026-10-15T09:50:56.808Z" }, +] + +[[package]] +name = "psycopg" +version = "3.3.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, + { name = "tzdata", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/76/26/3ea4ca5eaea1c0debcdf7ee7c1613fbe721dc27a03c461c0817ffd8a0601/psycopg-3.3.6.tar.gz", hash = "sha256:c081f2250df751a943036e42db6df4571c66cd0aabe8291a7a506512b12007d2", size = 168171, upload-time = "2026-09-18T13:22:55.152Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/de/748bd7609c71cae5d737f0ba9192f19329f70180ecda8fff3cac02c5abe3/psycopg-3.3.6-py3-none-any.whl", hash = "sha256:a1db9f7148b06a28606767efaca51fa6f9398c5c0a3810519be69d7000bdb631", size = 215490, upload-time = "2026-09-18T13:15:29.374Z" }, +] + +[package.optional-dependencies] +binary = [ + { name = "psycopg-binary", marker = "implementation_name != 'pypy'" }, +] +pool = [ + { name = "psycopg-pool" }, +] + +[[package]] +name = "psycopg-binary" +version = "3.3.6" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/01/2cdd1824e58b4467ee0b9498664cd28c42d8794db6b1e35b6bcb834f0044/psycopg_binary-3.3.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3f84dab25e0385692ee13274c68678377e0b1a70ab9d14e56264cbf61f60c62d", size = 4707086, upload-time = "2026-09-18T13:18:05.138Z" }, + { url = "https://files.pythonhosted.org/packages/f6/76/de9948ac06895261c84d5b9fbe283d8f3c5bc9f070691b8d9eaa1b51e322/psycopg_binary-3.3.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:612382ac3ed13651c7fa44b5fee9fbf7baaa2ddbc6f500391672682c5f1df9e0", size = 4769607, upload-time = "2026-09-18T13:18:12.83Z" }, + { url = "https://files.pythonhosted.org/packages/76/a9/72436c9915ee4905964689e7f0e182ce7767cc0a0390b3ce703be8177625/psycopg_binary-3.3.6-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:366db6e97e66b37211475f20c4c1324a2dc0dd825e46d4e87f9d599304d276f9", size = 5554134, upload-time = "2026-09-18T13:18:21.175Z" }, + { url = "https://files.pythonhosted.org/packages/0a/42/948bb3d2617795093512613fd96ba380e922992c7908fbc073858147d196/psycopg_binary-3.3.6-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1679a1cb93fbe5a6d1fd58d82cbddcc6fcb8c61446ba7cae6eb2a7b19bc585de", size = 5235723, upload-time = "2026-09-18T13:18:27.071Z" }, + { url = "https://files.pythonhosted.org/packages/99/47/93e823ff1b0088400703410939c9bda3e63ed9c850b3ee088e8769f4c10b/psycopg_binary-3.3.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:37d40450659401600e6d043ff586c89a71a69f33cbb8bcdba6cdb2569beecdbe", size = 6833587, upload-time = "2026-09-18T13:18:33.794Z" }, + { url = "https://files.pythonhosted.org/packages/5e/2d/ecc69c847795aa704041a9f5667a6b0938a088cf1853636d762a6938e493/psycopg_binary-3.3.6-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a5165300324efd5a772c48a88ab3a928513ab3979fca76553e62ee815f7b2b9c", size = 5070013, upload-time = "2026-09-18T13:18:39.628Z" }, + { url = "https://files.pythonhosted.org/packages/92/36/6126f0dac21713dcae91404f2a76da18598a6252339a8c669c46370d43b2/psycopg_binary-3.3.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d636338c8f21b0df2f84657b00bc34f9313f826ef93f1155bc743607e4a0c5eb", size = 4597367, upload-time = "2026-09-18T13:18:45.023Z" }, + { url = "https://files.pythonhosted.org/packages/4d/29/7ecfc04243b46c89ffd49924e9c5634ea904ef96c7d0f37e4073623584c1/psycopg_binary-3.3.6-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a4ee3bdd5468a725f2a4d9aab8a74b6d0279f768c8b5d3aeb102c5307ff3d59c", size = 4275419, upload-time = "2026-09-18T13:18:49.299Z" }, + { url = "https://files.pythonhosted.org/packages/6e/90/2f46d2e0de79706ac170df0a3637fe63c4498fc04f131f6049520b78b806/psycopg_binary-3.3.6-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:289aadd6a00e151203c081f708348ec89f1e483c9b510ef4ac3981f847f01f79", size = 4007358, upload-time = "2026-09-18T13:18:53.944Z" }, + { url = "https://files.pythonhosted.org/packages/03/48/6744e91291b751a8cf12d63d719977974bb94c84ceba913e7ddb2e478e51/psycopg_binary-3.3.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f21d057f3e5f5491067e5b292498073b73847d48799b099803fef100775fcc52", size = 4320156, upload-time = "2026-09-18T13:18:59.258Z" }, + { url = "https://files.pythonhosted.org/packages/1a/9b/94ff7fce53a64d5b286e2ec454e0a025cf3d6e6b4a9189bef16aa5de98b2/psycopg_binary-3.3.6-cp312-cp312-win_amd64.whl", hash = "sha256:e23a66a763fbe83fcc210bc77c27e5a5ea380ebf091c06f34d8561b695e5a40f", size = 3658864, upload-time = "2026-09-18T13:19:06.503Z" }, +] + +[[package]] +name = "psycopg-pool" +version = "3.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/74/5e/c0664b968b102ff68b811d999c728546c48d5c1eec03e3bbaf88c0cb4472/psycopg_pool-3.3.3.tar.gz", hash = "sha256:df87b5d9d0ad7db37f6cdad4fa8ce113d250f5997f6db38e9a99192fb67f9e1d", size = 32006, upload-time = "2026-09-22T15:53:24.947Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/b4/452c6607a0f479465cd8a9b0d9956919fcb150050c1f83f9f11e6b8ee8dc/psycopg_pool-3.3.3-py3-none-any.whl", hash = "sha256:9b9cd6a4fcec47a410f7e82d408540e7f77b478509e91b44c1a5457a13e5ff37", size = 40304, upload-time = "2026-09-22T15:53:23.712Z" }, +] + +[[package]] +name = "pycparser" +version = "3.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cb/27/eeb9f307bf07060f3d9f9aa0fb8c15b01bdfded0a941e4b2719c7f94cacd/pycparser-3.12.tar.gz", hash = "sha256:f03387877eab82ce01bbdfd0ba7252ee55a90b1c708d5129e2ce915475cf1db6", size = 158785, upload-time = "2026-10-22T13:40:03.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/ae/315bbeee126a769cbde43cf4908acb4b40408d8bf8bbf334dd7368d8dadf/pycparser-3.12-py3-none-any.whl", hash = "sha256:a076f3f489b39b43ed13563a1dafe42447445bec2e294154ec5c57fcdda4c85e", size = 62600, upload-time = "2026-10-22T13:40:02.021Z" }, +] + +[[package]] +name = "pydantic" +version = "2.14.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9f/d5/b4867fa7c7f04c34997d7d8aad744f64d210bb99d67cf18bf3fb1eea1aed/pydantic-2.14.2.tar.gz", hash = "sha256:fb7b2db6cefe8414dd612edeede49c4c433acb0432b0f92b95024e45f66c505d", size = 911596, upload-time = "2026-10-29T16:37:12.476Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/97/01/c71a71258b58659c72504e5fd65b451f6e36e34dc931d0b237ded213c814/pydantic-2.14.2-py3-none-any.whl", hash = "sha256:7efbf7507b937931cd32a5755acb00ea1cf5ccb1d4e8067a5850d5069e382118", size = 490403, upload-time = "2026-10-29T16:37:10.181Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.50.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/8e/23ec1021834e35041fbb2f10946141e6acdfd39379c45cc4d65a4e8a1d98/pydantic_core-2.50.2.tar.gz", hash = "sha256:1b0e8dc3932cf4e9ed5727570325cacc716b9409ffc794a221c0ccc72e8eb775", size = 518711, upload-time = "2026-10-29T16:34:57.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d6/65/6609a66cda909d414c58438f9bd70b1e947fe12c25f6bd40c93121afd7ef/pydantic_core-2.50.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:e3d824b6152e1c0fd58dc6266f2de470eb7b2286135294f5f7cd26a0f0693738", size = 2220341, upload-time = "2026-10-29T16:32:10.193Z" }, + { url = "https://files.pythonhosted.org/packages/f9/0b/92463ae7be78d73885487f72c4599902c2cc190378bccaad5718b7495250/pydantic_core-2.50.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:596921489390a002d6a5e303384a0f1f98384f8bb550fbf38a1aafa6093da0f9", size = 2093701, upload-time = "2026-10-29T16:32:11.502Z" }, + { url = "https://files.pythonhosted.org/packages/62/d3/24147a1aa22f7eade546172750e1110fd7b2793998057809800d3ebeae4e/pydantic_core-2.50.2-cp312-cp312-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:36d8b9725684ca3bf658b90a101d335fc8cae405bb22196b7b5ef41344913756", size = 2253622, upload-time = "2026-10-29T16:32:13.051Z" }, + { url = "https://files.pythonhosted.org/packages/f6/50/2628ca3c83a0d9a6fda3305fe59b1b28e40c0221e8f234cd1ef86fb64745/pydantic_core-2.50.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:43a8fd56f3c681f3cda2d5c842ad28e88241df742dfcbe8fd1dd437a3056e1f6", size = 2114101, upload-time = "2026-10-29T16:32:14.702Z" }, + { url = "https://files.pythonhosted.org/packages/21/c8/cc6d7304a93f91f5e06260ccad71cc7d882489663a37dec009532379fc46/pydantic_core-2.50.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:6f5a432c6c1ef18a1a02a04b3616b8d3f2f88b13faa46caae1ac6559ab202234", size = 2199541, upload-time = "2026-10-29T16:32:16.153Z" }, + { url = "https://files.pythonhosted.org/packages/65/d9/18f44ac5696b3e2b2384cb89c9fbe6ed69860f528e232b9fb46cc5b45a17/pydantic_core-2.50.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5d3cd8be71c4da3c9b42cc92f17e5e3036bdca98bf18555a0e072c3fe87abbb4", size = 2368597, upload-time = "2026-10-29T16:32:17.544Z" }, + { url = "https://files.pythonhosted.org/packages/1d/22/5f2a48ef819a7e1b74fb003a85d27576ad2f9ddf3901b88998ac63ce1e00/pydantic_core-2.50.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6a438cb8a3f87f2c49e82e43fb19511d4d5043f53e0787dc4df937ccb904373a", size = 2451701, upload-time = "2026-10-29T16:32:18.956Z" }, + { url = "https://files.pythonhosted.org/packages/08/93/2a6556bbdb8e918175af9d849a5d0b367b5644e41939d040f3a7215b1339/pydantic_core-2.50.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9667637665acba166a7dbbc786f14c50512d3a01f7199e0e1a13b929e92d7c7a", size = 2242782, upload-time = "2026-10-29T16:32:20.381Z" }, + { url = "https://files.pythonhosted.org/packages/90/ed/dd9f29a92257f32eb5b99d5120826186ee0632ecc3aaf6c23e2fab89ed6d/pydantic_core-2.50.2-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:b3e681208e2d39fde13fbea449ef2736a85ec1ea2afa41e9193a8c536e71dafe", size = 2253706, upload-time = "2026-10-29T16:32:22.293Z" }, + { url = "https://files.pythonhosted.org/packages/11/19/1ccf3bf38eb4ed97d8aeefc558458834ae0ad53fdbb1edf61af7228ea500/pydantic_core-2.50.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:6eb6ff07964f39e33c6f57fefe939514e76b8c0d4a694e5663e2e04e80cc1798", size = 2288603, upload-time = "2026-10-29T16:32:23.465Z" }, + { url = "https://files.pythonhosted.org/packages/ea/cd/bae2320fc89a65bcd87bf66ec83aac51b3b43b970a2edece15feb8af64dd/pydantic_core-2.50.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:4eb54c25e3463d73e1e4ed439ffc45d1d7e590df40bc7bb06f11a906afd996c3", size = 2476597, upload-time = "2026-10-29T16:32:24.824Z" }, + { url = "https://files.pythonhosted.org/packages/db/35/1bdb8d52c8e562e95c5e6ebb5784792af568ac6a81470dd546d95f392b60/pydantic_core-2.50.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:91238117cd296352f54f24117ff5a227bdea428865dba1244aa0cdd1424c0bc2", size = 2478664, upload-time = "2026-10-29T16:32:26.197Z" }, + { url = "https://files.pythonhosted.org/packages/12/72/0179b40ac6a6b0899c61826f2e3e80f88063f6d821e0dd9641927de46700/pydantic_core-2.50.2-cp312-cp312-win32.whl", hash = "sha256:98722314e12a8e4fa346e0afd3fff2098b5732875ff45592b450a7b589b43c4f", size = 2108820, upload-time = "2026-10-29T16:32:27.736Z" }, + { url = "https://files.pythonhosted.org/packages/b4/fb/679144362d7e5162519d9f6631ec982521417de3196351c6c56485f5b29f/pydantic_core-2.50.2-cp312-cp312-win_amd64.whl", hash = "sha256:b381574614245f18fdb2d6d1aa8f149e225869c47b5ee7f81812de8977817314", size = 2252238, upload-time = "2026-10-29T16:32:29.572Z" }, + { url = "https://files.pythonhosted.org/packages/0f/68/e3ccc885c3e2086ff84d7ca496f45b974a9f0a49ce2da8973aaa3a369a4b/pydantic_core-2.50.2-cp312-cp312-win_arm64.whl", hash = "sha256:f07c965a8aa6d62145f122641f292129984f39a3e3697585b19298a1488287db", size = 2162565, upload-time = "2026-10-29T16:32:30.853Z" }, + { url = "https://files.pythonhosted.org/packages/64/4d/23560b11366b547e3e68a3b8f9c02557cee707effa54fd39dbb3c4fff1fa/pydantic_core-2.50.2-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:d18d56c1ec63b304f4bb3c7db7e0d311e61cca1b1c944590a4b13ac39b2ca92b", size = 2204868, upload-time = "2026-10-29T16:34:34.745Z" }, + { url = "https://files.pythonhosted.org/packages/06/58/b9ddfaad189143d6568627166a730b6624ca90bd9a9a4af4854df88d444b/pydantic_core-2.50.2-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:41ed8abeffda6a880207fdc0cd1343a448cec3cc6b38b53f730c0745f745292d", size = 2049162, upload-time = "2026-10-29T16:34:36.186Z" }, + { url = "https://files.pythonhosted.org/packages/8b/20/99d259bf7835b2f13c6d0b3eb7bcf669fb6349986736fa7a8308a9e620b0/pydantic_core-2.50.2-graalpy312-graalpy250_312_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b7abcfaf66c1dc14c5ed928c349614f223c972a8b021b4be9548dbea6c817371", size = 2112135, upload-time = "2026-10-29T16:34:37.777Z" }, + { url = "https://files.pythonhosted.org/packages/9b/ca/652c8fe599abacafd852479059d209e608596ad3de82f1bff22e9f0f02fe/pydantic_core-2.50.2-graalpy312-graalpy250_312_native-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9e7460abce637f90e37f8c443559fbd687c38884d05cb69ef265e634945f4324", size = 2270339, upload-time = "2026-10-29T16:34:39.039Z" }, +] + +[[package]] +name = "pydantic-settings" +version = "2.16.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d0/31/21d21e0e38a8f5f7a7f0cde22820117b6d17d6bc36f348129527f915d7f4/pydantic_settings-2.16.2.tar.gz", hash = "sha256:3dc08ffabed2bbd5dc2dd55ead7b78b4e4c5cd776aecd04310db5f1224caaf46", size = 309225, upload-time = "2026-10-28T11:14:28.066Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/88/4131c51ff87b7cd7f82a1194d0c0a2b7ca68c72d9da04c3b7e69ab91a79f/pydantic_settings-2.16.2-py3-none-any.whl", hash = "sha256:8d523e5c129b097686bde019bd6109bff53f4c8c3f63f1ddf9933ffa42e5ab4f", size = 81994, upload-time = "2026-10-28T11:14:26.716Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, +] + +[[package]] +name = "pytest" +version = "9.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/79/42/bb4641652e58dedeac2ec51abc1f8cae4fee4ec63899a0999016229a0f2a/pytest-9.2.0.tar.gz", hash = "sha256:97c4f3b1f3c7414aa36465e09b8220f1d03627993bd51b1282e193753c80557b", size = 1797555, upload-time = "2026-10-27T21:30:20.728Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/39/1f5d8c8877a0fa327db959c19341d4be61660de1ab6b7391f9eb805bcd67/pytest-9.2.0-py3-none-any.whl", hash = "sha256:07acdcf88ec174f907dc01af70bf52d49b014bbab03faeeade31c96b18c2e588", size = 411776, upload-time = "2026-10-27T21:30:19.131Z" }, +] + +[[package]] +name = "python-dotenv" +version = "1.2.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/74/26/2fbeedb218a787a5eea551c7532cac4e009f83d689dd2faa0d0353473f86/python_dotenv-1.2.4.tar.gz", hash = "sha256:f0d53e69935a851c0dcc78f3ab7aaccd8cabef0b92382b576b824212902873c0", size = 60824, upload-time = "2026-10-01T05:36:10Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/d1/38f3a3405989a89ac18390803e70c6ad7c7760da4f9b83cbeca0c44a0c72/python_dotenv-1.2.4-py3-none-any.whl", hash = "sha256:42269a8a5b3fd54ffa6f3d84b18abed50064717576b4ecf03dc4a55d8aa04fdc", size = 23266, upload-time = "2026-10-01T05:36:08.633Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, +] + +[[package]] +name = "redis" +version = "8.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a8/99/604f0b666d4c616d891cf77ebb9db6bb21601344c051aebf1b72b9ff915f/redis-8.1.0.tar.gz", hash = "sha256:6e1a19beef9225c83efd689c7e6b7da2d5215b1f42cd13b7fc3714d0a09c7b25", size = 5254356, upload-time = "2026-07-30T08:51:00.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/66/9d/c5731f6e3608663d4d3656fd8d3aecee8b509c3082818f5a13eae925baea/redis-8.1.0-py3-none-any.whl", hash = "sha256:a4fe1aac3d3b3cc791d4b3d5931c5a956045dc951ee74d1c913ee3ac4d2ee9fb", size = 560618, upload-time = "2026-07-30T08:50:58.497Z" }, +] + +[[package]] +name = "referencing" +version = "0.37.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513, upload-time = "2021-05-12T16:37:54.178Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490, upload-time = "2021-05-12T16:37:52.536Z" }, +] + +[[package]] +name = "rpds-py" +version = "2026.9.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/42/68/3bd46b8a5e01d3c2ebdf9c5e9497912e3fe0cde02bac21a7130ca866e403/rpds_py-2026.9.1.tar.gz", hash = "sha256:4793ef7f78268b124b73fa933440f01d258bbae01de9fa53e9080c9ab0425a12", size = 63948, upload-time = "2026-10-04T16:32:36.469Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/34/a828586ea3329fbb50895b50e9cf98ca3d924a9f41a0b26d443bff1b3794/rpds_py-2026.9.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:50906f5aea24b5a865cbd0a589698288631d9f3a54c3a937c83aefa95a0d14af", size = 346822, upload-time = "2026-10-04T16:29:16.258Z" }, + { url = "https://files.pythonhosted.org/packages/90/81/ac6a0d064982251856ce009c9e1dd51a34110b3c055aa7d1aad18b4899a3/rpds_py-2026.9.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e21c1429e205828ea886a2293a4a2c8e01f4c25d9893ca330e97a6cf73f52e7b", size = 341380, upload-time = "2026-10-04T16:29:17.706Z" }, + { url = "https://files.pythonhosted.org/packages/42/ff/bf7d54f362748fd6a49277b9d6531c394074110fedf50ad791ec59133fbb/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2693b2728bbcc48d09a981a356954b0c47c53ff25b545856f28a889ea619f69a", size = 373053, upload-time = "2026-10-04T16:29:19.063Z" }, + { url = "https://files.pythonhosted.org/packages/60/de/74b0ccdbbd28687b9b5fdb34c1cabed88352182facaced9d6f5486b8b9ed/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8601470267d938bcb7f3ab1a336100af51a4fd5b6ed030ef52461bb3ef5e7e07", size = 377742, upload-time = "2026-10-04T16:29:20.543Z" }, + { url = "https://files.pythonhosted.org/packages/c2/6d/b979775a3057b2a5c26d75ecbff60a20a24ef081db6dd76836fca3f20247/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3890a6aa36e6baa53d5258a2a25d3ef8b37ad165a6ab27a892d7c3e3a432cd69", size = 487289, upload-time = "2026-10-04T16:29:21.958Z" }, + { url = "https://files.pythonhosted.org/packages/1d/5d/7c34734ce3ece943d9d6ee0122a74a21bbc75b47acb5b7053c83f6efb1ed/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6b5b393eda5ea42cca1c1a6665f2a4882b4fd5d1777e41ce0545a107fb008c9d", size = 390710, upload-time = "2026-10-04T16:29:23.378Z" }, + { url = "https://files.pythonhosted.org/packages/1d/6d/b26eb1e75395925b3a142ed351cbed2ec8212f5c9d937aee3df32c701baa/rpds_py-2026.9.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:addeda51556dac7c1a2f14cda62db8b621cd12afba3091d03a96c72932387eab", size = 371261, upload-time = "2026-10-04T16:29:25.1Z" }, + { url = "https://files.pythonhosted.org/packages/7c/98/b2fdfe10301a9e27af21e634337fbba7baac0bc17fe44619a17c26bba2cb/rpds_py-2026.9.1-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:d9edf30457d74eebfd76b045535e36f1cd89062566a128a0db2145ca042d787e", size = 376075, upload-time = "2026-10-04T16:29:26.748Z" }, + { url = "https://files.pythonhosted.org/packages/c5/b1/c4b8d954e49c3c69cf8063c0c9e0919c99f3d2cecc46311606a1cbe835dc/rpds_py-2026.9.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:815d26356930846a40c7bc1366e7b1b0320ab8a063e66c11298a208bed0fd237", size = 399358, upload-time = "2026-10-04T16:29:28.282Z" }, + { url = "https://files.pythonhosted.org/packages/b3/59/9559a7293c97dff0cbb293efffbd36644103883ecc27741af8ef90c84ca8/rpds_py-2026.9.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3b5a6f40f0a1486b4b36c888123afc67acdbd9f33235927acf5ff295429a0ba3", size = 550267, upload-time = "2026-10-04T16:29:29.851Z" }, + { url = "https://files.pythonhosted.org/packages/6c/9d/6dc60e49511de4c8b00e74f9c1d43aed4d27f712cdb1ade92f2c199cbf64/rpds_py-2026.9.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b5b8b0753718d258fd454283fbd57e14545d3b40583fa672e27cb4f987626bcc", size = 614018, upload-time = "2026-10-04T16:29:31.54Z" }, + { url = "https://files.pythonhosted.org/packages/fb/bc/92a4ecf27301b886232a413360f6b348a81d55ffef654f2ebda5970ebc3d/rpds_py-2026.9.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:46d80bc76b51a6c24f9944368c28d38b8bcbcea1da4f2f8d3ebc31a67e8c6ec6", size = 578509, upload-time = "2026-10-04T16:29:33.01Z" }, + { url = "https://files.pythonhosted.org/packages/08/53/efb97f2e6589b7ab8394385a73870e0b2ab2a195281c117b21fd6d7d4855/rpds_py-2026.9.1-cp312-cp312-win32.whl", hash = "sha256:befc2d6a953e563f8a7bfd87a42c22ebf8a3e980dcb7b6a4d17b70b0e914e8a3", size = 205401, upload-time = "2026-10-04T16:29:34.451Z" }, + { url = "https://files.pythonhosted.org/packages/1c/84/1700cc748d0eaa747486e4e82882d2575224e6e9a3148df583058850c629/rpds_py-2026.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:5ce8943f79c2210f7abcc28e86367b03b28d95027fd01c46d2472373ae70c86f", size = 222923, upload-time = "2026-10-04T16:29:35.709Z" }, + { url = "https://files.pythonhosted.org/packages/c3/89/0302215373c2f8b4408b0fdfee955368cc378a98ff59508d47a7e0dc2dbf/rpds_py-2026.9.1-cp312-cp312-win_arm64.whl", hash = "sha256:501909f2e4a1e2dee528ef766fe3c469060ebc17e54a8383d404ba07a81a6f02", size = 218415, upload-time = "2026-10-04T16:29:37.263Z" }, + { url = "https://files.pythonhosted.org/packages/a3/90/a9ba81408369d34c1aca73319c15adc91ed45c1d21e9e8ee4832ffb7fe0b/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6cdc537c8633d7fd92a82e2e0d2ab74320a3f63d5e59fb9cf08711e08fe151c4", size = 381109, upload-time = "2026-10-04T16:32:08.994Z" }, + { url = "https://files.pythonhosted.org/packages/b3/44/5192a0bed94cec86bd2a5e1cc5a1bb8f7eec3aec907eacd2deb13e87e326/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:10e208f2425d973938afcd56e28a7c4be32e27b6a60b5d381f49fb9d8acf9759", size = 388222, upload-time = "2026-10-04T16:32:11.321Z" }, + { url = "https://files.pythonhosted.org/packages/92/cd/5356549711448f18b52f7a11ffbe90f1228774996fbf3c6cd1b18d22abaf/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6c0dbbcc19735fe5f8b0a54c07659d154a9e69f47e15d0a6ab7299215daf62cb", size = 500384, upload-time = "2026-10-04T16:32:13.478Z" }, + { url = "https://files.pythonhosted.org/packages/7a/88/ddda9d28adfe33119c75b2e733d4ba7e326f41d7e1b1093951771768ca48/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:684fd492fff4fead00587544e059be2bbcb6f93454f21fa2a91b66fc7508be82", size = 401661, upload-time = "2026-10-04T16:32:15.653Z" }, + { url = "https://files.pythonhosted.org/packages/32/c3/bb59ba16a6b4a57995d15b8c04c00f28df3b938c4dcdde48fbe0f73edb0c/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d1028417bb44037eb3069c1009bd7b7277212876cda22fbe565b0bca9fab6d2c", size = 380748, upload-time = "2026-10-04T16:32:17.727Z" }, + { url = "https://files.pythonhosted.org/packages/f5/b8/0580faa1c5a32ddc160130dd7ae54d2d007272a89a40a6b5db3e50f9f585/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:492e5e428cbe126221611f47e068f01660352feec4ad18bc0f5ea9b2ae88fb14", size = 385731, upload-time = "2026-10-04T16:32:19.855Z" }, + { url = "https://files.pythonhosted.org/packages/bf/70/f73564642bbe3322c7eeef2c2f258cf040b71c41a430b532e59d04a1b838/rpds_py-2026.9.1-pp312-pypy312_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:88b5268892fde430d5531f95bc560b6efbbd67c929662c586afd729a96e7461c", size = 412131, upload-time = "2026-10-04T16:32:22.285Z" }, + { url = "https://files.pythonhosted.org/packages/8c/5d/17fff2e1f8f68721a2afb5cb48f7e442c751bb6b4883157c5abaf618cd08/rpds_py-2026.9.1-pp312-pypy312_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:01445c8d194aa032a08e944f16567672da1c62dbdbefd8b6d0693032e290cf68", size = 558193, upload-time = "2026-10-04T16:32:24.4Z" }, + { url = "https://files.pythonhosted.org/packages/2a/d0/869ab6fb08531f97aae4a780b4d61b4190d8aef48fe054ee28bcf7114466/rpds_py-2026.9.1-pp312-pypy312_pp73-musllinux_1_2_i686.whl", hash = "sha256:eef6a03b0b6d08d0835ccfa8ec8d1bc70525e3801387567137b50c557695e6da", size = 622448, upload-time = "2026-10-04T16:32:26.844Z" }, + { url = "https://files.pythonhosted.org/packages/ba/a5/9672e532fe02cd3b92c78cfd8743abca939d96853006c63835009a1ecb6f/rpds_py-2026.9.1-pp312-pypy312_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:6b9bf3135b4ad5981df9a73d71a35272d650a2985ae9c2746357b24d59de2448", size = 591126, upload-time = "2026-10-04T16:32:29.274Z" }, + { url = "https://files.pythonhosted.org/packages/80/ef/3a9f8e4279c7920af561deed4cb7ebebed2794a8f608cf404d5eef14a105/rpds_py-2026.9.1-pp312-pypy312_pp80-macosx_10_12_x86_64.whl", hash = "sha256:56c6952a9b15047466d0c2347c446a761d4527f89976156341e68f0ce5cc08b0", size = 357108, upload-time = "2026-10-04T16:32:31.641Z" }, + { url = "https://files.pythonhosted.org/packages/b7/55/4b2fa381a583760aea5c92841e4e928a358e1c6511b129219e9c2826a226/rpds_py-2026.9.1-pp312-pypy312_pp80-macosx_11_0_arm64.whl", hash = "sha256:b242c27c8f836305a4a72df9cdd564386ac57b807bd252a063223331c9316b37", size = 346877, upload-time = "2026-10-04T16:32:34.061Z" }, +] + +[[package]] +name = "ruff" +version = "0.17.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/59/73/81f140c4edd9cc323de5478e6bbd3bbcfae9a82692df1a258de8cec6a6d2/ruff-0.17.3.tar.gz", hash = "sha256:a57049c8addb3662073859bb55a7ad35aa54f8a7c9ed268911d1333c5aadaaa9", size = 5339444, upload-time = "2026-10-27T00:34:05.914Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/8c/083365310c4e79c842f25bf5a842facbd9b0c0ec336f96dffa5074fe723d/ruff-0.17.3-py3-none-linux_armv6l.whl", hash = "sha256:ab86b84cd9d05e56d329742c0cabdcbe2d1d56c98f4a04aab9b5b66196febfb4", size = 10216522, upload-time = "2026-10-27T00:33:29.822Z" }, + { url = "https://files.pythonhosted.org/packages/72/26/4b2edf31cfebe9605d8f6ed8f1d6f376d3a53d4c9a123e62661c64c440f0/ruff-0.17.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:e407b4a6852853a9a2cdce96963e94ad9775578bb44e7561a0f2829f3cc04b11", size = 10217786, upload-time = "2026-10-27T00:33:33.949Z" }, + { url = "https://files.pythonhosted.org/packages/a2/7e/537aba4b7f54397a374d2f6a6fc93e9c8015e18553f31a4a7b7dbced48b5/ruff-0.17.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:b75cc113b3aca388933d8296b667b1ac401a80317ea3074c9b0a66541199da29", size = 9440362, upload-time = "2026-10-27T00:33:35.784Z" }, + { url = "https://files.pythonhosted.org/packages/3d/66/283e39734f66c8a5ebaa93c22eb7b7515779a0b1d5a5c0ad20e05c0edb41/ruff-0.17.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab5fa7ed5ce18554ea69d850ad162cbaa0c85fc47c08d83a569f806681c9a6ad", size = 10094281, upload-time = "2026-10-27T00:33:38.216Z" }, + { url = "https://files.pythonhosted.org/packages/21/4c/1ffc768497bd025a32c72152771e40c0b99bddc5cc6e4f50c7949a395346/ruff-0.17.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c673c170e27834d1262e3a9c1e97bdc9b9c3b180c63d89173ce69747232474c1", size = 10022543, upload-time = "2026-10-27T00:33:40.181Z" }, + { url = "https://files.pythonhosted.org/packages/73/c3/f90db547301080fcb82c92abf914c8bd57b89911d9b65a6c4cc6b52d0635/ruff-0.17.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6a754c0341bc9ca151b7b335988b3263921c08859f84ca219b70cee825571b6f", size = 10683921, upload-time = "2026-10-27T00:33:42.182Z" }, + { url = "https://files.pythonhosted.org/packages/e5/98/92d4a8a26c6c96cf1a5b34dd59036d8a71e52d650aab065c58867e964e63/ruff-0.17.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4590b9d86c0b1543ebb09094254e191cd43fe8edaf330baa035aab03da251532", size = 11373408, upload-time = "2026-10-27T00:33:44.19Z" }, + { url = "https://files.pythonhosted.org/packages/43/02/1f24d2e3064c9753926deeb901afa57777b37ee46799b09ddd7aee6e5145/ruff-0.17.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bbde18beccd98c29a227c63c99022e3443b99258e08326df6425dfe0443705ef", size = 10977469, upload-time = "2026-10-27T00:33:46.179Z" }, + { url = "https://files.pythonhosted.org/packages/f0/20/fecedea2209f574ab92033b344e01a7f0c2dc76c6d6d19a14c9f8141173f/ruff-0.17.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7fa4b0f931cdbcb8a52044f370a3eb429fb42eb88807b0e800fcaa98dd42b24e", size = 10577491, upload-time = "2026-10-27T00:33:48.233Z" }, + { url = "https://files.pythonhosted.org/packages/33/36/b93fdf0bc6f84f0cd487aadfb0354deb40013669ea35ac3d26855de1e959/ruff-0.17.3-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:39405f341deec934b4289634324ad695f72df2970f9121582872eaf5b722f0f5", size = 10608748, upload-time = "2026-10-27T00:33:50.284Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b7/7d3f5f14145daead1efb0b9a8289ed1daa100f419d60774375951723ce00/ruff-0.17.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68074094f55ca3d29ab19491f640282f7a84061c4c7977aa5094b968ca457e9a", size = 10075057, upload-time = "2026-10-27T00:33:52.074Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ed/93ff7a5909ee56e2bd4b982deae9e0efb2724417874a90c9e41ad66c6dd7/ruff-0.17.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:27bb571ac78fef178fe5118d2827df95c2aae74a48fff2b15f6acd03af5ff5bb", size = 10022431, upload-time = "2026-10-27T00:33:54.061Z" }, + { url = "https://files.pythonhosted.org/packages/9b/07/a83b9eeec8c1c3c0e4eda15f06c3a91001bfd2687ea2f07b750719bf9712/ruff-0.17.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:029c37cbd3de48ca37aa12117bead2d065f15da17d66bf84e0d4274013705db2", size = 10394903, upload-time = "2026-10-27T00:33:56.158Z" }, + { url = "https://files.pythonhosted.org/packages/af/b2/05c39857c2526fcbebe46ad93a8dc97424656dfef14d3ef933abe1ffd331/ruff-0.17.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:692fdb46d0fd9c71e380947dc5fc72f2c3f881073bc1f739e4579376231affbe", size = 10799780, upload-time = "2026-10-27T00:33:58.204Z" }, + { url = "https://files.pythonhosted.org/packages/ec/d9/47171a16739eb7a353936b31c20cf54340531e68c9af7d72fd7a784e235d/ruff-0.17.3-py3-none-win32.whl", hash = "sha256:46539cb031b01fd29ae0a02142483c46640b233ee12bb1c1b690bffa1555d5ca", size = 9908481, upload-time = "2026-10-27T00:34:00.087Z" }, + { url = "https://files.pythonhosted.org/packages/d0/a0/f08c1631bfd81faa6a90eaf70c37c786c11bed2046302b56bb506c25e1a0/ruff-0.17.3-py3-none-win_amd64.whl", hash = "sha256:56b8ffb3f3b3cbccb8b76b71b38261b7ed982ef5d20f5b447b1b61a7f4949b24", size = 10341333, upload-time = "2026-10-27T00:34:02.099Z" }, + { url = "https://files.pythonhosted.org/packages/99/d5/4ad4ed31413c301430918e70d3d38ae6f097af0766cb9ab8c9d502b2a4d6/ruff-0.17.3-py3-none-win_arm64.whl", hash = "sha256:81fce74bcd6be0e9da7c67c7553fd0f1f12964a2052cd728ef917b937a5ca1d9", size = 9854332, upload-time = "2026-10-27T00:34:03.847Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "starlette" +version = "1.10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/bb/3d8757f21e9a53d9035c9eb039a777047139a16bfdbedfc7a58241c3d914/starlette-1.10.0.tar.gz", hash = "sha256:b8399098d4c1e3522734f7235dc79b1fc967f96cf139c81e0fa30479e0685f9b", size = 2734356, upload-time = "2026-10-24T15:04:12.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/2e/947cfe02def9371c07cd5bf5b6b61c829e9aecb9904db02a66cfafbc1eec/starlette-1.10.0-py3-none-any.whl", hash = "sha256:478c0ab3b4ced6e82719849c118fa406f0278a3499c1a898cd15cd31bdc38ce4", size = 80571, upload-time = "2026-10-24T15:04:10.371Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/26/b09b8010994eccc3c09092e6b34058f36a460eea2d4c3e8b910c695975a0/typing_inspection-0.4.4.tar.gz", hash = "sha256:547274fa6b0a561ccf549cc9524b999a578e737d015d8709d021f9d0d13bea47", size = 76928, upload-time = "2026-08-12T12:37:25.997Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/81/4add07e5172b7ac40d8ed5ff580409a7801a4fe26d529bdd915401dabfbe/typing_inspection-0.4.4-py3-none-any.whl", hash = "sha256:65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147", size = 14750, upload-time = "2026-08-12T12:37:24.648Z" }, +] + +[[package]] +name = "tzdata" +version = "2026.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7a/29/6a1391d31cd00ff9e927215a224a880e1e84e826b64ba80a499e51c074d8/tzdata-2026.6.tar.gz", hash = "sha256:85d2cd9c09f81f0bb29db27759fc83af4f1e620efb814f8c5bf8b4cc4feece6d", size = 201017, upload-time = "2026-10-28T09:57:09.137Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/66/9a06c2227fedfd4919f0eaaa8b94377d9730882a7e4f95823c9a331ab5e1/tzdata-2026.6-py2.py3-none-any.whl", hash = "sha256:0a10eec6e13ef16b627fabed9a5f2ba61a62b1c67f327305f4e7e412a70b4aec", size = 348210, upload-time = "2026-10-28T09:57:07.276Z" }, +] + +[[package]] +name = "uvicorn" +version = "0.54.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/da/34/30e9280707135d2cfc589dfff3cb796bd07a3aeb1a3e415ba09dd89d7bb4/uvicorn-0.54.0.tar.gz", hash = "sha256:a2e33cbfaa0306f8e6b0c13e0cb89d7d7a2da3e62b90c66e18c33d9807b28620", size = 112283, upload-time = "2026-09-25T06:52:37.601Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/0c/b54a4fdd7f90a3af8b02ebc9ce6712c2c208b7926a2f7bad95c33ebbe943/uvicorn-0.54.0-py3-none-any.whl", hash = "sha256:505bdb0f318731d45f1f712071fc781a8981f6847a31c902c9f5e652d4f67faf", size = 87427, upload-time = "2026-09-25T06:52:35.829Z" }, +] -- 2.54.0 From a0ca0af168d9f4b1be9937bd98d960ec2092cd1a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=92=D0=B0=D1=81=D0=B8=D0=BB=D1=8C=D0=B5=D0=B2=20=D0=9D?= =?UTF-8?q?=D0=B8=D0=BA=D0=B8=D1=82=D0=B0?= Date: Fri, 6 Nov 2026 18:16:18 +0300 Subject: [PATCH 2/4] Document scaling experiment, measured database boundary and verified failure recovery --- .env.example | 22 +- REPORT.md | 156 +- evidence/contract-validation.txt | 4 + evidence/failover-first.txt | 4 + evidence/haproxy-benchmark.cfg | 35 + evidence/independent-expiry.json | 9 + evidence/independent-faults.json | 92 + evidence/independent-http.json | 313 + evidence/lb-no-ready-api.json | 13 + evidence/lb-no-ready-api.txt | 29 + evidence/persistence.txt | 3 + evidence/readiness-isolation.json | 11 + evidence/readiness-isolation.txt | 11 + evidence/replica-failures.json | 35 + evidence/replica-failures.txt | 67 + evidence/research-runner-manifest.json | 11 + evidence/restart-after.json | 42 + evidence/restart-before.json | 42 + evidence/rolling-update.json | 39 + evidence/rolling-update.txt | 83 + evidence/scaling-final-resources.png | Bin 0 -> 104333 bytes evidence/scaling-final-resources.svg | 2604 ++++ evidence/scaling-final-summary.json | 338 + evidence/scaling-final-summary.md | 27 + evidence/scaling-final.json | 18638 +++++++++++++++++++++++ evidence/scaling-final.png | Bin 0 -> 106330 bytes evidence/scaling-final.svg | 2691 ++++ evidence/scaling-pilot-aiohttp.json | 28 + evidence/scaling-pilot-causal.json | 856 ++ evidence/scaling-pilot.json | 24 + evidence/scaling-reversal.json | 1123 ++ evidence/scaling-reversal.txt | 91 + evidence/smoke-final.txt | 2 + evidence/tests-final.txt | 4 + infra/haproxy.cfg | 2 + pyproject.toml | 10 +- research/README.md | 48 + research/analyze.py | 166 + research/load.py | 132 + research/reversal.py | 40 + research/run.py | 225 + scripts/container_snapshot.py | 14 +- scripts/stop_one.py | 19 +- scripts/verify_lb_unavailable.py | 46 + scripts/verify_readiness.py | 12 +- scripts/verify_replicas.py | 55 +- scripts/verify_rolling.py | 51 +- scripts/verify_teacher_faults.py | 103 + scripts/verify_teacher_http.py | 193 + student-tests/test_api.py | 9 +- student-tests/test_lab3.py | 82 +- uv.lock | 334 + 52 files changed, 28893 insertions(+), 95 deletions(-) create mode 100644 evidence/contract-validation.txt create mode 100644 evidence/failover-first.txt create mode 100644 evidence/haproxy-benchmark.cfg create mode 100644 evidence/independent-expiry.json create mode 100644 evidence/independent-faults.json create mode 100644 evidence/independent-http.json create mode 100644 evidence/lb-no-ready-api.json create mode 100644 evidence/lb-no-ready-api.txt create mode 100644 evidence/persistence.txt create mode 100644 evidence/readiness-isolation.json create mode 100644 evidence/readiness-isolation.txt create mode 100644 evidence/replica-failures.json create mode 100644 evidence/replica-failures.txt create mode 100644 evidence/research-runner-manifest.json create mode 100644 evidence/restart-after.json create mode 100644 evidence/restart-before.json create mode 100644 evidence/rolling-update.json create mode 100644 evidence/rolling-update.txt create mode 100644 evidence/scaling-final-resources.png create mode 100644 evidence/scaling-final-resources.svg create mode 100644 evidence/scaling-final-summary.json create mode 100644 evidence/scaling-final-summary.md create mode 100644 evidence/scaling-final.json create mode 100644 evidence/scaling-final.png create mode 100644 evidence/scaling-final.svg create mode 100644 evidence/scaling-pilot-aiohttp.json create mode 100644 evidence/scaling-pilot-causal.json create mode 100644 evidence/scaling-pilot.json create mode 100644 evidence/scaling-reversal.json create mode 100644 evidence/scaling-reversal.txt create mode 100644 evidence/smoke-final.txt create mode 100644 evidence/tests-final.txt create mode 100644 research/README.md create mode 100644 research/analyze.py create mode 100644 research/load.py create mode 100644 research/reversal.py create mode 100644 research/run.py create mode 100644 scripts/verify_lb_unavailable.py create mode 100644 scripts/verify_teacher_faults.py create mode 100644 scripts/verify_teacher_http.py diff --git a/.env.example b/.env.example index d32b9be0..0fb64b37 100644 --- a/.env.example +++ b/.env.example @@ -1,13 +1,13 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. -APP_HOST=0.0.0.0 -APP_PORT=8080 -APP_ENV=lab +# Local synthetic Docker Compose configuration. make bootstrap creates .env +# and private secrets once; never commit generated .env or secrets/. +PUBLIC_PORT=8083 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 -CACHE_URL_FILE=/run/secrets/cache_url API_REPLICAS=2 -IDEMPOTENCY_TTL_SECONDS=86400 +API_CPUS=0.5 +API_MEMORY=256m +POOL_MAX_SIZE=8 +PG_CPUS=1 +PG_MEMORY=768m +# API_IMAGE defaults to mtusi-vasilev:lab3; set it for an already built rolling image. +# DATABASE_URL_FILE and CACHE_URL_FILE are fixed to /run/secrets/... in compose.yaml. +# Runtime binds 0.0.0.0:8080. Cache TTL60s and idempotency TTL24h are fixed policy. diff --git a/REPORT.md b/REPORT.md index c2679005..21698d52 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,145 @@ -# Отчёт — лабораторная 3 +# ЛР3: балансировка и отказ API-реплики -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +**Васильев Никита · БВТ2301 · цель:5 · трек1 «Цена масштабирования».** -## Запуск из чистого clone +Реализация продолжает собственную ЛР2, адаптированную к исходному skeleton ЛР3. Контракты, публичные tests, README, COURSE и CONTRIBUTING не изменялись. Код и анализ подготовлены с помощью AI-ассистента; доказательства получены настоящими локальными запусками, а не из чужих PR. Публикация не выполнялась. -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +## Воспроизводимый запуск -## Архитектура и решения +Нужны Docker с Compose и Python3.9+ для публичных скриптов. Для собственных тестов — uv и Python3.12. -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +```sh +make up +make check +make test +uv sync --locked --python 3.12 +make validate PYTHON=.venv/bin/python +make lint +make student-test +``` -## Доказательства критериев +`make up` создаёт локальные secrets/.env только при отсутствии, собирает образ, запускает PostgreSQL/Valkey, отдельную миграцию, две API и HAProxy. Единственная публикация — `127.0.0.1:8083`. API внутри слушают0.0.0.0:8080 и наружу порт не публикуют. `.env.example` описывает фактические параметры Compose. -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +Ручная сборка: `VCS_REF=$(git rev-parse HEAD) docker compose build`. Запуск: `docker compose up -d --wait`. Остановка с сохранением данных: `make down`. Не применяйте `down --volumes` для обычной остановки. -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +## Архитектура и ресурсы -## Эксперименты и отказы +```text +Клиент → HAProxy → API ×2 → PostgreSQL + ↘ Valkey: карточки пользователей TTL60s +``` -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Все API используют одну БД и сессии PostgreSQL. Sticky sessions нет. `X-Instance-Id` — случайный UUID, постоянный на время жизни процесса. `X-Request-Id` добавляется ко всем созданным API ответам, включая ошибки. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +Штатные ограничения: -## Ограничения и следующие шаги +|Сервис|CPU|RAM| +|---|---:|---:| +|Каждая API,2шт.|0.5|256MiB| +|PostgreSQL|1|768MiB| +|Valkey|0.5|128MiB| +|HAProxy|0.5|128MiB| +|migrate,однократный|0.5|256MiB| -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Нет container_name; один Compose-service API масштабируется. LB находится в frontend-сети, PostgreSQL/Valkey в backend, API в обеих. Хранилище PostgreSQL — именованный volume. API без root, read-only, cap_dropALL, no-new-privileges, tmpfs16MiB, pids96. Секреты передаются файлами, не входят в Git и Docker context. + +Python3.12, зависимости закреплены uv.lock; базовый Python-образ и HAProxy закреплены digest. PostgreSQL17.10 и Valkey8.1.3 закреплены версиями. Базовый образ и runtime-пакеты унаследованы из проверенной собственной ЛР2. Дополнительные aiohttp и matplotlib нужны только исследовательским инструментам, в runtime image не устанавливаются. + +## Идемпотентность + +Для отправки сообщения обязателен ASCII Idempotency-Key длиной1..128. Область — пользователь, POST, чат и ключ. Под одной транзакцией выполняются ACL, advisory lock, поиск результата, вставка сообщения и сохранение исходного201-ответа. TTL24h. Разный валидный body с тем же ключом —409. Отсутствующий attachment_ids и[] эквивалентны. Неуспешные5xx не фиксируются как результат. + +Повтор заново проверяет сессию и доступ. Одновременные запросы через разные API возвращают одно сообщение. Сбой до COMMIT откатывает сообщение вместе с ключом; после COMMIT клиент повторяет тот же ключ. LB не повторяет POST автоматически, включая создание чатов и пользователей. + +Подробности структуры, bytea для losslessUnicode U+0000 и транзакционных границ — [SCHEMA.md](SCHEMA.md). + +## Readiness, DNS и остановка + +HAProxy server-template разрешает до8 API через DockerDNS127.0.0.11, обновляет адреса без фиксированных IP. Roundrobin, активная проверка `/health/ready`, inter1s, timeoutcheck1s, fall2, rise2. Оценка обнаружения устойчивого отказа — примерно до3s без учёта аномалий планировщика; фактические переходы измерены отдельно. Fallback без readiness нет. + +Readiness выполняет дешёвую проверку обязательных таблиц и полей БД, а не только проверки процесса. Liveness отвечает независимо от БД. Если одна API теряет backend-сеть, она остаётся живой, но readiness503 исключает её из LB. + +ConnecttimeoutLB1s, server8s, client10s, queuetimeout2s, transparent retries0. Uvicorn grace5s, Compose stop8s. ПулБД до8 соединений/API, очередь32, ожидание2s, подключение2s, SQL2.5s, lock1.5s. Дополнительный client-side I/Odeadline3s закрывает зависшее соединение, даже если PostgreSQL paused и серверный statement_timeout не исполняется. Эти бюджеты не складываются в обещание единогоHTTP SLA. + +## Проверки уровней3–4 + +- [Публичный контракт и схема](evidence/contract-validation.txt):PASS. +- [Собственные тесты](evidence/tests-final.txt):77PASS, включая20конкурентных повторов через≥2API, bodyconflict, scopes, NUL, Unicode, malformedUTF8, Basicbody, cursor и заголовки. +- [Независимые HTTP-регрессии](evidence/independent-http.json):61PASS. +- [Независимые отказы](evidence/independent-faults.json):4PASS — ACLдоreplay, исчезновение обязательной таблицы, pausedPG с503примерно3.08s и восстановлением, logout под блокировкой с последующим отзывом. +- [LB без готовых API](evidence/lb-no-ready-api.json):503JSON, новыйX-Request-Idсовпадаетсerror.request_id, фиктивногоX-Instance-Idнет; прежняя сессия работает после восстановления. +- [КороткийTTL](evidence/independent-expiry.json):проверен отдельной API, рабочая конфигурация TTL3600не менялась. +- [Публичный persistence](evidence/persistence.txt):прежний токен и подтверждённые данные сохранились. +- [Публичный failover](evidence/failover-first.txt):123успешных записи,3неуспешных попытки, первое восстановление1.429s. +- [Отказ каждой реальной реплики](evidence/replica-failures.json):два отдельных прогона1419и1472успешных записей;83и62переходные ошибки соответственно. **Все подтверждённые записи каждого прогона найдены**, потерь нет. Target сопоставлен с настоящим containerID и оставлен остановленным; перед следующей проверкой предыдущий восстановлен. +- [Изоляция неготовой API](evidence/readiness-isolation.json):после потери backend-сети directready503;30/30последующих запросов черезLBуспешны и обслужены только другой API. После reconnect снова видны две. +- [Поочерёдная замена](evidence/rolling-update.json):3558успешных записей,257переходных ошибок, все подтверждённые сообщения сохранены. Обе API последовательно заменены, containerIDs и imageIDs изменились. + +Команды проверки: + +```sh +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-failover ACTION_SCRIPT=scripts/stop-one.sh +# Восстановить остановленную реплику перед следующими проверками: +docker compose up -d --no-recreate --wait +uv run --locked python scripts/verify_replicas.py +uv run --locked python scripts/verify_readiness.py +uv run --locked python scripts/verify_rolling.py +uv run --locked python scripts/verify_lb_unavailable.py +# Дополнительные независимые проверки, адаптированные для запуска из репозитория: +uv run --locked python scripts/verify_teacher_http.py --lab 3 --repo . --base-url http://127.0.0.1:8083 --output evidence/teacher-http-repeat.json +uv run --locked python scripts/verify_teacher_faults.py --output evidence/teacher-faults-repeat.json +``` + +Проверки отказов запускаются последовательно, не одновременно с нагрузочным исследованием. restart-hook сохраняет безопасные snapshots StartedAt/ID до и после, чтобы доказать перезапуск API,LB,PGиValkey. Все shellhooks executable100755. + +Rolling-target отличается revision-label, функциональный код и схема одинаковы. Этот опыт доказывает поочерёдную замену образа и процессов под трафиком, но не совместимость произвольного нового кода/схемы. Первоначальная миграция003с textнаbytea требует maintenancewindow со старой ЛР2; ограничения не скрываются. + +## Исследование на5 + +Методика, параметры и ограничения — [research/README.md](research/README.md). Основной файл [scaling-final.json](evidence/scaling-final.json), итоговая [таблица](evidence/scaling-final-summary.md), [график](evidence/scaling-final.svg). + +**Гипотеза:** рост API перестанет помогать при насыщении общей БД. Если активно ограничивает CPUquotaPostgreSQL, её увеличение при остальных неизменных ресурсах повысит успешный throughput. + +Сравниваются фиксированный суммарный бюджет API1CPU/1024MiB для1/2/4реплик и растущий бюджет по0.5CPU/256MiB на реплику. PostgreSQL специально ограничена0.25CPU/768MiB в основной матрице. Контрольное улучшение:4APIпо0.5CPU/256MiB, только CPUБДувеличен0.25→0.5. Штатный стенд имеет другую квотуБД1CPU. + +Предлагаемая нагрузка100/400/900уникальных POST/s,3повтора×6s,7конфигураций —63прогона. Генератор open-loop aiohttp, in-flightcap128; отдельно учитываются scheduled, attempts, successful201, errors и dropped. Процентили только успешных запросов; RPSпо реальному времени вместе с завершением начатых запросов. Actual CPU/RAM проверяются dockerinspect, samplesdockerstats сохраняются; CPUиRAM API сначала суммируются на каждомtimestamp. + +Основная матрица: **114780 успешных HTTP-ответов,0 HTTP-ошибок,61620 неотправленных слотов** из176400запланированных. Все dropped связаны с in-flightcap128; scheduler-drops0. Максимальная загрузка процесса генератора —31.54% одногоhostCPU. Успешность отправленных запросов не означает выполнение всех предложенных слотов. + +Медианы при900offeredPOST/s, по3повтора: + +|Серия|API1|API2|API4| +|---|---:|---:|---:| +|Fixed-total1CPU/1024MiB, successfulRPS|391.81|363.47|378.74| +|Growth0.5CPU/256MiBнаAPI, successfulRPS|163.01|384.98|442.33| + +При фиксированной сумме ресурсов увеличение числа процессов не дало выигрыша throughput. На900offered peak summed memoryAPIвfixedсерии составила96.91/159.57/304.92MiB для1/2/4процессов: у реплик есть собственные расходы. + +В growthсерии переход2→4APIдал только≈14.9% throughput при удвоении APIресурсов. Дляgrowth4на900offered медианаCPUБД25.05%приquota25%,API107.08%приобщемbudget200%,LBоколо5%CPU: общая ограниченная PostgreSQL стала активным узким местом. + +Контроль изменил **только CPUPostgreSQL0.25→0.5**, RAMБД768MiB и4APIпо0.5CPU/256MiB сохранены и проверены inspect: + +|Метрика,900offered/s|PG0.25CPU|PG0.5CPU| +|---|---:|---:| +|МедианаsuccessfulRPS|442.33|881.06| +|Медианаp95успешных,ms|621.58|223.69| +|Droppedслотов,3повтора|8147|298| +|МедианаDBCPU%|25.05|42.86| +|МедианаAPI CPU%,сумма|107.08|179.65| + +Подтверждённое улучшение:≈99.2%успешногоthroughput и≈64.0%сниженияp95вэтомопыте. После него [обратный контроль](evidence/scaling-reversal.json) вернулPG0.25CPU:411.104/471.464/465.411RPS,медиана465.411. Возврат производительности к исходному диапазону поддерживает причинное объяснение через квотуБД, хотя короткая серия и прогрев/checkpointоставляют шум. + +881RPSне объявляется новым пределом: это близко к предложенным900/s, а CPUAPIподошёл к своему бюджету. Для установления следующего ограничения понадобился бы отдельный более высокий профиль. Мы доказали границу специально ограниченной0.25CPUБД, а не общий максимум PostgreSQL. + +[Ресурсные графики](evidence/scaling-final-resources.svg) показывают CPUБД, CPUгенератора и droppedslots. Калибровочныеpilotфайлы сохранены отдельно и в63основных прогона не входят; обратный контроль —ещё3отдельныхпрогона. + +Runtimeисследования соответствует commit029bf9b, sourceSHA256записаны в JSON. Форматирование runnerбез изменения поведения отражено в [manifest](evidence/research-runner-manifest.json). После измерений добавлен только JSON503для случая отсутствия готовых backend; прежняя конфигурация сохранена в [haproxy-benchmark.cfg](evidence/haproxy-benchmark.cfg). Это изменение пути отказа не является измеренным улучшениемthroughput. + +После опыта штатные2API и PostgreSQL1CPUвосстановлены. Копии результатов не содержат токенов и секретов. + +## Ограничения и подготовка к защите + +Один DockerDesktophost, один LB, одна PostgreSQL и её volume остаются точками отказа. Переживание отказа узла или потери диска не заявляется. Короткие синтетические прогоны не равны промышленному SLA; после неопределённой сетевой ошибки POST повторяется с исходным ключом. Retention старых idempotency-записей не выполняется фоновым GC: срок учитывается при replay, просроченный ключ удаляется при его повторном использовании; неиспользуемые просроченные строки потребуют эксплуатационной очистки. + +Сначала на защите показать≥2разныхX-Instance-Id с одним токеном, затем конкурентный replay, остановку конкретного контейнера, сохранность прежних сообщений и таблицу/график исследования. [REVIEW_NOTES.md](REVIEW_NOTES.md) связывает учтённые ошибки с замечаниями преподавателя. diff --git a/evidence/contract-validation.txt b/evidence/contract-validation.txt new file mode 100644 index 00000000..ed9cd475 --- /dev/null +++ b/evidence/contract-validation.txt @@ -0,0 +1,4 @@ +.venv/bin/python scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. +.venv/bin/python scripts/validate_openapi.py +PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested. diff --git a/evidence/failover-first.txt b/evidence/failover-first.txt new file mode 100644 index 00000000..3fe88e2e --- /dev/null +++ b/evidence/failover-first.txt @@ -0,0 +1,4 @@ +python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://127.0.0.1:8083" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 123, "failed_attempts": 3, "first_recovery_seconds": 1.429} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/haproxy-benchmark.cfg b/evidence/haproxy-benchmark.cfg new file mode 100644 index 00000000..ae5f764a --- /dev/null +++ b/evidence/haproxy-benchmark.cfg @@ -0,0 +1,35 @@ +global + log stdout format raw local0 + maxconn 256 + stats socket /tmp/haproxy.sock mode 600 level admin + +defaults + mode http + log global + timeout connect 1s + timeout client 10s + timeout server 8s + timeout check 1s + timeout queue 2s + retries 0 + option httplog + +resolvers docker + nameserver dns 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + hold valid 1s + hold obsolete 1s + hold nx 1s + +frontend public + bind :8080 + default_backend apis + +backend apis + balance roundrobin + option httpchk GET /health/ready + http-check expect status 200 + default-server inter 1s fastinter 500ms downinter 1s fall 2 rise 2 + server-template api 1-8 api:8080 check resolvers docker resolve-prefer ipv4 init-addr libc,none diff --git a/evidence/independent-expiry.json b/evidence/independent-expiry.json new file mode 100644 index 00000000..70a3ddce --- /dev/null +++ b/evidence/independent-expiry.json @@ -0,0 +1,9 @@ +{ + "lab": 3, + "status": "PASS", + "configured_ttl_s": 2, + "valid_before_restart": 200, + "same_token_after_restart_and_expiry": 401, + "elapsed_after_login_s": 2.3318688750150613, + "main_api_reconfigured": false +} diff --git a/evidence/independent-faults.json b/evidence/independent-faults.json new file mode 100644 index 00000000..41fa072c --- /dev/null +++ b/evidence/independent-faults.json @@ -0,0 +1,92 @@ +{ + "tests": [ + { + "case": "ACL precedes both replay and conflict", + "status": "PASS", + "detail": { + "same_body": 404, + "changed_body": 404 + }, + "elapsed_s": 0.09069112502038479 + }, + { + "case": "readiness detects missing mandatory table", + "status": "PASS", + "detail": [ + { + "status": 503, + "elapsed_s": 0.08109846600564197, + "request_id": "b73d5368-2568-442a-b749-076a81e635b7", + "instance_id": "b5916273-3714-494a-9de5-dda6dc88b2e5", + "body": { + "error": { + "code": "unavailable", + "message": "Хранилище недоступно", + "request_id": "b73d5368-2568-442a-b749-076a81e635b7" + } + } + }, + { + "status": 503, + "elapsed_s": 0.007741153007373214, + "request_id": "502d1bfd-7338-4a02-b11f-da70d96a6aaf", + "instance_id": "01e8e3d3-878e-4af2-9fdd-5c0085dbeb7f", + "body": { + "error": { + "code": "unavailable", + "message": "Хранилище недоступно", + "request_id": "502d1bfd-7338-4a02-b11f-da70d96a6aaf" + } + } + } + ], + "elapsed_s": 0.8006304160226136 + }, + { + "case": "paused PostgreSQL bounded API error and recovery", + "status": "PASS", + "detail": { + "during_pause": [ + { + "status": 503, + "elapsed_s": 3.084492939990014, + "request_id": "75c8f628-2e6b-48fd-8996-272a52a0f9cc", + "instance_id": "b5916273-3714-494a-9de5-dda6dc88b2e5", + "body": { + "error": { + "code": "unavailable", + "message": "Хранилище недоступно", + "request_id": "75c8f628-2e6b-48fd-8996-272a52a0f9cc" + } + } + }, + { + "status": 503, + "elapsed_s": 3.083705213968642, + "request_id": "1f41f669-e5a7-4cb5-b4f4-5681f22edd55", + "instance_id": "b5916273-3714-494a-9de5-dda6dc88b2e5", + "body": { + "error": { + "code": "unavailable", + "message": "Хранилище временно недоступно", + "request_id": "1f41f669-e5a7-4cb5-b4f4-5681f22edd55" + } + } + } + ], + "recovered_status": 200 + }, + "elapsed_s": 4.286921292019542 + }, + { + "case": "logout cannot falsely succeed under DB lock", + "status": "PASS", + "detail": { + "blocked_logout": 503, + "retry": 204, + "old_token": 401 + }, + "elapsed_s": 2.920123041025363 + } + ] +} diff --git a/evidence/independent-http.json b/evidence/independent-http.json new file mode 100644 index 00000000..da760602 --- /dev/null +++ b/evidence/independent-http.json @@ -0,0 +1,313 @@ +{ + "lab": 3, + "base_url": "http://127.0.0.1:8083", + "tests": [ + { + "case": "message rejects wrong types/extra {'text': None}", + "status": "PASS", + "elapsed_s": 0.0272 + }, + { + "case": "message rejects wrong types/extra {'text': 123}", + "status": "PASS", + "elapsed_s": 0.0026 + }, + { + "case": "message rejects wrong types/extra {'text': True}", + "status": "PASS", + "elapsed_s": 0.0027 + }, + { + "case": "message rejects wrong types/extra {'text': []}", + "status": "PASS", + "elapsed_s": 0.0036 + }, + { + "case": "message rejects wrong types/extra {'text': 'x', 'TEXT': 'y'}", + "status": "PASS", + "elapsed_s": 0.0024 + }, + { + "case": "message rejects wrong types/extra {'Text': 'x'}", + "status": "PASS", + "elapsed_s": 0.0026 + }, + { + "case": "message rejects wrong types/extra {'text': 'x', 'attachment_ids': None}", + "status": "PASS", + "elapsed_s": 0.0039 + }, + { + "case": "message rejects wrong types/extra {'text': 'x', 'attachment_ids': {}}", + "status": "PASS", + "elapsed_s": 0.0027 + }, + { + "case": "message rejects wrong types/extra {}", + "status": "PASS", + "elapsed_s": 0.0026 + }, + { + "case": "invalid idempotency key ''", + "status": "PASS", + "elapsed_s": 0.0025 + }, + { + "case": "invalid idempotency key 'contains space'", + "status": "PASS", + "elapsed_s": 0.0024 + }, + { + "case": "invalid idempotency key 'xxxxxxxxxxxxxxxxxxxx'", + "status": "PASS", + "elapsed_s": 0.0023 + }, + { + "case": "invalid idempotency key 'bad/key'", + "status": "PASS", + "elapsed_s": 0.0025 + }, + { + "case": "missing idempotency key", + "status": "PASS", + "elapsed_s": 0.0028 + }, + { + "case": "malformed UTF8/JSON b'{bad'", + "status": "PASS", + "elapsed_s": 0.002 + }, + { + "case": "malformed UTF8/JSON b'\\xff'", + "status": "PASS", + "elapsed_s": 0.0017 + }, + { + "case": "malformed UTF8/JSON b'{\"text\":\"x\"}{}'", + "status": "PASS", + "elapsed_s": 0.0016 + }, + { + "case": "pagination /api/v1/chats?limit=", + "status": "PASS", + "elapsed_s": 0.0022 + }, + { + "case": "pagination /api/v1/chats?limit=0", + "status": "PASS", + "elapsed_s": 0.0025 + }, + { + "case": "pagination /api/v1/chats?limit=101", + "status": "PASS", + "elapsed_s": 0.0025 + }, + { + "case": "pagination /api/v1/chats?limit=abc", + "status": "PASS", + "elapsed_s": 0.052 + }, + { + "case": "pagination /api/v1/chats?limit=1&limit=2", + "status": "PASS", + "elapsed_s": 0.0029 + }, + { + "case": "pagination /api/v1/chats?cursor=", + "status": "PASS", + "elapsed_s": 0.0031 + }, + { + "case": "pagination /api/v1/chats?cursor=W10", + "status": "PASS", + "elapsed_s": 0.0029 + }, + { + "case": "pagination /api/v1/chats?cursor=bnVsbA", + "status": "PASS", + "elapsed_s": 0.0028 + }, + { + "case": "pagination /api/v1/chats/fd2889fb-7506-4b39-af52-0cbaf333768d/messages?limit=", + "status": "PASS", + "elapsed_s": 0.0033 + }, + { + "case": "pagination /api/v1/chats/fd2889fb-7506-4b39-af52-0cbaf333768d/messages?limit=0", + "status": "PASS", + "elapsed_s": 0.0027 + }, + { + "case": "pagination /api/v1/chats/fd2889fb-7506-4b39-af52-0cbaf333768d/messages?limit=101", + "status": "PASS", + "elapsed_s": 0.0027 + }, + { + "case": "pagination /api/v1/chats/fd2889fb-7506-4b39-af52-0cbaf333768d/messages?limit=abc", + "status": "PASS", + "elapsed_s": 0.0023 + }, + { + "case": "pagination /api/v1/chats/fd2889fb-7506-4b39-af52-0cbaf333768d/messages?limit=1&limit=2", + "status": "PASS", + "elapsed_s": 0.0028 + }, + { + "case": "pagination /api/v1/chats/fd2889fb-7506-4b39-af52-0cbaf333768d/messages?cursor=", + "status": "PASS", + "elapsed_s": 0.0022 + }, + { + "case": "pagination /api/v1/chats/fd2889fb-7506-4b39-af52-0cbaf333768d/messages?cursor=W10", + "status": "PASS", + "elapsed_s": 0.0018 + }, + { + "case": "pagination /api/v1/chats/fd2889fb-7506-4b39-af52-0cbaf333768d/messages?cursor=bnVsbA", + "status": "PASS", + "elapsed_s": 0.0019 + }, + { + "case": "typed cursor (2, None)", + "status": "PASS", + "elapsed_s": 0.0034 + }, + { + "case": "typed cursor (2, 1)", + "status": "PASS", + "elapsed_s": 0.0031 + }, + { + "case": "typed cursor (2, '2026-13-01T00:00:00Z')", + "status": "PASS", + "elapsed_s": 0.0025 + }, + { + "case": "typed cursor (3, False)", + "status": "PASS", + "elapsed_s": 0.0035 + }, + { + "case": "typed cursor (3, [])", + "status": "PASS", + "elapsed_s": 0.0035 + }, + { + "case": "typed cursor (3, {})", + "status": "PASS", + "elapsed_s": 0.0033 + }, + { + "case": "typed cursor (3, 'not-a-uuid')", + "status": "PASS", + "elapsed_s": 0.0034 + }, + { + "case": "invalid UUID path", + "status": "PASS", + "elapsed_s": 0.0029 + }, + { + "case": "member UUID []", + "status": "PASS", + "elapsed_s": 0.0029 + }, + { + "case": "member UUID {}", + "status": "PASS", + "elapsed_s": 0.0031 + }, + { + "case": "member UUID 123", + "status": "PASS", + "elapsed_s": 0.003 + }, + { + "case": "member UUID False", + "status": "PASS", + "elapsed_s": 0.0028 + }, + { + "case": "unknown member400", + "status": "PASS", + "elapsed_s": 0.0035 + }, + { + "case": "login rejects body b'{bad'", + "status": "PASS", + "elapsed_s": 0.0016 + }, + { + "case": "login rejects body b'{}'", + "status": "PASS", + "elapsed_s": 0.0525 + }, + { + "case": "login rejects body b'null'", + "status": "PASS", + "elapsed_s": 0.0021 + }, + { + "case": "login rejects body b' '", + "status": "PASS", + "elapsed_s": 0.0027 + }, + { + "case": "nonASCII Bearer401", + "status": "PASS", + "elapsed_s": 0.0025 + }, + { + "case": "username trailing whitespace", + "status": "PASS", + "elapsed_s": 0.0019 + }, + { + "case": "username trailing whitespace", + "status": "PASS", + "elapsed_s": 0.0017 + }, + { + "case": "blank password400", + "status": "PASS", + "elapsed_s": 0.002 + }, + { + "case": "UTF8 colon128 password and NUL display name", + "status": "PASS", + "elapsed_s": 0.2074 + }, + { + "case": "omitted attachment_ids equals [] and conflict", + "status": "PASS", + "elapsed_s": 0.0857 + }, + { + "case": "32 concurrent same key all201 same message", + "status": "PASS", + "elapsed_s": 0.1192 + }, + { + "case": "key scope user and chat", + "status": "PASS", + "elapsed_s": 0.0135 + }, + { + "case": "outsider cannot send", + "status": "PASS", + "elapsed_s": 0.0028 + }, + { + "case": "NUL message exact post replay history", + "status": "PASS", + "elapsed_s": 0.0105 + }, + { + "case": "logout visible through all replicas", + "status": "PASS", + "elapsed_s": 0.2597 + } + ], + "passed": 61, + "failed": 0 +} diff --git a/evidence/lb-no-ready-api.json b/evidence/lb-no-ready-api.json new file mode 100644 index 00000000..b4cc278b --- /dev/null +++ b/evidence/lb-no-ready-api.json @@ -0,0 +1,13 @@ +{ + "status": 503, + "body": { + "error": { + "code": "unavailable", + "message": "No ready API", + "request_id": "ec5c5343-c31f-4da7-be00-7f3849be9dbe" + } + }, + "request_id": "ec5c5343-c31f-4da7-be00-7f3849be9dbe", + "instance_id": null, + "recovered_existing_session": true +} diff --git a/evidence/lb-no-ready-api.txt b/evidence/lb-no-ready-api.txt new file mode 100644 index 00000000..29e81afe --- /dev/null +++ b/evidence/lb-no-ready-api.txt @@ -0,0 +1,29 @@ + Container mtusi-vasilev-lab3-api-3 Stopping + Container mtusi-vasilev-lab3-api-4 Stopping + Container mtusi-vasilev-lab3-api-4 Stopped + Container mtusi-vasilev-lab3-api-3 Stopped + Container mtusi-vasilev-lab3-postgres-1 Waiting + Container mtusi-vasilev-lab3-postgres-1 Healthy + Container mtusi-vasilev-lab3-migrate-1 Starting + Container mtusi-vasilev-lab3-migrate-1 Started + Container mtusi-vasilev-lab3-migrate-1 Waiting + Container mtusi-vasilev-lab3-cache-1 Waiting + Container mtusi-vasilev-lab3-cache-1 Healthy + Container mtusi-vasilev-lab3-migrate-1 Exited + Container mtusi-vasilev-lab3-api-4 Starting + Container mtusi-vasilev-lab3-api-4 Started + Container mtusi-vasilev-lab3-api-3 Starting + Container mtusi-vasilev-lab3-api-3 Started +{ + "status": 503, + "body": { + "error": { + "code": "unavailable", + "message": "No ready API", + "request_id": "ec5c5343-c31f-4da7-be00-7f3849be9dbe" + } + }, + "request_id": "ec5c5343-c31f-4da7-be00-7f3849be9dbe", + "instance_id": null, + "recovered_existing_session": true +} diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..111da060 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,3 @@ +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://127.0.0.1:8083" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/readiness-isolation.json b/evidence/readiness-isolation.json new file mode 100644 index 00000000..04269dc4 --- /dev/null +++ b/evidence/readiness-isolation.json @@ -0,0 +1,11 @@ +{ + "target": "be9077fda25a10358650f9e60386e75b6cf8eb834756848ac73426a8c5e6cb44", + "failed_instance": "3a2b912b-b9d3-4884-b5a3-ef1ad50f3c66", + "direct_readiness": 503, + "seconds_until_verification": 7.425393832963891, + "lb_successful_requests": 30, + "lb_instances": [ + "8df6f4db-808e-4d97-b341-0729fad5b95e" + ], + "recovered_two_instances": true +} diff --git a/evidence/readiness-isolation.txt b/evidence/readiness-isolation.txt new file mode 100644 index 00000000..04269dc4 --- /dev/null +++ b/evidence/readiness-isolation.txt @@ -0,0 +1,11 @@ +{ + "target": "be9077fda25a10358650f9e60386e75b6cf8eb834756848ac73426a8c5e6cb44", + "failed_instance": "3a2b912b-b9d3-4884-b5a3-ef1ad50f3c66", + "direct_readiness": 503, + "seconds_until_verification": 7.425393832963891, + "lb_successful_requests": 30, + "lb_instances": [ + "8df6f4db-808e-4d97-b341-0729fad5b95e" + ], + "recovered_two_instances": true +} diff --git a/evidence/replica-failures.json b/evidence/replica-failures.json new file mode 100644 index 00000000..e0e63644 --- /dev/null +++ b/evidence/replica-failures.json @@ -0,0 +1,35 @@ +{ + "real_instances_before": { + "607ae394e5d53a440ea76c2dfed0b2df0096a50a1a628e18322fdc1a7d44057b": "b5916273-3714-494a-9de5-dda6dc88b2e5", + "050f8e6d2c4c62fcbfd5be06a398d25a50b00a20abc06fb44212a7d96bc4d130": "fde77ccb-f644-4f3d-8bdc-9374f3537e63" + }, + "runs": [ + { + "target_container": "607ae394e5d53a440ea76c2dfed0b2df0096a50a1a628e18322fdc1a7d44057b", + "target_alias": "b5916273-3714-494a-9de5-dda6dc88b2e5", + "successful_writes": 1419, + "failed_attempts": 83, + "successful_rps": 240.92887504635945, + "recovery_seconds": 0.0023248750367201865, + "observed_after": [ + "fde77ccb-f644-4f3d-8bdc-9374f3537e63" + ], + "target_running_after_hook": false, + "all_confirmed_present": true + }, + { + "target_container": "050f8e6d2c4c62fcbfd5be06a398d25a50b00a20abc06fb44212a7d96bc4d130", + "target_alias": "fde77ccb-f644-4f3d-8bdc-9374f3537e63", + "successful_writes": 1472, + "failed_attempts": 62, + "successful_rps": 231.41351169464048, + "recovery_seconds": 0.0026418750057928264, + "observed_after": [ + "fdf23b82-08f3-4a92-a03f-d5f1cab7cfef" + ], + "target_running_after_hook": false, + "all_confirmed_present": true + } + ], + "pass": true +} diff --git a/evidence/replica-failures.txt b/evidence/replica-failures.txt new file mode 100644 index 00000000..fc918663 --- /dev/null +++ b/evidence/replica-failures.txt @@ -0,0 +1,67 @@ + Container mtusi-vasilev-lab3-api-1 Running + Container mtusi-vasilev-lab3-lb-1 Running + Container mtusi-vasilev-lab3-postgres-1 Running + Container mtusi-vasilev-lab3-cache-1 Running + Container mtusi-vasilev-lab3-postgres-1 Waiting + Container mtusi-vasilev-lab3-postgres-1 Healthy + Container mtusi-vasilev-lab3-migrate-1 Starting + Container mtusi-vasilev-lab3-migrate-1 Started + Container mtusi-vasilev-lab3-cache-1 Waiting + Container mtusi-vasilev-lab3-migrate-1 Waiting + Container mtusi-vasilev-lab3-cache-1 Healthy + Container mtusi-vasilev-lab3-migrate-1 Exited + Container mtusi-vasilev-lab3-api-2 Starting + Container mtusi-vasilev-lab3-api-2 Started + Container mtusi-vasilev-lab3-api-1 Waiting + Container mtusi-vasilev-lab3-api-2 Waiting + Container mtusi-vasilev-lab3-api-1 Healthy + Container mtusi-vasilev-lab3-api-2 Healthy + Container mtusi-vasilev-lab3-migrate-1 Waiting + Container mtusi-vasilev-lab3-api-1 Waiting + Container mtusi-vasilev-lab3-api-2 Waiting + Container mtusi-vasilev-lab3-lb-1 Waiting + Container mtusi-vasilev-lab3-postgres-1 Waiting + Container mtusi-vasilev-lab3-cache-1 Waiting + Container mtusi-vasilev-lab3-cache-1 Healthy + Container mtusi-vasilev-lab3-lb-1 Healthy + Container mtusi-vasilev-lab3-migrate-1 Exited + Container mtusi-vasilev-lab3-postgres-1 Healthy + Container mtusi-vasilev-lab3-api-1 Healthy + Container mtusi-vasilev-lab3-api-2 Healthy +{"stopped_container": "607ae394e5d53a440ea76c2dfed0b2df0096a50a1a628e18322fdc1a7d44057b", "instance_id": "b5916273-3714-494a-9de5-dda6dc88b2e5"} +{"stopped_container": "050f8e6d2c4c62fcbfd5be06a398d25a50b00a20abc06fb44212a7d96bc4d130", "instance_id": "fde77ccb-f644-4f3d-8bdc-9374f3537e63"} +{ + "real_instances_before": { + "607ae394e5d53a440ea76c2dfed0b2df0096a50a1a628e18322fdc1a7d44057b": "b5916273-3714-494a-9de5-dda6dc88b2e5", + "050f8e6d2c4c62fcbfd5be06a398d25a50b00a20abc06fb44212a7d96bc4d130": "fde77ccb-f644-4f3d-8bdc-9374f3537e63" + }, + "runs": [ + { + "target_container": "607ae394e5d53a440ea76c2dfed0b2df0096a50a1a628e18322fdc1a7d44057b", + "target_alias": "b5916273-3714-494a-9de5-dda6dc88b2e5", + "successful_writes": 1419, + "failed_attempts": 83, + "successful_rps": 240.92887504635945, + "recovery_seconds": 0.0023248750367201865, + "observed_after": [ + "fde77ccb-f644-4f3d-8bdc-9374f3537e63" + ], + "target_running_after_hook": false, + "all_confirmed_present": true + }, + { + "target_container": "050f8e6d2c4c62fcbfd5be06a398d25a50b00a20abc06fb44212a7d96bc4d130", + "target_alias": "fde77ccb-f644-4f3d-8bdc-9374f3537e63", + "successful_writes": 1472, + "failed_attempts": 62, + "successful_rps": 231.41351169464048, + "recovery_seconds": 0.0026418750057928264, + "observed_after": [ + "fdf23b82-08f3-4a92-a03f-d5f1cab7cfef" + ], + "target_running_after_hook": false, + "all_confirmed_present": true + } + ], + "pass": true +} diff --git a/evidence/research-runner-manifest.json b/evidence/research-runner-manifest.json new file mode 100644 index 00000000..2d5defe0 --- /dev/null +++ b/evidence/research-runner-manifest.json @@ -0,0 +1,11 @@ +{ + "executed_before_formatting": { + "research/run.py": "aba9205e2dc9847b13711019848b5b65d57a1c0840190aff6cfeee1708fc972d", + "research/load.py": "5bea62916f9d701b8dbe10c44bfae9bea0ea67789862f408593f43b91634143a" + }, + "committed_after_formatting": { + "research/run.py": "6db58307302ba83576501c7761d9e8c08ff183cd1517b2ecb19c9b2dee46d778", + "research/load.py": "63857926d91c1c52a5ef19cbfc2a5a8c50df701e53386eacd55cd36dbe59bc77" + }, + "note": "ruff format changed only source layout during measurement; no runtime container or benchmark behavior was changed." +} diff --git a/evidence/restart-after.json b/evidence/restart-after.json new file mode 100644 index 00000000..c6f3fff1 --- /dev/null +++ b/evidence/restart-after.json @@ -0,0 +1,42 @@ +[ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "started_at": "2026-11-06T15:14:19.739138675Z", + "cpu_quota": 500000000, + "memory": 268435456 + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "started_at": "2026-11-06T15:14:19.753008862Z", + "cpu_quota": 500000000, + "memory": 268435456 + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "started_at": "2026-11-06T15:14:19.460690889Z", + "cpu_quota": 500000000, + "memory": 134217728 + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "started_at": "2026-11-06T15:14:19.430244988Z", + "cpu_quota": 500000000, + "memory": 134217728 + }, + { + "id": "d72d342a99b838fc75686476cc1b0c5b2efe5b9ff002a3e12a3234d4adb4c613", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "started_at": "2026-11-06T15:14:19.445218459Z", + "cpu_quota": 1000000000, + "memory": 805306368 + } +] diff --git a/evidence/restart-before.json b/evidence/restart-before.json new file mode 100644 index 00000000..857aed88 --- /dev/null +++ b/evidence/restart-before.json @@ -0,0 +1,42 @@ +[ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "started_at": "2026-11-06T15:13:08.172211608Z", + "cpu_quota": 500000000, + "memory": 268435456 + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "started_at": "2026-11-06T15:13:08.077176252Z", + "cpu_quota": 500000000, + "memory": 268435456 + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "started_at": "2026-11-06T14:55:08.17509564Z", + "cpu_quota": 500000000, + "memory": 134217728 + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "started_at": "2026-11-06T15:13:01.454797957Z", + "cpu_quota": 500000000, + "memory": 134217728 + }, + { + "id": "d72d342a99b838fc75686476cc1b0c5b2efe5b9ff002a3e12a3234d4adb4c613", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "started_at": "2026-11-06T15:12:21.564759223Z", + "cpu_quota": 1000000000, + "memory": 805306368 + } +] diff --git a/evidence/rolling-update.json b/evidence/rolling-update.json new file mode 100644 index 00000000..0e562d7a --- /dev/null +++ b/evidence/rolling-update.json @@ -0,0 +1,39 @@ +{ + "before": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "started_at": "2026-11-06T15:14:19.739138675Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "started_at": "2026-11-06T15:14:19.753008862Z" + } + ], + "after": [ + { + "id": "913f0e142dc7441c27cdb712499cd492ba92043e9e4a5e0be54a65b2fee72f28", + "image_id": "sha256:c2052979740ef0b96efd01ac24394ce61b09ae24dd7dcdffa69d6829c6053b71", + "started_at": "2026-11-06T15:14:29.20515981Z" + }, + { + "id": "184c4778883ed8e10bcbec05b69b2756b701bd6dd3976572d57e49255b806556", + "image_id": "sha256:c2052979740ef0b96efd01ac24394ce61b09ae24dd7dcdffa69d6829c6053b71", + "started_at": "2026-11-06T15:14:35.879897946Z" + } + ], + "successful_writes": 3558, + "failed_attempts": 257, + "elapsed_seconds": 16.29884020803729, + "successful_rps": 218.29774110218455, + "observed_instances": [ + "1ef45a61-bbe0-4bd9-904f-5bbd88593528", + "38f843bc-29a0-4544-aab6-edf2326f9ad9", + "5250815b-8d6a-435e-a200-d63dc46c0c51", + "cdb74aa3-b7d5-4e85-9152-70e9afa13c29" + ], + "largest_success_gap_seconds": 1.0128310000291094, + "all_confirmed_present": true, + "note": "Target image differs by revision label; same API/schema. This verifies sequential replacement, not arbitrary schema compatibility." +} diff --git a/evidence/rolling-update.txt b/evidence/rolling-update.txt new file mode 100644 index 00000000..8007f1cb --- /dev/null +++ b/evidence/rolling-update.txt @@ -0,0 +1,83 @@ +#0 building with "colima" instance using docker driver + +#1 [internal] load build definition from Dockerfile +#1 transferring dockerfile: 102B done +#1 DONE 0.0s + +#2 [internal] load metadata for docker.io/library/mtusi-vasilev:lab3 +#2 DONE 0.0s + +#3 [internal] load .dockerignore +#3 transferring context: 2B done +#3 DONE 0.0s + +#4 [1/1] FROM docker.io/library/mtusi-vasilev:lab3@sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868 +#4 resolve docker.io/library/mtusi-vasilev:lab3@sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868 done +#4 CACHED + +#5 exporting to image +#5 exporting layers done +#5 exporting manifest sha256:b40d4ac1452a5dc13cceaf50a551c9bc40bbc302dc1c3fe83e66afa0c55cf172 done +#5 exporting config sha256:123f1da685332b5c9d2a569f1934bf65b12007f1bacfb6fa92aaca33ddd6361d done +#5 exporting attestation manifest sha256:e457177f482340b3b7dbd0293bc41aa8b4b49505d8cbc9665e97de4d8c58edf6 done +#5 exporting manifest list sha256:c2052979740ef0b96efd01ac24394ce61b09ae24dd7dcdffa69d6829c6053b71 done +#5 naming to docker.io/library/mtusi-vasilev:lab3-rolling done +#5 unpacking to docker.io/library/mtusi-vasilev:lab3-rolling done +#5 DONE 0.0s + Container mtusi-vasilev-lab3-api-4 Running + Container mtusi-vasilev-lab3-api-5 Creating + Container mtusi-vasilev-lab3-api-5 Created + Container mtusi-vasilev-lab3-api-5 Starting + Container mtusi-vasilev-lab3-api-5 Started + Container mtusi-vasilev-lab3-api-5 Waiting + Container mtusi-vasilev-lab3-api-4 Waiting + Container mtusi-vasilev-lab3-api-5 Healthy + Container mtusi-vasilev-lab3-api-4 Healthy + Container mtusi-vasilev-lab3-api-5 Running + Container mtusi-vasilev-lab3-api-6 Creating + Container mtusi-vasilev-lab3-api-6 Created + Container mtusi-vasilev-lab3-api-6 Starting + Container mtusi-vasilev-lab3-api-6 Started + Container mtusi-vasilev-lab3-api-6 Waiting + Container mtusi-vasilev-lab3-api-5 Waiting + Container mtusi-vasilev-lab3-api-6 Healthy + Container mtusi-vasilev-lab3-api-5 Healthy +{ + "before": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "started_at": "2026-11-06T15:14:19.739138675Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "started_at": "2026-11-06T15:14:19.753008862Z" + } + ], + "after": [ + { + "id": "913f0e142dc7441c27cdb712499cd492ba92043e9e4a5e0be54a65b2fee72f28", + "image_id": "sha256:c2052979740ef0b96efd01ac24394ce61b09ae24dd7dcdffa69d6829c6053b71", + "started_at": "2026-11-06T15:14:29.20515981Z" + }, + { + "id": "184c4778883ed8e10bcbec05b69b2756b701bd6dd3976572d57e49255b806556", + "image_id": "sha256:c2052979740ef0b96efd01ac24394ce61b09ae24dd7dcdffa69d6829c6053b71", + "started_at": "2026-11-06T15:14:35.879897946Z" + } + ], + "successful_writes": 3558, + "failed_attempts": 257, + "elapsed_seconds": 16.29884020803729, + "successful_rps": 218.29774110218455, + "observed_instances": [ + "1ef45a61-bbe0-4bd9-904f-5bbd88593528", + "38f843bc-29a0-4544-aab6-edf2326f9ad9", + "5250815b-8d6a-435e-a200-d63dc46c0c51", + "cdb74aa3-b7d5-4e85-9152-70e9afa13c29" + ], + "largest_success_gap_seconds": 1.0128310000291094, + "all_confirmed_present": true, + "note": "Target image differs by revision label; same API/schema. This verifies sequential replacement, not arbitrary schema compatibility." +} diff --git a/evidence/scaling-final-resources.png b/evidence/scaling-final-resources.png new file mode 100644 index 0000000000000000000000000000000000000000..c37c32166301bd732a0f1320c43dd055b6960579 GIT binary patch literal 104333 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 + + + + + + + 2026-11-06T18:15:54.061396 + image/svg+xml + + + Matplotlib v3.10.8, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/evidence/scaling-final-summary.json b/evidence/scaling-final-summary.json new file mode 100644 index 00000000..4dabc94c --- /dev/null +++ b/evidence/scaling-final-summary.json @@ -0,0 +1,338 @@ +[ + { + "configuration": "fixed-1", + "offered_rate": 100, + "repeats": 3, + "median_successful_rps": 100.061, + "median_p95_ms": 8.597, + "total_successful": 1800, + "total_errors": 0, + "total_dropped": 0, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.08843281826729238, + "total_scheduled": 1800, + "median_db_cpu_percent": 10.12, + "median_api_cpu_percent_sum": 31.896666666666665, + "max_api_memory_mib_sum": 92.3 + }, + { + "configuration": "fixed-1", + "offered_rate": 400, + "repeats": 3, + "median_successful_rps": 399.73, + "median_p95_ms": 98.167, + "total_successful": 7200, + "total_errors": 0, + "total_dropped": 0, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.2029229202321888, + "total_scheduled": 7200, + "median_db_cpu_percent": 16.189999999999998, + "median_api_cpu_percent_sum": 50.83333333333333, + "max_api_memory_mib_sum": 103.3 + }, + { + "configuration": "fixed-1", + "offered_rate": 900, + "repeats": 3, + "median_successful_rps": 391.81, + "median_p95_ms": 412.474, + "total_successful": 7324, + "total_errors": 0, + "total_dropped": 8876, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.20232546694036863, + "total_scheduled": 16200, + "median_db_cpu_percent": 19.99, + "median_api_cpu_percent_sum": 106.48, + "max_api_memory_mib_sum": 96.91 + }, + { + "configuration": "fixed-2", + "offered_rate": 100, + "repeats": 3, + "median_successful_rps": 100.038, + "median_p95_ms": 10.166, + "total_successful": 1800, + "total_errors": 0, + "total_dropped": 0, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.08871829307849742, + "total_scheduled": 1800, + "median_db_cpu_percent": 8.273333333333333, + "median_api_cpu_percent_sum": 35.593333333333334, + "max_api_memory_mib_sum": 151.79000000000002 + }, + { + "configuration": "fixed-2", + "offered_rate": 400, + "repeats": 3, + "median_successful_rps": 395.474, + "median_p95_ms": 195.18, + "total_successful": 7200, + "total_errors": 0, + "total_dropped": 0, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.20277991022584074, + "total_scheduled": 7200, + "median_db_cpu_percent": 17.583333333333336, + "median_api_cpu_percent_sum": 64.65333333333334, + "max_api_memory_mib_sum": 158.69 + }, + { + "configuration": "fixed-2", + "offered_rate": 900, + "repeats": 3, + "median_successful_rps": 363.473, + "median_p95_ms": 600.226, + "total_successful": 7076, + "total_errors": 0, + "total_dropped": 9124, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.1818849475837354, + "total_scheduled": 16200, + "median_db_cpu_percent": 17.34, + "median_api_cpu_percent_sum": 76.5875, + "max_api_memory_mib_sum": 159.57 + }, + { + "configuration": "fixed-4", + "offered_rate": 100, + "repeats": 3, + "median_successful_rps": 100.076, + "median_p95_ms": 59.538, + "total_successful": 1800, + "total_errors": 0, + "total_dropped": 0, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.08237912047279333, + "total_scheduled": 1800, + "median_db_cpu_percent": 9.053333333333333, + "median_api_cpu_percent_sum": 40.846666666666664, + "max_api_memory_mib_sum": 295.64 + }, + { + "configuration": "fixed-4", + "offered_rate": 400, + "repeats": 3, + "median_successful_rps": 390.192, + "median_p95_ms": 383.246, + "total_successful": 7078, + "total_errors": 0, + "total_dropped": 122, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.19185405633444985, + "total_scheduled": 7200, + "median_db_cpu_percent": 18.94, + "median_api_cpu_percent_sum": 79.71666666666667, + "max_api_memory_mib_sum": 286.86 + }, + { + "configuration": "fixed-4", + "offered_rate": 900, + "repeats": 3, + "median_successful_rps": 378.738, + "median_p95_ms": 718.332, + "total_successful": 7077, + "total_errors": 0, + "total_dropped": 9123, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.18088731292292065, + "total_scheduled": 16200, + "median_db_cpu_percent": 15.87, + "median_api_cpu_percent_sum": 86.33666666666667, + "max_api_memory_mib_sum": 304.92 + }, + { + "configuration": "growth-1", + "offered_rate": 100, + "repeats": 3, + "median_successful_rps": 100.04, + "median_p95_ms": 68.874, + "total_successful": 1800, + "total_errors": 0, + "total_dropped": 0, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.09423092680755431, + "total_scheduled": 1800, + "median_db_cpu_percent": 9.836666666666666, + "median_api_cpu_percent_sum": 32.49333333333333, + "max_api_memory_mib_sum": 78.11 + }, + { + "configuration": "growth-1", + "offered_rate": 400, + "repeats": 3, + "median_successful_rps": 167.785, + "median_p95_ms": 1406.105, + "total_successful": 3290, + "total_errors": 0, + "total_dropped": 3910, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.10820845725487749, + "total_scheduled": 7200, + "median_db_cpu_percent": 10.633333333333333, + "median_api_cpu_percent_sum": 51.35666666666667, + "max_api_memory_mib_sum": 91.02 + }, + { + "configuration": "growth-1", + "offered_rate": 900, + "repeats": 3, + "median_successful_rps": 163.01, + "median_p95_ms": 1500.974, + "total_successful": 3166, + "total_errors": 0, + "total_dropped": 13034, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.11270218653839223, + "total_scheduled": 16200, + "median_db_cpu_percent": 10.005, + "median_api_cpu_percent_sum": 47.3475, + "max_api_memory_mib_sum": 90.62 + }, + { + "configuration": "growth-2", + "offered_rate": 100, + "repeats": 3, + "median_successful_rps": 100.056, + "median_p95_ms": 10.563, + "total_successful": 1800, + "total_errors": 0, + "total_dropped": 0, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.07299362032286852, + "total_scheduled": 1800, + "median_db_cpu_percent": 9.376666666666667, + "median_api_cpu_percent_sum": 36.13666666666666, + "max_api_memory_mib_sum": 160.12 + }, + { + "configuration": "growth-2", + "offered_rate": 400, + "repeats": 3, + "median_successful_rps": 399.789, + "median_p95_ms": 183.603, + "total_successful": 7093, + "total_errors": 0, + "total_dropped": 107, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.17175096821894723, + "total_scheduled": 7200, + "median_db_cpu_percent": 19.95, + "median_api_cpu_percent_sum": 73.05999999999999, + "max_api_memory_mib_sum": 165.43 + }, + { + "configuration": "growth-2", + "offered_rate": 900, + "repeats": 3, + "median_successful_rps": 384.981, + "median_p95_ms": 477.664, + "total_successful": 7321, + "total_errors": 0, + "total_dropped": 8879, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.18570354381517867, + "total_scheduled": 16200, + "median_db_cpu_percent": 20.9525, + "median_api_cpu_percent_sum": 79.7275, + "max_api_memory_mib_sum": 166.75 + }, + { + "configuration": "growth-4", + "offered_rate": 100, + "repeats": 3, + "median_successful_rps": 100.071, + "median_p95_ms": 7.386, + "total_successful": 1800, + "total_errors": 0, + "total_dropped": 0, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.0794899513187198, + "total_scheduled": 1800, + "median_db_cpu_percent": 7.6466666666666665, + "median_api_cpu_percent_sum": 43.79666666666667, + "max_api_memory_mib_sum": 287.78999999999996 + }, + { + "configuration": "growth-4", + "offered_rate": 400, + "repeats": 3, + "median_successful_rps": 399.843, + "median_p95_ms": 18.634, + "total_successful": 7200, + "total_errors": 0, + "total_dropped": 0, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.19108340412160874, + "total_scheduled": 7200, + "median_db_cpu_percent": 18.136666666666667, + "median_api_cpu_percent_sum": 86.13000000000001, + "max_api_memory_mib_sum": 319.14 + }, + { + "configuration": "growth-4", + "offered_rate": 900, + "repeats": 3, + "median_successful_rps": 442.326, + "median_p95_ms": 621.578, + "total_successful": 8053, + "total_errors": 0, + "total_dropped": 8147, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.20250008266902153, + "total_scheduled": 16200, + "median_db_cpu_percent": 25.053333333333335, + "median_api_cpu_percent_sum": 107.07666666666667, + "max_api_memory_mib_sum": 317.97999999999996 + }, + { + "configuration": "db-improved", + "offered_rate": 100, + "repeats": 3, + "median_successful_rps": 100.064, + "median_p95_ms": 7.358, + "total_successful": 1800, + "total_errors": 0, + "total_dropped": 0, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.08305383954688951, + "total_scheduled": 1800, + "median_db_cpu_percent": 9.74, + "median_api_cpu_percent_sum": 44.056666666666665, + "max_api_memory_mib_sum": 313.15000000000003 + }, + { + "configuration": "db-improved", + "offered_rate": 400, + "repeats": 3, + "median_successful_rps": 399.815, + "median_p95_ms": 5.889, + "total_successful": 7200, + "total_errors": 0, + "total_dropped": 0, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.17013195582514973, + "total_scheduled": 7200, + "median_db_cpu_percent": 17.783333333333335, + "median_api_cpu_percent_sum": 76.28999999999999, + "max_api_memory_mib_sum": 318.8 + }, + { + "configuration": "db-improved", + "offered_rate": 900, + "repeats": 3, + "median_successful_rps": 881.057, + "median_p95_ms": 223.691, + "total_successful": 15902, + "total_errors": 0, + "total_dropped": 298, + "total_scheduler_dropped": 0, + "max_driver_cpu_fraction": 0.31538257716045937, + "total_scheduled": 16200, + "median_db_cpu_percent": 42.86333333333333, + "median_api_cpu_percent_sum": 179.64666666666668, + "max_api_memory_mib_sum": 316.5 + } +] diff --git a/evidence/scaling-final-summary.md b/evidence/scaling-final-summary.md new file mode 100644 index 00000000..93add3bd --- /dev/null +++ b/evidence/scaling-final-summary.md @@ -0,0 +1,27 @@ +# Scaling results + +CPU%: 100% means one logical CPU. Memory is summed Docker MemUsage, not heap RSS. + +|Configuration|Offered/s|Success/s median|p95 ms median|Errors total|Dropped total|DB CPU% median|API CPU% sum median|API peak MiB sum| +|---|---:|---:|---:|---:|---:|---:|---:|---:| +|fixed-1|100|100.06|8.60|0|0|10.12|31.90|92.30| +|fixed-1|400|399.73|98.17|0|0|16.19|50.83|103.30| +|fixed-1|900|391.81|412.47|0|8876|19.99|106.48|96.91| +|fixed-2|100|100.04|10.17|0|0|8.27|35.59|151.79| +|fixed-2|400|395.47|195.18|0|0|17.58|64.65|158.69| +|fixed-2|900|363.47|600.23|0|9124|17.34|76.59|159.57| +|fixed-4|100|100.08|59.54|0|0|9.05|40.85|295.64| +|fixed-4|400|390.19|383.25|0|122|18.94|79.72|286.86| +|fixed-4|900|378.74|718.33|0|9123|15.87|86.34|304.92| +|growth-1|100|100.04|68.87|0|0|9.84|32.49|78.11| +|growth-1|400|167.78|1406.11|0|3910|10.63|51.36|91.02| +|growth-1|900|163.01|1500.97|0|13034|10.01|47.35|90.62| +|growth-2|100|100.06|10.56|0|0|9.38|36.14|160.12| +|growth-2|400|399.79|183.60|0|107|19.95|73.06|165.43| +|growth-2|900|384.98|477.66|0|8879|20.95|79.73|166.75| +|growth-4|100|100.07|7.39|0|0|7.65|43.80|287.79| +|growth-4|400|399.84|18.63|0|0|18.14|86.13|319.14| +|growth-4|900|442.33|621.58|0|8147|25.05|107.08|317.98| +|db-improved|100|100.06|7.36|0|0|9.74|44.06|313.15| +|db-improved|400|399.81|5.89|0|0|17.78|76.29|318.80| +|db-improved|900|881.06|223.69|0|298|42.86|179.65|316.50| diff --git a/evidence/scaling-final.json b/evidence/scaling-final.json new file mode 100644 index 00000000..2636b092 --- /dev/null +++ b/evidence/scaling-final.json @@ -0,0 +1,18638 @@ +{ + "source_manifest": { + "src/messenger/__init__.py": "9a72a49106367ca514cc6147d0e727e62c4d33fefd61572d209a5c9494551a2c", + "src/messenger/__main__.py": "ba9a59ad44ee8884cd65cf88d5ea15cbd7051b10f7c729043ddd44ca2f34defe", + "src/messenger/app.py": "ded13f4c21b8610885f69ae9fa8b4637d58cacf5b8bda7d5a376b44acd0f4f1f", + "src/messenger/config.py": "e4d4aaf674ede8b5abdc361f77c7793ee94d8d7856030c28834eb7c95291b193", + "src/messenger/domain.py": "33086cb229083ecee3bcee09f143b4bc09e48896a0c497bd9902e738e2e6b1af", + "src/messenger/migrate.py": "eb5cad7ac6abe38dd40b2db307d298b297abe9543b3928c36bab8ef06283664e", + "src/messenger/models.py": "0ca8f9a3a43833ebf0c0b14e05d77c3e1ab48394d15c6b6d678689d40b4cd416", + "src/messenger/postgres.py": "449ac90643222e5e1437df2f33ed3584dc9ccb7579c10beae4e8d710a4aae052", + "migrations/001_initial.sql": "5d88cd12ef9fda008832dc0b886fa0cf5d886738fe9b77180cdc65adac50dfd9", + "migrations/002_idempotency.sql": "82b41be828ad55ec5c1d991775528e7fe6766c362fa58a2c4f46690459b2c00d", + "migrations/003_unicode_storage.sql": "7282a55da4aa081f7d3d99692e11eeb7a49feab9c9f829a09d3d72dc74009643" + }, + "source_revision": "029bf9b377ee0d9990365706522f2abff51bcfaa", + "started_at": "2026-11-06T15:03:43.641063+00:00", + "host": "macOS-15.3.1-arm64-arm-64bit", + "docker": { + "ServerVersion": "29.5.2", + "NCPU": 4, + "MemTotal": 8307167232, + "Architecture": "aarch64", + "OperatingSystem": "Ubuntu 24.04.4 LTS" + }, + "profiles": [ + { + "name": "fixed-1", + "series": "fixed", + "replicas": 1, + "api_cpu": 1.0, + "api_memory": "1024m", + "pg_cpu": 0.25 + }, + { + "name": "fixed-2", + "series": "fixed", + "replicas": 2, + "api_cpu": 0.5, + "api_memory": "512m", + "pg_cpu": 0.25 + }, + { + "name": "fixed-4", + "series": "fixed", + "replicas": 4, + "api_cpu": 0.25, + "api_memory": "256m", + "pg_cpu": 0.25 + }, + { + "name": "growth-1", + "series": "growth", + "replicas": 1, + "api_cpu": 0.5, + "api_memory": "256m", + "pg_cpu": 0.25 + }, + { + "name": "growth-2", + "series": "growth", + "replicas": 2, + "api_cpu": 0.5, + "api_memory": "256m", + "pg_cpu": 0.25 + }, + { + "name": "growth-4", + "series": "growth", + "replicas": 4, + "api_cpu": 0.5, + "api_memory": "256m", + "pg_cpu": 0.25 + }, + { + "name": "db-improved", + "series": "improvement", + "replicas": 4, + "api_cpu": 0.5, + "api_memory": "256m", + "pg_cpu": 0.5 + } + ], + "runs": [ + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9963, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.45945199999999997, + "driver_cpu_fraction_one_core": 0.07662287523064887, + "successful_rps": 100.061, + "attempted_rps": 100.061, + "latency_success_ms": { + "p50": 5.025, + "p95": 8.201, + "p99": 10.76 + }, + "max_schedule_lag_ms": 3.199, + "instances": { + "43b36fd6-577f-4497-a54b-75132f8be8fb": 600 + }, + "concurrency_cap": 128, + "configuration": "fixed-1", + "repeat": 1, + "actual_containers": [ + { + "id": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 1000000000, + "memory_bytes": 1073741824, + "started_at": "2026-11-06T15:03:49.86620098Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455497.056404833, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "41.14%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "5.51%", + "MemUsage": "56.38MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "552kB / 622kB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.68%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.58%", + "MemUsage": "3.309MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "2.72MB / 5.06MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.98%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.81%", + "MemUsage": "12.55MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "25.2MB / 27MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "11.68%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "3.17%", + "MemUsage": "24.34MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "242kB / 199kB", + "PIDs": "8" + } + ] + }, + { + "monotonic": 455499.068502125, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "29.34%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "5.50%", + "MemUsage": "56.27MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "1.09MB / 1.22MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.80%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.59%", + "MemUsage": "3.316MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "2.75MB / 5.11MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.06%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.81%", + "MemUsage": "12.56MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "25.4MB / 27.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "9.42%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "3.27%", + "MemUsage": "25.14MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "923kB / 765kB", + "PIDs": "8" + } + ] + }, + { + "monotonic": 455501.0907955, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "35.73%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "5.49%", + "MemUsage": "56.26MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "1.61MB / 1.8MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.61%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.58%", + "MemUsage": "3.305MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "2.77MB / 5.16MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.61%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.80%", + "MemUsage": "12.54MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "25.7MB / 27.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "7.31%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "3.30%", + "MemUsage": "25.35MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "1.37MB / 1.13MB", + "PIDs": "8" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0024, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 1.164445, + "driver_cpu_fraction_one_core": 0.1939969651176304, + "successful_rps": 399.84, + "attempted_rps": 399.84, + "latency_success_ms": { + "p50": 2.357, + "p95": 98.167, + "p99": 116.552 + }, + "max_schedule_lag_ms": 5.67, + "instances": { + "43b36fd6-577f-4497-a54b-75132f8be8fb": 2400 + }, + "concurrency_cap": 128, + "configuration": "fixed-1", + "repeat": 1, + "actual_containers": [ + { + "id": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 1000000000, + "memory_bytes": 1073741824, + "started_at": "2026-11-06T15:03:49.86620098Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455503.095864416, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "40.80%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "6.06%", + "MemUsage": "62MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "3.75MB / 4.21MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.31%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "2.89MB / 5.39MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.71%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.98%", + "MemUsage": "12.78MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "26.5MB / 28.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "13.65%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "5.20%", + "MemUsage": "39.91MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "3.17MB / 2.62MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455505.100185708, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "43.63%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "6.06%", + "MemUsage": "62.01MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "5.89MB / 6.59MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.41%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "3MB / 5.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.82%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.98%", + "MemUsage": "12.77MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "27.4MB / 29.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "14.62%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "5.28%", + "MemUsage": "40.58MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "4.97MB / 4.13MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455507.106780875, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "57.71%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "6.06%", + "MemUsage": "62.01MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "8.02MB / 8.96MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.33%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.344MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "3.11MB / 5.82MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.75%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.98%", + "MemUsage": "12.78MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "28.3MB / 29.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "14.22%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "5.46%", + "MemUsage": "41.93MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "6.77MB / 5.63MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.2594, + "scheduled": 5400, + "attempted": 2493, + "successful": 2493, + "errors": {}, + "dropped": 2907, + "dropped_scheduler": 0, + "dropped_concurrency": 2907, + "driver_cpu_seconds": 1.209951, + "driver_cpu_fraction_one_core": 0.19330326520509908, + "successful_rps": 398.283, + "attempted_rps": 398.283, + "latency_success_ms": { + "p50": 307.611, + "p95": 412.474, + "p99": 471.46 + }, + "max_schedule_lag_ms": 2.904, + "instances": { + "43b36fd6-577f-4497-a54b-75132f8be8fb": 2493 + }, + "concurrency_cap": 128, + "configuration": "fixed-1", + "repeat": 1, + "actual_containers": [ + { + "id": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 1000000000, + "memory_bytes": 1073741824, + "started_at": "2026-11-06T15:03:49.86620098Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455509.115324083, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "105.92%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "6.89%", + "MemUsage": "70.56MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "10.5MB / 11.5MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.36%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.344MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "3.23MB / 6.06MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.94%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.33%", + "MemUsage": "13.22MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "29.4MB / 31.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "20.31%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "5.55%", + "MemUsage": "42.63MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "8.63MB / 7.18MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455511.123931541, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "107.04%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "7.65%", + "MemUsage": "78.3MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "12.8MB / 13.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.40%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "3.33MB / 6.26MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.36%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.33%", + "MemUsage": "13.22MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "30.3MB / 32.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "20.70%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "5.63%", + "MemUsage": "43.24MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "10.3MB / 8.61MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455513.132228708, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "106.48%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "9.46%", + "MemUsage": "96.91MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "15.1MB / 16.4MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.50%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.336MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "3.43MB / 6.47MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.28%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.33%", + "MemUsage": "13.23MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "31.2MB / 33.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "19.86%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "5.72%", + "MemUsage": "43.94MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "12.1MB / 10.1MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.2326, + "scheduled": 5400, + "attempted": 2442, + "successful": 2442, + "errors": {}, + "dropped": 2958, + "dropped_scheduler": 0, + "dropped_concurrency": 2958, + "driver_cpu_seconds": 1.221917, + "driver_cpu_fraction_one_core": 0.19605243229246944, + "successful_rps": 391.81, + "attempted_rps": 391.81, + "latency_success_ms": { + "p50": 311.192, + "p95": 388.134, + "p99": 423.132 + }, + "max_schedule_lag_ms": 3.418, + "instances": { + "43b36fd6-577f-4497-a54b-75132f8be8fb": 2442 + }, + "concurrency_cap": 128, + "configuration": "fixed-1", + "repeat": 2, + "actual_containers": [ + { + "id": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 1000000000, + "memory_bytes": 1073741824, + "started_at": "2026-11-06T15:03:49.86620098Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455515.139252583, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "106.68%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "8.80%", + "MemUsage": "90.15MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "17.4MB / 18.8MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.45%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "3.55MB / 6.69MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.57%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.33%", + "MemUsage": "13.23MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "32.2MB / 34.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "20.58%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "5.84%", + "MemUsage": "44.83MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "13.9MB / 11.6MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455517.146973875, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "106.88%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "8.89%", + "MemUsage": "91.04MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "19.6MB / 21.2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.42%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "3.65MB / 6.89MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.74%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.33%", + "MemUsage": "13.22MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "33.1MB / 35.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "18.37%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "5.92%", + "MemUsage": "45.46MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "15.6MB / 13MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455519.155326041, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "107.76%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "9.05%", + "MemUsage": "92.69MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "21.9MB / 23.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.55%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.62%", + "MemUsage": "3.348MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "3.76MB / 7.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.54%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.33%", + "MemUsage": "13.22MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "34MB / 36.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "21.02%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "5.97%", + "MemUsage": "45.85MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "17.4MB / 14.5MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.004, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 1.1956490000000004, + "driver_cpu_fraction_one_core": 0.19914210536513183, + "successful_rps": 399.73, + "attempted_rps": 399.73, + "latency_success_ms": { + "p50": 2.802, + "p95": 151.441, + "p99": 180.407 + }, + "max_schedule_lag_ms": 2.7, + "instances": { + "43b36fd6-577f-4497-a54b-75132f8be8fb": 2400 + }, + "concurrency_cap": 128, + "configuration": "fixed-1", + "repeat": 2, + "actual_containers": [ + { + "id": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 1000000000, + "memory_bytes": 1073741824, + "started_at": "2026-11-06T15:03:49.86620098Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455521.159961833, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "102.54%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "9.01%", + "MemUsage": "92.28MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "24.2MB / 26.1MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.42%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "3.86MB / 7.31MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.10%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.93%", + "MemUsage": "12.71MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "34.9MB / 37.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "20.87%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "6.10%", + "MemUsage": "46.84MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "19.2MB / 16MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455523.167076666, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "65.64%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "10.09%", + "MemUsage": "103.3MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "26.3MB / 28.5MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.47%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "3.97MB / 7.53MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.73%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.94%", + "MemUsage": "12.72MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "35.8MB / 38.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "15.71%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "6.18%", + "MemUsage": "47.49MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "21MB / 17.5MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455525.173719333, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "48.45%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "9.01%", + "MemUsage": "92.28MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "28.5MB / 30.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.50%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.07MB / 7.74MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.70%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.94%", + "MemUsage": "12.72MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "36.7MB / 39.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "17.32%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "6.27%", + "MemUsage": "48.12MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "22.8MB / 19MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9981, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.530424, + "driver_cpu_fraction_one_core": 0.08843281826729238, + "successful_rps": 100.031, + "attempted_rps": 100.031, + "latency_success_ms": { + "p50": 5.29, + "p95": 37.055, + "p99": 113.898 + }, + "max_schedule_lag_ms": 3.402, + "instances": { + "43b36fd6-577f-4497-a54b-75132f8be8fb": 600 + }, + "concurrency_cap": 128, + "configuration": "fixed-1", + "repeat": 2, + "actual_containers": [ + { + "id": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 1000000000, + "memory_bytes": 1073741824, + "started_at": "2026-11-06T15:03:49.86620098Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455527.183883125, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "37.27%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "9.01%", + "MemUsage": "92.3MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "29.4MB / 31.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.62%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.12MB / 7.84MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.65%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.93%", + "MemUsage": "12.71MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "37.1MB / 39.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "12.23%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "6.61%", + "MemUsage": "50.73MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "23.6MB / 19.6MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455529.190266375, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "27.54%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "9.01%", + "MemUsage": "92.3MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "29.9MB / 32.5MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.50%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.15MB / 7.89MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.50%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.92%", + "MemUsage": "13.98MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "37.3MB / 39.7MB", + "PIDs": "11" + }, + { + "BlockIO": "0B / 463kB", + "CPUPerc": "10.63%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "6.62%", + "MemUsage": "50.82MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "24MB / 20MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455531.200760583, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "27.83%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "8.97%", + "MemUsage": "91.8MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "30.4MB / 33.1MB", + "PIDs": "33" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.99%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.17MB / 7.94MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.77%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.93%", + "MemUsage": "12.71MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "37.5MB / 39.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 463kB", + "CPUPerc": "10.09%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "6.63%", + "MemUsage": "50.94MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "24.5MB / 20.4MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9944, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.5198559999999999, + "driver_cpu_fraction_one_core": 0.08672392213057813, + "successful_rps": 100.093, + "attempted_rps": 100.093, + "latency_success_ms": { + "p50": 5.005, + "p95": 8.597, + "p99": 11.059 + }, + "max_schedule_lag_ms": 2.676, + "instances": { + "43b36fd6-577f-4497-a54b-75132f8be8fb": 600 + }, + "concurrency_cap": 128, + "configuration": "fixed-1", + "repeat": 3, + "actual_containers": [ + { + "id": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 1000000000, + "memory_bytes": 1073741824, + "started_at": "2026-11-06T15:03:49.86620098Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455533.211071375, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "37.61%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "8.91%", + "MemUsage": "91.27MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "31MB / 33.7MB", + "PIDs": "23" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.41%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.2MB / 8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.71%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.93%", + "MemUsage": "12.71MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "37.8MB / 40.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 463kB", + "CPUPerc": "9.20%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "6.65%", + "MemUsage": "51.11MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "25MB / 20.8MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455535.224233833, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "29.34%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "8.91%", + "MemUsage": "91.2MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "31.5MB / 34.3MB", + "PIDs": "22" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.87%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.22MB / 8.05MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.04%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.91%", + "MemUsage": "12.68MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "38MB / 40.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 463kB", + "CPUPerc": "10.47%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "6.68%", + "MemUsage": "51.32MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "25.4MB / 21.2MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455537.237770833, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.74%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "8.83%", + "MemUsage": "90.41MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "32.1MB / 34.9MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.66%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.25MB / 8.11MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.22%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.84%", + "MemUsage": "12.6MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "38.2MB / 40.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 463kB", + "CPUPerc": "10.69%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "6.70%", + "MemUsage": "51.47MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "25.9MB / 21.5MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0132, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 1.2202039999999998, + "driver_cpu_fraction_one_core": 0.2029229202321888, + "successful_rps": 399.125, + "attempted_rps": 399.125, + "latency_success_ms": { + "p50": 2.382, + "p95": 16.227, + "p99": 47.303 + }, + "max_schedule_lag_ms": 13.149, + "instances": { + "43b36fd6-577f-4497-a54b-75132f8be8fb": 2400 + }, + "concurrency_cap": 128, + "configuration": "fixed-1", + "repeat": 3, + "actual_containers": [ + { + "id": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 1000000000, + "memory_bytes": 1073741824, + "started_at": "2026-11-06T15:03:49.86620098Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455539.242633083, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "64.46%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "8.93%", + "MemUsage": "91.41MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "33.8MB / 36.9MB", + "PIDs": "30" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.49%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.34MB / 8.29MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.15%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.95%", + "MemUsage": "12.73MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "38.9MB / 41.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 463kB", + "CPUPerc": "17.00%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "6.79%", + "MemUsage": "52.18MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "27.4MB / 22.8MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455541.248404375, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "42.69%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "8.95%", + "MemUsage": "91.65MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "36MB / 39.3MB", + "PIDs": "30" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.43%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.44MB / 8.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.81%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.91%", + "MemUsage": "12.69MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "39.8MB / 42.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 504kB", + "CPUPerc": "15.28%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "6.91%", + "MemUsage": "53.09MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "29.2MB / 24.3MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455543.255077291, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "45.35%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "8.95%", + "MemUsage": "91.65MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "38.1MB / 41.6MB", + "PIDs": "30" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.49%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.55MB / 8.72MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.06%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.91%", + "MemUsage": "12.69MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "40.6MB / 42.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 504kB", + "CPUPerc": "16.29%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "6.96%", + "MemUsage": "53.47MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "31MB / 25.8MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.2028, + "scheduled": 5400, + "attempted": 2389, + "successful": 2389, + "errors": {}, + "dropped": 3011, + "dropped_scheduler": 0, + "dropped_concurrency": 3011, + "driver_cpu_seconds": 1.2549910000000004, + "driver_cpu_fraction_one_core": 0.20232546694036863, + "successful_rps": 385.146, + "attempted_rps": 385.146, + "latency_success_ms": { + "p50": 316.612, + "p95": 421.359, + "p99": 470.055 + }, + "max_schedule_lag_ms": 7.095, + "instances": { + "43b36fd6-577f-4497-a54b-75132f8be8fb": 2389 + }, + "concurrency_cap": 128, + "configuration": "fixed-1", + "repeat": 3, + "actual_containers": [ + { + "id": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 1000000000, + "memory_bytes": 1073741824, + "started_at": "2026-11-06T15:03:49.86620098Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455545.262397583, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "107.37%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "9.28%", + "MemUsage": "95.04MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "40.4MB / 44MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.53%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.66MB / 8.95MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.97%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.33%", + "MemUsage": "13.22MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "41.6MB / 44MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 504kB", + "CPUPerc": "20.99%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "7.06%", + "MemUsage": "54.18MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "32.7MB / 27.2MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455547.268315416, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "104.94%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "9.03%", + "MemUsage": "92.43MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "42.6MB / 46.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.52%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.344MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.76MB / 9.15MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.00%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.33%", + "MemUsage": "13.22MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "42.5MB / 45MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 586kB", + "CPUPerc": "21.83%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "7.24%", + "MemUsage": "55.57MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "34.4MB / 28.6MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455549.275575291, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "103.89%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "9.07%", + "MemUsage": "92.88MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "44.9MB / 48.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.39%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.344MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.87MB / 9.35MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.41%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.34%", + "MemUsage": "13.23MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "43.4MB / 46.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 586kB", + "CPUPerc": "18.87%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "7.35%", + "MemUsage": "56.48MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "36.1MB / 30.1MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455551.302126166, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.18%", + "Container": "91a12815ea7d7280a9c434dd3aa4bd93385d4573a90d7550debc9e70a3099b0d", + "ID": "91a12815ea7d", + "MemPerc": "9.05%", + "MemUsage": "92.66MiB / 1GiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "45.6MB / 49.5MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.84%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.9MB / 9.41MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.22%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.78%", + "MemUsage": "12.52MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "43.7MB / 46.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 791kB", + "CPUPerc": "2.18%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "7.34%", + "MemUsage": "56.34MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "36.7MB / 30.6MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9977, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.520779000000001, + "driver_cpu_fraction_one_core": 0.0868305918672895, + "successful_rps": 100.038, + "attempted_rps": 100.038, + "latency_success_ms": { + "p50": 5.376, + "p95": 10.716, + "p99": 47.988 + }, + "max_schedule_lag_ms": 3.006, + "instances": { + "f0d6264c-408e-4cf6-a57a-6dbbf6eb9726": 300, + "a2c6d58b-280f-45f5-a17a-40fa58665046": 300 + }, + "concurrency_cap": 128, + "configuration": "fixed-2", + "repeat": 1, + "actual_containers": [ + { + "id": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.862560095Z" + }, + { + "id": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.965654536Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455562.298910916, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.87%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.54%", + "MemUsage": "69.34MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "281kB / 318kB", + "PIDs": "10" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.10%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "10.95%", + "MemUsage": "56.08MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "146kB / 166kB", + "PIDs": "6" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.51%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.58%", + "MemUsage": "3.297MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.93MB / 9.46MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.43%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.84%", + "MemUsage": "12.59MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "43.9MB / 46.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 791kB", + "CPUPerc": "10.16%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "6.87%", + "MemUsage": "52.79MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "37.2MB / 31MB", + "PIDs": "13" + } + ] + }, + { + "monotonic": 455564.3102095, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "14.38%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "11.08%", + "MemUsage": "56.73MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "557kB / 637kB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "14.87%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "11.03%", + "MemUsage": "56.48MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "557kB / 627kB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.58%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.58%", + "MemUsage": "3.305MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.96MB / 9.52MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.74%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.84%", + "MemUsage": "12.59MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "44.1MB / 46.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 791kB", + "CPUPerc": "9.34%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "7.01%", + "MemUsage": "53.87MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "37.7MB / 31.3MB", + "PIDs": "13" + } + ] + }, + { + "monotonic": 455566.328722125, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.72%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "11.08%", + "MemUsage": "56.73MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "820kB / 931kB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.70%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "11.03%", + "MemUsage": "56.49MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "825kB / 922kB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.38%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.56%", + "MemUsage": "3.281MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "4.98MB / 9.57MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.41%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.83%", + "MemUsage": "12.58MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "44.4MB / 47MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 1.04MB", + "CPUPerc": "7.37%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "7.03%", + "MemUsage": "54.01MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "38.1MB / 31.7MB", + "PIDs": "13" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0687, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 1.230601, + "driver_cpu_fraction_one_core": 0.20277991022584074, + "successful_rps": 395.474, + "attempted_rps": 395.474, + "latency_success_ms": { + "p50": 2.863, + "p95": 195.18, + "p99": 260.586 + }, + "max_schedule_lag_ms": 4.912, + "instances": { + "f0d6264c-408e-4cf6-a57a-6dbbf6eb9726": 1199, + "a2c6d58b-280f-45f5-a17a-40fa58665046": 1201 + }, + "concurrency_cap": 128, + "configuration": "fixed-2", + "repeat": 1, + "actual_containers": [ + { + "id": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.862560095Z" + }, + { + "id": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.965654536Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455568.337831875, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.50%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "11.13%", + "MemUsage": "56.99MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "1.88MB / 2.1MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.03%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "11.05%", + "MemUsage": "56.59MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "1.88MB / 2.1MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.57%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.57%", + "MemUsage": "3.289MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "5.09MB / 9.79MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.62%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.89%", + "MemUsage": "12.66MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "45.2MB / 47.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 18.1MB", + "CPUPerc": "16.51%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "7.41%", + "MemUsage": "56.88MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "39.9MB / 33.2MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455570.346486458, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "31.67%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "11.66%", + "MemUsage": "59.71MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "3MB / 3.35MB", + "PIDs": "39" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "43.19%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "11.79%", + "MemUsage": "60.37MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "3.02MB / 3.37MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.52%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.58%", + "MemUsage": "3.301MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "5.21MB / 10MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.94%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.92%", + "MemUsage": "12.7MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "46.1MB / 48.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 25.5MB", + "CPUPerc": "20.30%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "10.01%", + "MemUsage": "76.9MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "41.8MB / 34.7MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455572.354063875, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "36.03%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "14.19%", + "MemUsage": "72.63MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "4.06MB / 4.53MB", + "PIDs": "40" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "31.54%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "13.54%", + "MemUsage": "69.3MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "4.08MB / 4.54MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.46%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.58%", + "MemUsage": "3.305MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "5.31MB / 10.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.91%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.96%", + "MemUsage": "12.75MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "47MB / 49.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 33MB", + "CPUPerc": "15.94%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "10.11%", + "MemUsage": "77.66MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "43.6MB / 36.2MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.4764, + "scheduled": 5400, + "attempted": 2354, + "successful": 2354, + "errors": {}, + "dropped": 3046, + "dropped_scheduler": 0, + "dropped_concurrency": 3046, + "driver_cpu_seconds": 1.1457040000000003, + "driver_cpu_fraction_one_core": 0.17690458738148593, + "successful_rps": 363.473, + "attempted_rps": 363.473, + "latency_success_ms": { + "p50": 298.922, + "p95": 688.686, + "p99": 777.584 + }, + "max_schedule_lag_ms": 8.575, + "instances": { + "f0d6264c-408e-4cf6-a57a-6dbbf6eb9726": 1177, + "a2c6d58b-280f-45f5-a17a-40fa58665046": 1177 + }, + "concurrency_cap": 128, + "configuration": "fixed-2", + "repeat": 1, + "actual_containers": [ + { + "id": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.862560095Z" + }, + { + "id": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.965654536Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455574.361549125, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.52%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "12.43%", + "MemUsage": "63.62MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "5.29MB / 5.84MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.73%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "13.10%", + "MemUsage": "67.05MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "5.17MB / 5.68MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.54%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.62%", + "MemUsage": "3.355MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "5.44MB / 10.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.74%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.34%", + "MemUsage": "13.24MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "48MB / 50.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 39.8MB", + "CPUPerc": "22.05%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "10.22%", + "MemUsage": "78.49MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "45.3MB / 37.6MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455576.377798291, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "50.64%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "12.90%", + "MemUsage": "66.06MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "6.33MB / 6.97MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "50.64%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "16.22%", + "MemUsage": "83.02MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "6.15MB / 6.74MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.32%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.62%", + "MemUsage": "3.352MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "5.55MB / 10.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.89%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.50%", + "MemUsage": "13.44MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "48.8MB / 51.7MB", + "PIDs": "6" + }, + { + "BlockIO": "0B / 46.3MB", + "CPUPerc": "17.37%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "10.30%", + "MemUsage": "79.13MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "46.9MB / 38.9MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455578.386493791, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "32.03%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.37%", + "MemUsage": "68.47MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "7.5MB / 8.25MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "50.97%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.10%", + "MemUsage": "72.17MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "7.27MB / 7.93MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.47%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.336MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "5.66MB / 10.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.44%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.34%", + "MemUsage": "13.24MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "49.7MB / 52.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 53.5MB", + "CPUPerc": "19.05%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "10.37%", + "MemUsage": "79.67MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "48.7MB / 40.4MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455580.412589166, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.52%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.39%", + "MemUsage": "68.57MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "7.53MB / 8.28MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.30%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.06%", + "MemUsage": "71.97MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "7.55MB / 8.31MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.12%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.332MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "5.68MB / 10.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.21%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.79%", + "MemUsage": "12.54MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "49.8MB / 52.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 54.8MB", + "CPUPerc": "0.36%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "10.38%", + "MemUsage": "79.73MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "49MB / 40.6MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.5783, + "scheduled": 5400, + "attempted": 2297, + "successful": 2297, + "errors": {}, + "dropped": 3103, + "dropped_scheduler": 0, + "dropped_concurrency": 3103, + "driver_cpu_seconds": 1.1096240000000002, + "driver_cpu_fraction_one_core": 0.1686796980438891, + "successful_rps": 349.178, + "attempted_rps": 349.178, + "latency_success_ms": { + "p50": 306.149, + "p95": 600.226, + "p99": 808.21 + }, + "max_schedule_lag_ms": 23.606, + "instances": { + "a2c6d58b-280f-45f5-a17a-40fa58665046": 1149, + "f0d6264c-408e-4cf6-a57a-6dbbf6eb9726": 1148 + }, + "concurrency_cap": 128, + "configuration": "fixed-2", + "repeat": 2, + "actual_containers": [ + { + "id": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.862560095Z" + }, + { + "id": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.965654536Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455582.423828333, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.50%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "15.10%", + "MemUsage": "77.34MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "8.69MB / 9.49MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.15%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.59%", + "MemUsage": "74.69MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "8.75MB / 9.58MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.53%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.62%", + "MemUsage": "3.348MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "5.8MB / 11.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.94%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.35%", + "MemUsage": "13.25MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "50.8MB / 54.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 61.9MB", + "CPUPerc": "21.13%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "10.51%", + "MemUsage": "80.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "50.8MB / 42.1MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455584.433964833, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.35%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.62%", + "MemUsage": "69.72MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "9.82MB / 10.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.86%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.91%", + "MemUsage": "76.32MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "9.76MB / 10.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.56%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.62%", + "MemUsage": "3.348MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "5.91MB / 11.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.96%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.34%", + "MemUsage": "13.24MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "51.7MB / 55.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 68.6MB", + "CPUPerc": "21.37%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "10.59%", + "MemUsage": "81.31MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "52.5MB / 43.5MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455586.443194916, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "44.77%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "16.16%", + "MemUsage": "82.75MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "10.8MB / 11.8MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "31.13%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.96%", + "MemUsage": "76.58MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "10.8MB / 11.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.20%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.01MB / 11.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.46%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.34%", + "MemUsage": "13.23MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "52.5MB / 56MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 74.8MB", + "CPUPerc": "26.33%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "13.23%", + "MemUsage": "101.6MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "54MB / 44.7MB", + "PIDs": "23" + } + ] + }, + { + "monotonic": 455588.487782708, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.70%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.61%", + "MemUsage": "69.67MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "10.9MB / 11.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.73%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.88%", + "MemUsage": "76.18MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "10.9MB / 12MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.87%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.02MB / 11.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.25%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.80%", + "MemUsage": "12.54MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "52.6MB / 56.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 76MB", + "CPUPerc": "0.53%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "10.96%", + "MemUsage": "84.16MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "54.3MB / 45MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.129, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 1.2269349999999992, + "driver_cpu_fraction_one_core": 0.20018572167642976, + "successful_rps": 391.58, + "attempted_rps": 391.58, + "latency_success_ms": { + "p50": 3.686, + "p95": 306.929, + "p99": 376.955 + }, + "max_schedule_lag_ms": 4.54, + "instances": { + "a2c6d58b-280f-45f5-a17a-40fa58665046": 1199, + "f0d6264c-408e-4cf6-a57a-6dbbf6eb9726": 1201 + }, + "concurrency_cap": 128, + "configuration": "fixed-2", + "repeat": 2, + "actual_containers": [ + { + "id": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.862560095Z" + }, + { + "id": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.965654536Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455590.484700208, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.72%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.64%", + "MemUsage": "69.85MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "11.9MB / 13.1MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "40.65%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "17.35%", + "MemUsage": "88.84MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "11.9MB / 13MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.42%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.336MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.12MB / 11.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.91%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.18%", + "MemUsage": "13.04MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "53.4MB / 56.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 82.5MB", + "CPUPerc": "15.50%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.05%", + "MemUsage": "84.89MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "55.9MB / 46.3MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455592.492578833, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.61%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.63%", + "MemUsage": "69.81MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "13.1MB / 14.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "45.07%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.88%", + "MemUsage": "76.19MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "13.2MB / 14.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.52%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.25MB / 11.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.46%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.93%", + "MemUsage": "12.71MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "54.4MB / 58MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 90.7MB", + "CPUPerc": "19.27%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.16%", + "MemUsage": "85.68MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "57.9MB / 47.9MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455594.498307666, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "38.96%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.68%", + "MemUsage": "70.05MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "14.3MB / 15.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "48.84%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.90%", + "MemUsage": "76.27MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "14.2MB / 15.5MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.41%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.336MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.36MB / 12.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.62%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.08%", + "MemUsage": "12.9MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "55.4MB / 59MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 97.6MB", + "CPUPerc": "18.05%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.24%", + "MemUsage": "86.29MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "59.6MB / 49.4MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9945, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.531820999999999, + "driver_cpu_fraction_one_core": 0.08871829307849742, + "successful_rps": 100.091, + "attempted_rps": 100.091, + "latency_success_ms": { + "p50": 5.099, + "p95": 9.192, + "p99": 41.908 + }, + "max_schedule_lag_ms": 2.974, + "instances": { + "f0d6264c-408e-4cf6-a57a-6dbbf6eb9726": 301, + "a2c6d58b-280f-45f5-a17a-40fa58665046": 299 + }, + "concurrency_cap": 128, + "configuration": "fixed-2", + "repeat": 2, + "actual_containers": [ + { + "id": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.862560095Z" + }, + { + "id": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.965654536Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455596.512078208, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.33%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.63%", + "MemUsage": "69.81MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "14.5MB / 15.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.30%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.88%", + "MemUsage": "76.19MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "14.5MB / 15.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.70%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.344MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.39MB / 12.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.01%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.83%", + "MemUsage": "12.58MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "55.6MB / 59.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 104MB", + "CPUPerc": "9.30%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.29%", + "MemUsage": "86.72MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "60.2MB / 49.8MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455598.523455041, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.25%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.64%", + "MemUsage": "69.81MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "14.8MB / 16.2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "13.91%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.88%", + "MemUsage": "76.2MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "14.8MB / 16.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.50%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.41MB / 12.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.71%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.85%", + "MemUsage": "12.61MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "55.8MB / 59.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 106MB", + "CPUPerc": "7.92%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.31%", + "MemUsage": "86.88MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "60.7MB / 50.2MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455600.531793541, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.51%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.63%", + "MemUsage": "69.81MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "15.1MB / 16.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "13.57%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "15.16%", + "MemUsage": "77.62MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "15.1MB / 16.6MB", + "PIDs": "51" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.49%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.344MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.44MB / 12.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.65%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.85%", + "MemUsage": "12.61MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "56MB / 59.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 108MB", + "CPUPerc": "7.60%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.31%", + "MemUsage": "86.86MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "61.2MB / 50.6MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0096, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.49542399999999986, + "driver_cpu_fraction_one_core": 0.08244001726727253, + "successful_rps": 99.841, + "attempted_rps": 99.841, + "latency_success_ms": { + "p50": 5.06, + "p95": 10.166, + "p99": 54.938 + }, + "max_schedule_lag_ms": 1.662, + "instances": { + "f0d6264c-408e-4cf6-a57a-6dbbf6eb9726": 300, + "a2c6d58b-280f-45f5-a17a-40fa58665046": 300 + }, + "concurrency_cap": 128, + "configuration": "fixed-2", + "repeat": 3, + "actual_containers": [ + { + "id": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.862560095Z" + }, + { + "id": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.965654536Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455602.54498825, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.64%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.64%", + "MemUsage": "69.82MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "15.3MB / 16.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.80%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.88%", + "MemUsage": "76.2MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "15.4MB / 16.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.73%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.47MB / 12.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.99%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.87%", + "MemUsage": "12.63MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "56.2MB / 59.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 110MB", + "CPUPerc": "9.20%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.34%", + "MemUsage": "87.12MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "61.7MB / 50.9MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455604.5538455, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "12.68%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.34%", + "MemUsage": "68.32MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "15.6MB / 17.2MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.91%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.83%", + "MemUsage": "75.93MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "15.6MB / 17.2MB", + "PIDs": "38" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.42%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.344MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.49MB / 12.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.68%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.87%", + "MemUsage": "12.64MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "56.4MB / 60.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 112MB", + "CPUPerc": "6.99%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.37%", + "MemUsage": "87.36MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "62.2MB / 51.3MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455606.563646, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.17%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "15.11%", + "MemUsage": "77.36MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "15.9MB / 17.5MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "14.58%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.54%", + "MemUsage": "74.43MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "15.9MB / 17.6MB", + "PIDs": "10" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.48%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.52MB / 12.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.75%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.86%", + "MemUsage": "12.62MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "56.6MB / 60.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 114MB", + "CPUPerc": "8.62%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.39%", + "MemUsage": "87.51MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "62.7MB / 51.7MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0035, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 1.1957669999999982, + "driver_cpu_fraction_one_core": 0.1991793431951757, + "successful_rps": 399.768, + "attempted_rps": 399.768, + "latency_success_ms": { + "p50": 2.927, + "p95": 131.187, + "p99": 175.203 + }, + "max_schedule_lag_ms": 6.021, + "instances": { + "f0d6264c-408e-4cf6-a57a-6dbbf6eb9726": 1202, + "a2c6d58b-280f-45f5-a17a-40fa58665046": 1198 + }, + "concurrency_cap": 128, + "configuration": "fixed-2", + "repeat": 3, + "actual_containers": [ + { + "id": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.862560095Z" + }, + { + "id": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.965654536Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455608.573299291, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.27%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.30%", + "MemUsage": "68.08MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "16.9MB / 18.6MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "33.16%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.77%", + "MemUsage": "75.64MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "16.9MB / 18.7MB", + "PIDs": "36" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.46%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.344MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.62MB / 12.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.17%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.00%", + "MemUsage": "12.8MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "57.5MB / 61.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 121MB", + "CPUPerc": "16.55%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.51%", + "MemUsage": "88.39MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "64.4MB / 53.1MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455610.578109916, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "49.37%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.60%", + "MemUsage": "69.63MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "17.9MB / 19.8MB", + "PIDs": "40" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "27.41%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.77%", + "MemUsage": "75.63MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "18MB / 19.9MB", + "PIDs": "36" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.40%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.73MB / 12.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.86%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.03%", + "MemUsage": "12.84MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "58.4MB / 61.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 128MB", + "CPUPerc": "17.83%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.59%", + "MemUsage": "89MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "66.2MB / 54.6MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455612.586314458, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.43%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.59%", + "MemUsage": "69.59MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "19MB / 21MB", + "PIDs": "40" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.79%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.84%", + "MemUsage": "76MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "19MB / 21.1MB", + "PIDs": "42" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.50%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.344MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.84MB / 13.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.56%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.02%", + "MemUsage": "12.82MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "59.3MB / 62.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 136MB", + "CPUPerc": "15.32%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.65%", + "MemUsage": "89.44MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "68MB / 56.1MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.2961, + "scheduled": 5400, + "attempted": 2425, + "successful": 2425, + "errors": {}, + "dropped": 2975, + "dropped_scheduler": 0, + "dropped_concurrency": 2975, + "driver_cpu_seconds": 1.1451600000000006, + "driver_cpu_fraction_one_core": 0.1818849475837354, + "successful_rps": 385.159, + "attempted_rps": 385.159, + "latency_success_ms": { + "p50": 313.053, + "p95": 490.399, + "p99": 564.035 + }, + "max_schedule_lag_ms": 6.376, + "instances": { + "a2c6d58b-280f-45f5-a17a-40fa58665046": 1213, + "f0d6264c-408e-4cf6-a57a-6dbbf6eb9726": 1212 + }, + "concurrency_cap": 128, + "configuration": "fixed-2", + "repeat": 3, + "actual_containers": [ + { + "id": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.862560095Z" + }, + { + "id": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 536870912, + "started_at": "2026-11-06T15:04:54.965654536Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455614.595422125, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.46%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.67%", + "MemUsage": "70MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "20.2MB / 22.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.41%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "17.14%", + "MemUsage": "87.78MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "20.2MB / 22.3MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.35%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.336MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "6.97MB / 13.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.25%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.34%", + "MemUsage": "13.24MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "60.3MB / 63.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 160MB", + "CPUPerc": "20.02%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.80%", + "MemUsage": "90.64MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "69.8MB / 57.6MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455616.603131041, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.59%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.67%", + "MemUsage": "70.01MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "21.4MB / 23.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.50%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "14.90%", + "MemUsage": "76.27MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "21.4MB / 23.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.59%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.336MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "7.08MB / 13.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.60%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.35%", + "MemUsage": "13.24MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "61.2MB / 65MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 167MB", + "CPUPerc": "21.67%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.88%", + "MemUsage": "91.22MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "71.7MB / 59.1MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455618.615162375, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.41%", + "Container": "8e279a9be79a782b2f5eb5333dcd95a3f7910c711df574e0c8a98ddb7bed34b0", + "ID": "8e279a9be79a", + "MemPerc": "13.72%", + "MemUsage": "70.26MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "22.5MB / 24.8MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.93%", + "Container": "3d4675deec893dba7db757ba683ca92f294df286a2ffd22ba561ee26f04efb0c", + "ID": "3d4675deec89", + "MemPerc": "17.44%", + "MemUsage": "89.31MiB / 512MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "22.4MB / 24.7MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.47%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.332MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "7.19MB / 13.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.18%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.35%", + "MemUsage": "13.24MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "62MB / 66MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 174MB", + "CPUPerc": "19.00%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.96%", + "MemUsage": "91.84MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "73.3MB / 60.4MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9966, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.4939889999999991, + "driver_cpu_fraction_one_core": 0.08237912047279333, + "successful_rps": 100.057, + "attempted_rps": 100.057, + "latency_success_ms": { + "p50": 5.596, + "p95": 60.686, + "p99": 84.083 + }, + "max_schedule_lag_ms": 2.753, + "instances": { + "76294478-9823-4e85-8a9b-d8f920affbab": 151, + "c78c2016-cd60-4521-b395-a581e8759b22": 150, + "db255e4a-b0f7-4e91-9a62-80aa6ff4346b": 150, + "245a667e-7f87-4b57-a512-07a092536b73": 149 + }, + "concurrency_cap": 128, + "configuration": "fixed-4", + "repeat": 1, + "actual_containers": [ + { + "id": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.715168556Z" + }, + { + "id": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.811185956Z" + }, + { + "id": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.977484216Z" + }, + { + "id": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.886621765Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455634.238836791, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "9.33%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.49%", + "MemUsage": "65.27MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "76.8kB / 88.6kB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.96%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "21.99%", + "MemUsage": "56.3MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "153kB / 183kB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.13%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "21.96%", + "MemUsage": "56.23MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "148kB / 175kB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.04%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "21.95%", + "MemUsage": "56.2MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "150kB / 178kB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.37%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.57%", + "MemUsage": "3.293MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "7.25MB / 13.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.97%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.89%", + "MemUsage": "12.66MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "62.5MB / 66.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 181MB", + "CPUPerc": "10.00%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "9.95%", + "MemUsage": "76.38MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "74.2MB / 61.2MB", + "PIDs": "16" + } + ] + }, + { + "monotonic": 455636.258571625, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.38%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "22.04%", + "MemUsage": "56.43MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "286kB / 344kB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.57%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "21.99%", + "MemUsage": "56.3MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "293kB / 347kB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.40%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "21.96%", + "MemUsage": "56.23MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "280kB / 324kB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.66%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "21.95%", + "MemUsage": "56.2MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "288kB / 332kB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.41%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.57%", + "MemUsage": "3.293MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "7.29MB / 13.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.73%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.89%", + "MemUsage": "12.66MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "62.7MB / 66.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 183MB", + "CPUPerc": "10.58%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "10.04%", + "MemUsage": "77.13MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "74.7MB / 61.5MB", + "PIDs": "16" + } + ] + }, + { + "monotonic": 455638.276267, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.18%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "22.04%", + "MemUsage": "56.43MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "419kB / 503kB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.76%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "22.01%", + "MemUsage": "56.34MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "427kB / 506kB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "8.65%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "22.04%", + "MemUsage": "56.42MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "418kB / 493kB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "8.48%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "21.97%", + "MemUsage": "56.24MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "420kB / 481kB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.38%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.57%", + "MemUsage": "3.289MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "7.32MB / 13.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.10%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.89%", + "MemUsage": "12.66MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "62.9MB / 66.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 184MB", + "CPUPerc": "8.70%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "10.63%", + "MemUsage": "81.67MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "75.2MB / 61.9MB", + "PIDs": "18" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0063, + "scheduled": 2400, + "attempted": 2295, + "successful": 2295, + "errors": {}, + "dropped": 105, + "dropped_scheduler": 0, + "dropped_concurrency": 105, + "driver_cpu_seconds": 1.129556000000001, + "driver_cpu_fraction_one_core": 0.1880638968938842, + "successful_rps": 382.102, + "attempted_rps": 382.102, + "latency_success_ms": { + "p50": 4.234, + "p95": 451.589, + "p99": 617.124 + }, + "max_schedule_lag_ms": 2.978, + "instances": { + "76294478-9823-4e85-8a9b-d8f920affbab": 574, + "c78c2016-cd60-4521-b395-a581e8759b22": 573, + "db255e4a-b0f7-4e91-9a62-80aa6ff4346b": 574, + "245a667e-7f87-4b57-a512-07a092536b73": 574 + }, + "concurrency_cap": 128, + "configuration": "fixed-4", + "repeat": 1, + "actual_containers": [ + { + "id": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.715168556Z" + }, + { + "id": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.811185956Z" + }, + { + "id": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.977484216Z" + }, + { + "id": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.886621765Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455640.285031958, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "14.77%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "22.05%", + "MemUsage": "56.44MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "948kB / 1.09MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.09%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "22.02%", + "MemUsage": "56.36MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "955kB / 1.09MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.17%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "22.04%", + "MemUsage": "56.43MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "947kB / 1.08MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.14%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "21.97%", + "MemUsage": "56.24MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "949kB / 1.07MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.64%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.58%", + "MemUsage": "3.305MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "7.42MB / 14.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.92%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.92%", + "MemUsage": "12.7MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "63.7MB / 67.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 192MB", + "CPUPerc": "17.24%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "10.79%", + "MemUsage": "82.83MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "77MB / 63.4MB", + "PIDs": "18" + } + ] + }, + { + "monotonic": 455642.295751666, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.29%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "23.54%", + "MemUsage": "60.26MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "1.41MB / 1.59MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.82%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "22.90%", + "MemUsage": "58.63MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "1.47MB / 1.67MB", + "PIDs": "27" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "22.98%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "24.17%", + "MemUsage": "61.88MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "1.44MB / 1.63MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "22.65%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "23.45%", + "MemUsage": "60.04MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "1.45MB / 1.62MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.40%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.62%", + "MemUsage": "3.359MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "7.55MB / 14.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.76%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.21%", + "MemUsage": "13.07MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "64.5MB / 68.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 197MB", + "CPUPerc": "25.54%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.95%", + "MemUsage": "130.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "78.6MB / 64.6MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455644.307343041, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.06%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "23.73%", + "MemUsage": "60.75MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "2.07MB / 2.32MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.50%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "23.20%", + "MemUsage": "59.39MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "2.07MB / 2.31MB", + "PIDs": "27" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.86%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "24.42%", + "MemUsage": "62.52MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "2.07MB / 2.31MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.02%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "23.72%", + "MemUsage": "60.73MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "2.07MB / 2.29MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.79%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.375MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "7.68MB / 14.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.53%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.95%", + "MemUsage": "12.74MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "65.6MB / 69.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 204MB", + "CPUPerc": "21.86%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "17.07%", + "MemUsage": "131.1MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "80.5MB / 66.3MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.4015, + "scheduled": 5400, + "attempted": 2014, + "successful": 2014, + "errors": {}, + "dropped": 3386, + "dropped_scheduler": 0, + "dropped_concurrency": 3386, + "driver_cpu_seconds": 0.9082889999999999, + "driver_cpu_fraction_one_core": 0.14188745683764803, + "successful_rps": 314.614, + "attempted_rps": 314.614, + "latency_success_ms": { + "p50": 403.902, + "p95": 705.962, + "p99": 877.744 + }, + "max_schedule_lag_ms": 4.169, + "instances": { + "245a667e-7f87-4b57-a512-07a092536b73": 505, + "76294478-9823-4e85-8a9b-d8f920affbab": 503, + "c78c2016-cd60-4521-b395-a581e8759b22": 502, + "db255e4a-b0f7-4e91-9a62-80aa6ff4346b": 504 + }, + "concurrency_cap": 128, + "configuration": "fixed-4", + "repeat": 1, + "actual_containers": [ + { + "id": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.715168556Z" + }, + { + "id": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.811185956Z" + }, + { + "id": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.977484216Z" + }, + { + "id": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.886621765Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455646.317011458, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.79%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "24.50%", + "MemUsage": "62.72MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "2.54MB / 2.81MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "20.03%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "24.21%", + "MemUsage": "61.98MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "2.57MB / 2.83MB", + "PIDs": "40" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "22.68%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "25.10%", + "MemUsage": "64.25MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "2.54MB / 2.81MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "20.17%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "24.52%", + "MemUsage": "62.76MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "2.52MB / 2.76MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.21%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.62%", + "MemUsage": "3.359MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "7.79MB / 14.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.29%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.37%", + "MemUsage": "13.27MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "66.4MB / 70.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 209MB", + "CPUPerc": "22.48%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "19.70%", + "MemUsage": "151.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "82MB / 67.5MB", + "PIDs": "39" + } + ] + }, + { + "monotonic": 455648.337935875, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "21.20%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "24.91%", + "MemUsage": "63.78MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "3.08MB / 3.38MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "20.27%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "24.58%", + "MemUsage": "62.91MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "3.12MB / 3.42MB", + "PIDs": "40" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "20.98%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "25.80%", + "MemUsage": "66.05MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "3.04MB / 3.31MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "21.76%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "25.13%", + "MemUsage": "64.33MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "3.03MB / 3.28MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.38%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.387MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "7.9MB / 14.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.12%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "67.2MB / 71.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 214MB", + "CPUPerc": "25.38%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "17.59%", + "MemUsage": "135.1MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "83.5MB / 68.8MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455650.350995083, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.87%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.29%", + "MemUsage": "64.74MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "3.54MB / 3.88MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.59%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "24.96%", + "MemUsage": "63.89MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "3.57MB / 3.92MB", + "PIDs": "40" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.42%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "31.33%", + "MemUsage": "80.2MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "3.48MB / 3.8MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.25%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "30.65%", + "MemUsage": "78.46MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "3.48MB / 3.78MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.23%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "8MB / 15.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.11%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.36%", + "MemUsage": "13.27MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "67.9MB / 72.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 219MB", + "CPUPerc": "15.05%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "17.68%", + "MemUsage": "135.8MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "85MB / 70MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.5785, + "scheduled": 5400, + "attempted": 2520, + "successful": 2520, + "errors": {}, + "dropped": 2880, + "dropped_scheduler": 0, + "dropped_concurrency": 2880, + "driver_cpu_seconds": 1.0881679999999996, + "driver_cpu_fraction_one_core": 0.16541353240586362, + "successful_rps": 383.067, + "attempted_rps": 383.067, + "latency_success_ms": { + "p50": 273.484, + "p95": 760.674, + "p99": 843.219 + }, + "max_schedule_lag_ms": 6.756, + "instances": { + "c78c2016-cd60-4521-b395-a581e8759b22": 631, + "db255e4a-b0f7-4e91-9a62-80aa6ff4346b": 631, + "245a667e-7f87-4b57-a512-07a092536b73": 631, + "76294478-9823-4e85-8a9b-d8f920affbab": 627 + }, + "concurrency_cap": 128, + "configuration": "fixed-4", + "repeat": 2, + "actual_containers": [ + { + "id": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.715168556Z" + }, + { + "id": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.811185956Z" + }, + { + "id": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.977484216Z" + }, + { + "id": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.886621765Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455652.3658515, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "27.01%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.30%", + "MemUsage": "64.77MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "4.14MB / 4.55MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.72%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "25.15%", + "MemUsage": "64.38MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "4.14MB / 4.53MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.94%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "26.23%", + "MemUsage": "67.16MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "4.14MB / 4.54MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.80%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "25.59%", + "MemUsage": "65.51MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "4.08MB / 4.44MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.54%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.387MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "8.13MB / 15.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.12%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.38%", + "MemUsage": "13.28MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "68.9MB / 73.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 227MB", + "CPUPerc": "24.09%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "17.80%", + "MemUsage": "136.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "86.9MB / 71.6MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455654.376343166, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.48%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.36%", + "MemUsage": "64.93MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "4.68MB / 5.14MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.83%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "25.36%", + "MemUsage": "64.93MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "4.62MB / 5.05MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.34%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "31.21%", + "MemUsage": "79.89MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "4.68MB / 5.15MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.54%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "30.10%", + "MemUsage": "77.06MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "4.57MB / 4.98MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.25%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.67%", + "MemUsage": "3.414MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "8.25MB / 15.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.41%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.52%", + "MemUsage": "13.46MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "69.8MB / 74.5MB", + "PIDs": "6" + }, + { + "BlockIO": "0B / 233MB", + "CPUPerc": "16.29%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "17.85%", + "MemUsage": "137.1MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "88.6MB / 72.9MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455656.387988375, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.79%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.82%", + "MemUsage": "66.09MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "5.31MB / 5.85MB", + "PIDs": "40" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.32%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "25.85%", + "MemUsage": "66.18MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "5.24MB / 5.74MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "20.15%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "26.42%", + "MemUsage": "67.64MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "5.3MB / 5.83MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.75%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "26.38%", + "MemUsage": "67.52MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "5.12MB / 5.58MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.54%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.72%", + "MemUsage": "3.48MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "8.38MB / 15.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.87%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.37%", + "MemUsage": "13.28MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "70.7MB / 75.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 241MB", + "CPUPerc": "21.89%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "17.93%", + "MemUsage": "137.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "90.5MB / 74.4MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455658.406211375, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "11.01%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.87%", + "MemUsage": "66.23MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "5.43MB / 5.97MB", + "PIDs": "40" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "8.47%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "25.93%", + "MemUsage": "66.38MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "5.42MB / 5.95MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "13.54%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "26.42%", + "MemUsage": "67.63MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "5.42MB / 5.97MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "13.56%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "31.34%", + "MemUsage": "80.24MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "5.41MB / 5.94MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.09%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.62%", + "MemUsage": "3.359MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "8.41MB / 15.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.11%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.82%", + "MemUsage": "12.57MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "71MB / 75.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 243MB", + "CPUPerc": "1.21%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "17.95%", + "MemUsage": "137.9MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "91.1MB / 74.9MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0077, + "scheduled": 2400, + "attempted": 2383, + "successful": 2383, + "errors": {}, + "dropped": 17, + "dropped_scheduler": 0, + "dropped_concurrency": 17, + "driver_cpu_seconds": 1.0962529999999973, + "driver_cpu_fraction_one_core": 0.1824763807019115, + "successful_rps": 396.66, + "attempted_rps": 396.66, + "latency_success_ms": { + "p50": 3.284, + "p95": 372.896, + "p99": 443.505 + }, + "max_schedule_lag_ms": 17.917, + "instances": { + "db255e4a-b0f7-4e91-9a62-80aa6ff4346b": 597, + "245a667e-7f87-4b57-a512-07a092536b73": 594, + "76294478-9823-4e85-8a9b-d8f920affbab": 595, + "c78c2016-cd60-4521-b395-a581e8759b22": 597 + }, + "concurrency_cap": 128, + "configuration": "fixed-4", + "repeat": 2, + "actual_containers": [ + { + "id": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.715168556Z" + }, + { + "id": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.811185956Z" + }, + { + "id": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.977484216Z" + }, + { + "id": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.886621765Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455660.420712041, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.64%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.84%", + "MemUsage": "66.16MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "5.96MB / 6.57MB", + "PIDs": "38" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.11%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "25.93%", + "MemUsage": "66.38MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "5.95MB / 6.54MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "14.91%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "26.42%", + "MemUsage": "67.63MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "5.95MB / 6.57MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "14.98%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "26.33%", + "MemUsage": "67.4MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "5.95MB / 6.54MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.98%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.375MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "8.52MB / 16MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.33%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.92%", + "MemUsage": "12.7MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "71.9MB / 76.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 251MB", + "CPUPerc": "16.83%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.08%", + "MemUsage": "138.8MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "92.9MB / 76.4MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455662.4361805, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.50%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.82%", + "MemUsage": "66.11MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "6.51MB / 7.18MB", + "PIDs": "37" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.15%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "26.12%", + "MemUsage": "66.88MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "6.51MB / 7.17MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.89%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "26.47%", + "MemUsage": "67.76MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "6.45MB / 7.11MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.92%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "31.47%", + "MemUsage": "80.57MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "6.44MB / 7.07MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.82%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.383MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "8.64MB / 16.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.94%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.22%", + "MemUsage": "13.08MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "72.8MB / 77.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 257MB", + "CPUPerc": "19.92%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.16%", + "MemUsage": "139.5MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "94.6MB / 77.8MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455664.447160833, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "17.00%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.79%", + "MemUsage": "66.02MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "7.1MB / 7.81MB", + "PIDs": "35" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "17.02%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "26.13%", + "MemUsage": "66.89MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "7.1MB / 7.8MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.80%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "26.44%", + "MemUsage": "67.69MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "7.1MB / 7.83MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.23%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "26.38%", + "MemUsage": "67.52MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "7.1MB / 7.8MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.97%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.387MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "8.76MB / 16.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.14%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.82%", + "MemUsage": "12.57MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "73.8MB / 78.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 265MB", + "CPUPerc": "19.89%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.24%", + "MemUsage": "140.1MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "96.6MB / 79.4MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9954, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.4865490000000001, + "driver_cpu_fraction_one_core": 0.0811543479205973, + "successful_rps": 100.076, + "attempted_rps": 100.076, + "latency_success_ms": { + "p50": 4.961, + "p95": 59.538, + "p99": 83.674 + }, + "max_schedule_lag_ms": 17.611, + "instances": { + "76294478-9823-4e85-8a9b-d8f920affbab": 149, + "c78c2016-cd60-4521-b395-a581e8759b22": 150, + "db255e4a-b0f7-4e91-9a62-80aa6ff4346b": 151, + "245a667e-7f87-4b57-a512-07a092536b73": 150 + }, + "concurrency_cap": 128, + "configuration": "fixed-4", + "repeat": 2, + "actual_containers": [ + { + "id": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.715168556Z" + }, + { + "id": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.811185956Z" + }, + { + "id": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.977484216Z" + }, + { + "id": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.886621765Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455666.460244125, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.56%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.79%", + "MemUsage": "66.03MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "7.24MB / 7.97MB", + "PIDs": "35" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.30%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "26.13%", + "MemUsage": "66.9MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "7.23MB / 7.97MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.44%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "26.44%", + "MemUsage": "67.7MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "7.24MB / 8MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.83%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "26.38%", + "MemUsage": "67.53MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "7.23MB / 7.96MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.51%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.383MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "8.79MB / 16.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.35%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.88%", + "MemUsage": "12.64MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "74MB / 79MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 275MB", + "CPUPerc": "7.58%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.28%", + "MemUsage": "140.4MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "97.1MB / 79.7MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455668.477254166, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "8.18%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.79%", + "MemUsage": "66.03MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "7.37MB / 8.14MB", + "PIDs": "35" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "10.06%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "27.74%", + "MemUsage": "71.01MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "7.37MB / 8.13MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "8.46%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "26.45%", + "MemUsage": "67.7MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "7.37MB / 8.16MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "8.60%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "26.38%", + "MemUsage": "67.53MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "7.37MB / 8.13MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.72%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.387MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "8.82MB / 16.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.02%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.88%", + "MemUsage": "12.64MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "74.3MB / 79.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 294MB", + "CPUPerc": "11.06%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.37%", + "MemUsage": "141.1MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "97.6MB / 80.1MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455670.489188291, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.26%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.79%", + "MemUsage": "66.03MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "7.51MB / 8.3MB", + "PIDs": "35" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.36%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "26.14%", + "MemUsage": "66.91MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "7.5MB / 8.29MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.45%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "26.44%", + "MemUsage": "67.7MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "7.51MB / 8.33MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "13.29%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "26.38%", + "MemUsage": "67.53MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "7.5MB / 8.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.64%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.375MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "8.86MB / 16.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.79%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.87%", + "MemUsage": "12.64MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "74.5MB / 79.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 296MB", + "CPUPerc": "8.52%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.41%", + "MemUsage": "141.4MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "98.1MB / 80.5MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9945, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.49357300000000137, + "driver_cpu_fraction_one_core": 0.08233768715432743, + "successful_rps": 100.091, + "attempted_rps": 100.091, + "latency_success_ms": { + "p50": 5.213, + "p95": 56.61, + "p99": 80.531 + }, + "max_schedule_lag_ms": 3.067, + "instances": { + "76294478-9823-4e85-8a9b-d8f920affbab": 149, + "c78c2016-cd60-4521-b395-a581e8759b22": 150, + "db255e4a-b0f7-4e91-9a62-80aa6ff4346b": 151, + "245a667e-7f87-4b57-a512-07a092536b73": 150 + }, + "concurrency_cap": 128, + "configuration": "fixed-4", + "repeat": 3, + "actual_containers": [ + { + "id": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.715168556Z" + }, + { + "id": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.811185956Z" + }, + { + "id": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.977484216Z" + }, + { + "id": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.886621765Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455672.503431791, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.12%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "29.24%", + "MemUsage": "74.85MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "7.64MB / 8.46MB", + "PIDs": "10" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.91%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "29.90%", + "MemUsage": "76.54MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "7.63MB / 8.46MB", + "PIDs": "10" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "13.04%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "29.97%", + "MemUsage": "76.71MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "7.64MB / 8.49MB", + "PIDs": "41" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.95%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "26.38%", + "MemUsage": "67.54MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "7.63MB / 8.46MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.61%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.375MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "8.89MB / 16.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.77%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.92%", + "MemUsage": "12.69MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "74.7MB / 79.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 298MB", + "CPUPerc": "8.46%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.44%", + "MemUsage": "141.6MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "98.6MB / 80.9MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455674.515940166, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.40%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.27%", + "MemUsage": "64.7MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "7.78MB / 8.63MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.73%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "25.46%", + "MemUsage": "65.19MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "7.77MB / 8.62MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "8.37%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "25.73%", + "MemUsage": "65.87MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "7.78MB / 8.66MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.82%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "25.72%", + "MemUsage": "65.86MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "7.77MB / 8.63MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.76%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.383MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "8.92MB / 16.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.17%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.91%", + "MemUsage": "12.68MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "74.9MB / 79.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 300MB", + "CPUPerc": "10.07%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.47%", + "MemUsage": "141.9MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "99.1MB / 81.2MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455676.531741, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "17.51%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.27%", + "MemUsage": "64.7MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "7.91MB / 8.8MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.59%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "25.46%", + "MemUsage": "65.19MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "7.9MB / 8.79MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.31%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "25.73%", + "MemUsage": "65.87MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "7.91MB / 8.83MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "12.81%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "28.97%", + "MemUsage": "74.17MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "7.91MB / 8.79MB", + "PIDs": "10" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.47%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.375MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "8.96MB / 16.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.43%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.91%", + "MemUsage": "12.68MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "75.1MB / 80.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 302MB", + "CPUPerc": "7.14%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.49%", + "MemUsage": "142MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "99.6MB / 81.6MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.1508, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 1.1800560000000004, + "driver_cpu_fraction_one_core": 0.19185405633444985, + "successful_rps": 390.192, + "attempted_rps": 390.192, + "latency_success_ms": { + "p50": 3.796, + "p95": 383.246, + "p99": 472.657 + }, + "max_schedule_lag_ms": 9.334, + "instances": { + "76294478-9823-4e85-8a9b-d8f920affbab": 600, + "db255e4a-b0f7-4e91-9a62-80aa6ff4346b": 600, + "245a667e-7f87-4b57-a512-07a092536b73": 600, + "c78c2016-cd60-4521-b395-a581e8759b22": 600 + }, + "concurrency_cap": 128, + "configuration": "fixed-4", + "repeat": 3, + "actual_containers": [ + { + "id": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.715168556Z" + }, + { + "id": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.811185956Z" + }, + { + "id": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.977484216Z" + }, + { + "id": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.886621765Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455678.541210333, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.56%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.28%", + "MemUsage": "64.73MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "8.45MB / 9.39MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "17.76%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "25.56%", + "MemUsage": "65.43MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "8.42MB / 9.36MB", + "PIDs": "15" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.32%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "25.73%", + "MemUsage": "65.87MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "8.44MB / 9.42MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.93%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "26.07%", + "MemUsage": "66.73MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "8.44MB / 9.4MB", + "PIDs": "28" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.03%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.391MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "9.07MB / 17MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.40%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.07%", + "MemUsage": "12.89MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "76MB / 81MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 309MB", + "CPUPerc": "17.54%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.59%", + "MemUsage": "142.8MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "101MB / 83.1MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455680.556030416, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.71%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.57%", + "MemUsage": "65.45MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "8.98MB / 9.99MB", + "PIDs": "25" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.46%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "25.69%", + "MemUsage": "65.77MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "8.99MB / 10MB", + "PIDs": "23" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.36%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "31.50%", + "MemUsage": "80.63MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "8.93MB / 9.95MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "20.86%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "29.30%", + "MemUsage": "75.01MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "8.98MB / 9.99MB", + "PIDs": "29" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.90%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.398MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "9.18MB / 17.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.64%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.21%", + "MemUsage": "13.07MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "76.9MB / 81.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 316MB", + "CPUPerc": "18.75%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.71%", + "MemUsage": "143.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "103MB / 84.5MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455682.567401916, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.81%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.55%", + "MemUsage": "65.4MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "9.58MB / 10.6MB", + "PIDs": "25" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.44%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "25.69%", + "MemUsage": "65.76MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "9.57MB / 10.6MB", + "PIDs": "23" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "21.42%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "26.42%", + "MemUsage": "67.63MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "9.58MB / 10.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.88%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "26.39%", + "MemUsage": "67.56MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "9.55MB / 10.6MB", + "PIDs": "43" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.01%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.387MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "9.3MB / 17.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.99%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.00%", + "MemUsage": "12.8MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "77.9MB / 82.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 324MB", + "CPUPerc": "20.53%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.78%", + "MemUsage": "144.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "105MB / 86.1MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.7144, + "scheduled": 5400, + "attempted": 2543, + "successful": 2543, + "errors": {}, + "dropped": 2857, + "dropped_scheduler": 0, + "dropped_concurrency": 2857, + "driver_cpu_seconds": 1.2145449999999975, + "driver_cpu_fraction_one_core": 0.18088731292292065, + "successful_rps": 378.738, + "attempted_rps": 378.738, + "latency_success_ms": { + "p50": 235.259, + "p95": 718.332, + "p99": 972.293 + }, + "max_schedule_lag_ms": 5.28, + "instances": { + "76294478-9823-4e85-8a9b-d8f920affbab": 636, + "c78c2016-cd60-4521-b395-a581e8759b22": 637, + "245a667e-7f87-4b57-a512-07a092536b73": 634, + "db255e4a-b0f7-4e91-9a62-80aa6ff4346b": 636 + }, + "concurrency_cap": 128, + "configuration": "fixed-4", + "repeat": 3, + "actual_containers": [ + { + "id": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.715168556Z" + }, + { + "id": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.811185956Z" + }, + { + "id": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.977484216Z" + }, + { + "id": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 250000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:06:05.886621765Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455684.579452208, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.20%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "30.53%", + "MemUsage": "78.15MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "10.2MB / 11.3MB", + "PIDs": "28" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.24%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "31.13%", + "MemUsage": "79.7MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "10.2MB / 11.3MB", + "PIDs": "41" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.43%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "30.98%", + "MemUsage": "79.3MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "10.1MB / 11.2MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.42%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "26.47%", + "MemUsage": "67.77MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "10.2MB / 11.4MB", + "PIDs": "51" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.72%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.391MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "9.44MB / 17.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.28%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.38%", + "MemUsage": "13.28MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "78.9MB / 84.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 331MB", + "CPUPerc": "17.86%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.86%", + "MemUsage": "144.9MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "107MB / 87.6MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455686.589905375, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.14%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.64%", + "MemUsage": "65.64MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "10.8MB / 12MB", + "PIDs": "30" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "20.96%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "26.03%", + "MemUsage": "66.64MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "10.8MB / 12MB", + "PIDs": "40" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.21%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "26.48%", + "MemUsage": "67.8MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "10.7MB / 11.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.92%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "26.47%", + "MemUsage": "67.76MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "10.7MB / 11.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.11%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.383MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "9.57MB / 17.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.61%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.38%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "79.9MB / 85.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 339MB", + "CPUPerc": "23.68%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.94%", + "MemUsage": "145.5MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "109MB / 89.2MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455688.602290333, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.75%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.65%", + "MemUsage": "65.65MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "11.4MB / 12.7MB", + "PIDs": "31" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.36%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "30.98%", + "MemUsage": "79.3MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "11.4MB / 12.6MB", + "PIDs": "41" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.62%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "29.83%", + "MemUsage": "76.37MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "11.3MB / 12.5MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.84%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "26.48%", + "MemUsage": "67.78MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "11.3MB / 12.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.81%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.379MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "9.7MB / 18.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.60%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.37%", + "MemUsage": "13.28MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "80.8MB / 86.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 346MB", + "CPUPerc": "18.64%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "19.19%", + "MemUsage": "147.4MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "111MB / 90.6MB", + "PIDs": "44" + } + ] + }, + { + "monotonic": 455690.635441916, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.12%", + "Container": "b19b2b37b58880404a5d3733fe3b50a85abae44373b0761d7cd2858d9af3e8c2", + "ID": "b19b2b37b588", + "MemPerc": "25.64%", + "MemUsage": "65.64MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "11.4MB / 12.7MB", + "PIDs": "30" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.54%", + "Container": "acfdd767d8e8581f9a8726e11a4507490fab89139beec8acf98c723df707e748", + "ID": "acfdd767d8e8", + "MemPerc": "26.03%", + "MemUsage": "66.64MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "11.4MB / 12.7MB", + "PIDs": "40" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.58%", + "Container": "d464a0e56df78b5734bae56f6197bb258485c3f356706ca2c8f4aa70613627c1", + "ID": "d464a0e56df7", + "MemPerc": "26.62%", + "MemUsage": "68.14MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "11.4MB / 12.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.44%", + "Container": "707e327e317f1fe859686c6b2964bb29191e330e4fe3c5f19454408b21133531", + "ID": "707e327e317f", + "MemPerc": "26.44%", + "MemUsage": "67.7MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "11.4MB / 12.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.48%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.375MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "9.71MB / 18.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.50%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.83%", + "MemUsage": "12.58MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "81MB / 86.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 347MB", + "CPUPerc": "0.19%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "19.06%", + "MemUsage": "146.4MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "111MB / 90.9MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.003, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.5656590000000001, + "driver_cpu_fraction_one_core": 0.09423092680755431, + "successful_rps": 99.95, + "attempted_rps": 99.95, + "latency_success_ms": { + "p50": 5.972, + "p95": 716.959, + "p99": 786.468 + }, + "max_schedule_lag_ms": 4.327, + "instances": { + "62f00416-932c-44ad-8f59-c646f6379eba": 600 + }, + "concurrency_cap": 128, + "configuration": "growth-1", + "repeat": 1, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455701.509558, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "31.42%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "21.96%", + "MemUsage": "56.21MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "284kB / 322kB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.58%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.58%", + "MemUsage": "3.305MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "9.75MB / 18.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.90%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.86%", + "MemUsage": "12.62MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "81.2MB / 86.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 354MB", + "CPUPerc": "10.22%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "9.58%", + "MemUsage": "73.59MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "112MB / 91.3MB", + "PIDs": "8" + } + ] + }, + { + "monotonic": 455703.522849, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "40.61%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "24.25%", + "MemUsage": "62.08MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "1.14MB / 1.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.26%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.324MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "9.79MB / 18.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.14%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.98%", + "MemUsage": "12.78MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "81.4MB / 86.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 356MB", + "CPUPerc": "11.61%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.43%", + "MemUsage": "87.8MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "112MB / 91.7MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455705.534861541, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.37%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "24.25%", + "MemUsage": "62.08MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "1.67MB / 1.89MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.41%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.59%", + "MemUsage": "3.32MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "9.81MB / 18.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.90%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.89%", + "MemUsage": "12.66MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "81.7MB / 87.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 358MB", + "CPUPerc": "9.65%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.46%", + "MemUsage": "88.04MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "113MB / 92MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.4547, + "scheduled": 2400, + "attempted": 1083, + "successful": 1083, + "errors": {}, + "dropped": 1317, + "dropped_scheduler": 0, + "dropped_concurrency": 1317, + "driver_cpu_seconds": 0.697261000000001, + "driver_cpu_fraction_one_core": 0.10802462230814455, + "successful_rps": 167.785, + "attempted_rps": 167.785, + "latency_success_ms": { + "p50": 653.28, + "p95": 1406.105, + "p99": 1476.236 + }, + "max_schedule_lag_ms": 5.813, + "instances": { + "62f00416-932c-44ad-8f59-c646f6379eba": 1083 + }, + "concurrency_cap": 128, + "configuration": "growth-1", + "repeat": 1, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455707.54276775, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.55%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "26.03%", + "MemUsage": "66.62MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "2.77MB / 3.01MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.03%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.332MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "9.87MB / 18.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.13%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "82.2MB / 87.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 361MB", + "CPUPerc": "11.40%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.79%", + "MemUsage": "90.53MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "113MB / 92.7MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455709.550365416, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.38%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "27.42%", + "MemUsage": "70.2MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "3.91MB / 4.24MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.04%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.328MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "9.93MB / 18.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.07%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "82.6MB / 88.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 364MB", + "CPUPerc": "11.11%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.81%", + "MemUsage": "90.73MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "114MB / 93.4MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455711.564393166, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.22%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "27.49%", + "MemUsage": "70.37MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "4.58MB / 4.98MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.08%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.324MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "9.96MB / 18.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.19%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.54%", + "MemUsage": "13.49MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "82.9MB / 88.5MB", + "PIDs": "6" + }, + { + "BlockIO": "0B / 367MB", + "CPUPerc": "11.79%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.83%", + "MemUsage": "90.87MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "115MB / 93.9MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.4965, + "scheduled": 5400, + "attempted": 1059, + "successful": 1059, + "errors": {}, + "dropped": 4341, + "dropped_scheduler": 0, + "dropped_concurrency": 4341, + "driver_cpu_seconds": 0.732171000000001, + "driver_cpu_fraction_one_core": 0.11270218653839223, + "successful_rps": 163.01, + "attempted_rps": 163.01, + "latency_success_ms": { + "p50": 694.044, + "p95": 1500.974, + "p99": 1579.873 + }, + "max_schedule_lag_ms": 3.508, + "instances": { + "62f00416-932c-44ad-8f59-c646f6379eba": 1059 + }, + "concurrency_cap": 128, + "configuration": "growth-1", + "repeat": 1, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455713.570322541, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.07%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "28.36%", + "MemUsage": "72.59MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "5.69MB / 6.17MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.05%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.324MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10MB / 18.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.42%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.38%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "83.4MB / 89MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 370MB", + "CPUPerc": "10.86%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.87%", + "MemUsage": "91.18MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "116MB / 94.6MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455715.588549166, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "50.58%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "28.37%", + "MemUsage": "72.63MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "6.31MB / 6.85MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.25%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.59%", + "MemUsage": "3.32MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.1MB / 18.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.15%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.38%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "83.6MB / 89.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 372MB", + "CPUPerc": "9.98%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.89%", + "MemUsage": "91.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "116MB / 95MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455717.597805791, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.88%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.00%", + "MemUsage": "76.81MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "7.41MB / 8.04MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.08%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.324MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.1MB / 18.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.63%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "84.1MB / 89.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 375MB", + "CPUPerc": "11.36%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.96%", + "MemUsage": "91.89MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "117MB / 95.7MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455719.619217625, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "11.56%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.38%", + "MemUsage": "77.77MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "7.95MB / 8.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.28%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.328MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.1MB / 18.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.15%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.84%", + "MemUsage": "12.59MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "84.3MB / 90.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 377MB", + "CPUPerc": "2.34%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "11.95%", + "MemUsage": "91.8MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "117MB / 96.1MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.4551, + "scheduled": 5400, + "attempted": 1082, + "successful": 1082, + "errors": {}, + "dropped": 4318, + "dropped_scheduler": 0, + "dropped_concurrency": 4318, + "driver_cpu_seconds": 0.7266969999999979, + "driver_cpu_fraction_one_core": 0.1125769605834917, + "successful_rps": 167.619, + "attempted_rps": 167.619, + "latency_success_ms": { + "p50": 681.05, + "p95": 1412.992, + "p99": 1502.121 + }, + "max_schedule_lag_ms": 3.888, + "instances": { + "62f00416-932c-44ad-8f59-c646f6379eba": 1082 + }, + "concurrency_cap": 128, + "configuration": "growth-1", + "repeat": 2, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455721.623821666, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.06%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.46%", + "MemUsage": "77.98MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "9.06MB / 9.82MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.15%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.324MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.2MB / 18.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.46%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "84.8MB / 90.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 381MB", + "CPUPerc": "11.01%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.01%", + "MemUsage": "92.22MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "118MB / 96.7MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455723.633662625, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.41%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.57%", + "MemUsage": "78.25MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "9.73MB / 10.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.11%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.328MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.2MB / 19MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.34%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "85MB / 91MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 383MB", + "CPUPerc": "10.50%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.06%", + "MemUsage": "92.65MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "119MB / 97.1MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455725.639375, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.63%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.47%", + "MemUsage": "78MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "10.9MB / 11.8MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.21%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.328MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.3MB / 19.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.10%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.53%", + "MemUsage": "13.48MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "85.5MB / 91.5MB", + "PIDs": "6" + }, + { + "BlockIO": "0B / 386MB", + "CPUPerc": "11.18%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.07%", + "MemUsage": "92.73MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "120MB / 97.9MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.4078, + "scheduled": 2400, + "attempted": 1068, + "successful": 1068, + "errors": {}, + "dropped": 1332, + "dropped_scheduler": 0, + "dropped_concurrency": 1332, + "driver_cpu_seconds": 0.6933760000000007, + "driver_cpu_fraction_one_core": 0.10820845725487749, + "successful_rps": 166.672, + "attempted_rps": 166.672, + "latency_success_ms": { + "p50": 655.429, + "p95": 1501.725, + "p99": 1569.291 + }, + "max_schedule_lag_ms": 11.592, + "instances": { + "62f00416-932c-44ad-8f59-c646f6379eba": 1068 + }, + "concurrency_cap": 128, + "configuration": "growth-1", + "repeat": 2, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455727.647011833, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.42%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.47%", + "MemUsage": "78MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "12MB / 13MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.97%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.336MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.3MB / 19.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.24%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "86MB / 92MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 390MB", + "CPUPerc": "8.99%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.11%", + "MemUsage": "93MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "121MB / 98.6MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455729.654963416, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.71%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.46%", + "MemUsage": "77.98MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "13.2MB / 14.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.04%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.332MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.4MB / 19.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.47%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "86.5MB / 92.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 394MB", + "CPUPerc": "11.12%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.16%", + "MemUsage": "93.39MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "122MB / 99.3MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455731.66630175, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "50.84%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "35.54%", + "MemUsage": "90.99MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "13.8MB / 15MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.73%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.328MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.4MB / 19.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.46%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "86.7MB / 92.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 399MB", + "CPUPerc": "10.28%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.18%", + "MemUsage": "93.51MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "122MB / 99.8MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455733.686409958, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.93%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.40%", + "MemUsage": "77.83MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "14.2MB / 15.5MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.36%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.59%", + "MemUsage": "3.32MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.5MB / 19.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.11%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.84%", + "MemUsage": "12.59MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "86.9MB / 93MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 400MB", + "CPUPerc": "1.57%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.19%", + "MemUsage": "93.62MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "122MB / 100MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9976, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.4906499999999987, + "driver_cpu_fraction_one_core": 0.0818083669257536, + "successful_rps": 100.04, + "attempted_rps": 100.04, + "latency_success_ms": { + "p50": 5.326, + "p95": 68.874, + "p99": 118.286 + }, + "max_schedule_lag_ms": 1.419, + "instances": { + "62f00416-932c-44ad-8f59-c646f6379eba": 600 + }, + "concurrency_cap": 128, + "configuration": "growth-1", + "repeat": 2, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455735.696616208, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "36.05%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.41%", + "MemUsage": "77.84MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "14.8MB / 16.1MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.10%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.324MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.5MB / 19.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.46%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.88%", + "MemUsage": "12.65MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "87.1MB / 93.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 402MB", + "CPUPerc": "7.62%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.22%", + "MemUsage": "93.88MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "123MB / 100MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455737.704430625, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.76%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.41%", + "MemUsage": "77.84MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "15.3MB / 16.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.66%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.324MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.5MB / 19.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.88%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.88%", + "MemUsage": "12.65MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "87.3MB / 93.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 404MB", + "CPUPerc": "10.00%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.25%", + "MemUsage": "94.07MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "123MB / 101MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455739.717017791, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "32.67%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.51%", + "MemUsage": "78.11MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "15.8MB / 17.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.52%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.324MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.5MB / 19.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.24%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.93%", + "MemUsage": "12.71MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "87.6MB / 93.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 406MB", + "CPUPerc": "10.16%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.27%", + "MemUsage": "94.23MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "124MB / 101MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9966, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.529083, + "driver_cpu_fraction_one_core": 0.08823057087572043, + "successful_rps": 100.056, + "attempted_rps": 100.056, + "latency_success_ms": { + "p50": 5.429, + "p95": 34.811, + "p99": 68.925 + }, + "max_schedule_lag_ms": 2.305, + "instances": { + "62f00416-932c-44ad-8f59-c646f6379eba": 600 + }, + "concurrency_cap": 128, + "configuration": "growth-1", + "repeat": 3, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455741.730990208, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "29.18%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.41%", + "MemUsage": "77.86MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "16.4MB / 17.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.64%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.324MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.6MB / 19.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.86%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.93%", + "MemUsage": "12.71MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "87.8MB / 93.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 408MB", + "CPUPerc": "10.43%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.30%", + "MemUsage": "94.44MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "124MB / 102MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455743.743282875, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.47%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.87%", + "MemUsage": "76.46MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "16.9MB / 18.5MB", + "PIDs": "16" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.58%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.324MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.6MB / 19.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.92%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.95%", + "MemUsage": "12.74MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "88MB / 94.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 410MB", + "CPUPerc": "10.52%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.32%", + "MemUsage": "94.62MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "125MB / 102MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455745.752246833, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "38.85%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.87%", + "MemUsage": "76.46MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "17.5MB / 19.1MB", + "PIDs": "16" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.15%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.324MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.6MB / 19.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.58%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.95%", + "MemUsage": "12.73MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "88.2MB / 94.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 412MB", + "CPUPerc": "8.56%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.34%", + "MemUsage": "94.75MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "125MB / 102MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.4373, + "scheduled": 2400, + "attempted": 1139, + "successful": 1139, + "errors": {}, + "dropped": 1261, + "dropped_scheduler": 0, + "dropped_concurrency": 1261, + "driver_cpu_seconds": 0.6617730000000002, + "driver_cpu_fraction_one_core": 0.10280384061649205, + "successful_rps": 176.938, + "attempted_rps": 176.938, + "latency_success_ms": { + "p50": 611.027, + "p95": 1301.108, + "p99": 1377.753 + }, + "max_schedule_lag_ms": 3.385, + "instances": { + "62f00416-932c-44ad-8f59-c646f6379eba": 1139 + }, + "concurrency_cap": 128, + "configuration": "growth-1", + "repeat": 3, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455747.75863225, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.35%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.46%", + "MemUsage": "77.96MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "18.7MB / 20.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.03%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.332MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.7MB / 19.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.12%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.38%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "88.8MB / 94.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 415MB", + "CPUPerc": "11.66%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.39%", + "MemUsage": "95.12MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "126MB / 103MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455749.76732725, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "50.75%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "35.55%", + "MemUsage": "91.02MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "19.5MB / 21.2MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.38%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.336MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.7MB / 19.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.97%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.54%", + "MemUsage": "13.49MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "89.1MB / 95.3MB", + "PIDs": "6" + }, + { + "BlockIO": "0B / 418MB", + "CPUPerc": "9.11%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.41%", + "MemUsage": "95.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "127MB / 104MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455751.772819625, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.97%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.47%", + "MemUsage": "78MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "20.5MB / 22.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.05%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.59%", + "MemUsage": "3.32MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.8MB / 20MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.43%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "89.5MB / 95.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 438MB", + "CPUPerc": "11.13%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.51%", + "MemUsage": "96.07MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "128MB / 104MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 7.3107, + "scheduled": 5400, + "attempted": 1025, + "successful": 1025, + "errors": {}, + "dropped": 4375, + "dropped_scheduler": 0, + "dropped_concurrency": 4375, + "driver_cpu_seconds": 0.683008000000001, + "driver_cpu_fraction_one_core": 0.0934257896473726, + "successful_rps": 140.205, + "attempted_rps": 140.205, + "latency_success_ms": { + "p50": 691.711, + "p95": 1708.197, + "p99": 1793.137 + }, + "max_schedule_lag_ms": 3.551, + "instances": { + "62f00416-932c-44ad-8f59-c646f6379eba": 1025 + }, + "concurrency_cap": 128, + "configuration": "growth-1", + "repeat": 3, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455753.790855708, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "50.36%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "35.40%", + "MemUsage": "90.62MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "21.5MB / 23.4MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.24%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.59%", + "MemUsage": "3.32MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.8MB / 20.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.93%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "89.9MB / 96.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 441MB", + "CPUPerc": "8.71%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.54%", + "MemUsage": "96.34MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "128MB / 105MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455755.798049, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.76%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.48%", + "MemUsage": "78.02MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "22.4MB / 24.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.16%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.59%", + "MemUsage": "3.32MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.9MB / 20.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.45%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "90.3MB / 96.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 444MB", + "CPUPerc": "11.10%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.61%", + "MemUsage": "96.87MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "129MB / 105MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455757.808784041, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.75%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "33.81%", + "MemUsage": "86.56MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "23.5MB / 25.6MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.15%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.324MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.9MB / 20.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.29%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "90.7MB / 97.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 447MB", + "CPUPerc": "10.24%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.66%", + "MemUsage": "97.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "130MB / 106MB", + "PIDs": "14" + } + ] + }, + { + "monotonic": 455759.848452916, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "35.52%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.40%", + "MemUsage": "77.81MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "23.8MB / 26MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.08%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.59%", + "MemUsage": "3.32MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "10.9MB / 20.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.40%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.84%", + "MemUsage": "12.59MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "90.9MB / 97.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 449MB", + "CPUPerc": "9.97%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "12.63%", + "MemUsage": "97.02MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "130MB / 106MB", + "PIDs": "14" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9974, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.32759000000000427, + "driver_cpu_fraction_one_core": 0.054622227960533114, + "successful_rps": 100.043, + "attempted_rps": 100.043, + "latency_success_ms": { + "p50": 4.956, + "p95": 19.354, + "p99": 58.407 + }, + "max_schedule_lag_ms": 3.827, + "instances": { + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 302, + "62f00416-932c-44ad-8f59-c646f6379eba": 298 + }, + "concurrency_cap": 128, + "configuration": "growth-2", + "repeat": 1, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455770.162400541, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "29.32%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.40%", + "MemUsage": "77.82MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "23.9MB / 26.2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "20.48%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "25.49%", + "MemUsage": "65.26MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "281kB / 316kB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.42%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.328MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "11MB / 20.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.58%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.88%", + "MemUsage": "12.65MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "91.1MB / 97.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 454MB", + "CPUPerc": "8.86%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "13.27%", + "MemUsage": "101.9MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "131MB / 107MB", + "PIDs": "15" + } + ] + }, + { + "monotonic": 455772.17246725, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.25%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "33.11%", + "MemUsage": "84.75MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "24.3MB / 26.7MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.50%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "22.00%", + "MemUsage": "56.32MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "554kB / 628kB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.51%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.328MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "11MB / 20.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.97%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.89%", + "MemUsage": "12.66MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "91.3MB / 97.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 456MB", + "CPUPerc": "10.76%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "13.91%", + "MemUsage": "106.9MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "131MB / 107MB", + "PIDs": "17" + } + ] + }, + { + "monotonic": 455774.18607375, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.82%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.74%", + "MemUsage": "76.14MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "24.6MB / 27MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.32%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "22.14%", + "MemUsage": "56.68MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "821kB / 930kB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.11%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.324MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "11MB / 20.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.24%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.88%", + "MemUsage": "12.64MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "91.5MB / 97.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 457MB", + "CPUPerc": "8.51%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "14.22%", + "MemUsage": "109.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "132MB / 108MB", + "PIDs": "18" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0032, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.9342100000000002, + "driver_cpu_fraction_one_core": 0.15561987510912448, + "successful_rps": 399.789, + "attempted_rps": 399.789, + "latency_success_ms": { + "p50": 2.941, + "p95": 183.603, + "p99": 226.881 + }, + "max_schedule_lag_ms": 2.543, + "instances": { + "62f00416-932c-44ad-8f59-c646f6379eba": 1199, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 1201 + }, + "concurrency_cap": 128, + "configuration": "growth-2", + "repeat": 1, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455776.195319666, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "45.92%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.43%", + "MemUsage": "77.89MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "25.6MB / 28.1MB", + "PIDs": "44" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.68%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "22.15%", + "MemUsage": "56.7MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "1.88MB / 2.11MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.57%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.60%", + "MemUsage": "3.328MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "11.1MB / 20.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.15%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.06%", + "MemUsage": "12.88MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "92.3MB / 98.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 465MB", + "CPUPerc": "18.38%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "14.35%", + "MemUsage": "110.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "133MB / 109MB", + "PIDs": "18" + } + ] + }, + { + "monotonic": 455778.2057225, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.87%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.40%", + "MemUsage": "77.82MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "26.7MB / 29.4MB", + "PIDs": "44" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "42.98%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "23.34%", + "MemUsage": "59.75MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "2.97MB / 3.36MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.56%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.336MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "11.2MB / 20.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.29%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.04%", + "MemUsage": "12.85MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "93.3MB / 99.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 472MB", + "CPUPerc": "21.26%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "15.68%", + "MemUsage": "120.4MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "135MB / 111MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455780.215340791, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "45.05%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.44%", + "MemUsage": "77.92MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "27.8MB / 30.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "27.68%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "23.32%", + "MemUsage": "59.7MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "4.04MB / 4.54MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.52%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.336MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "11.4MB / 21.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.26%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.99%", + "MemUsage": "12.79MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "94.2MB / 101MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 480MB", + "CPUPerc": "20.21%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "15.78%", + "MemUsage": "121.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "137MB / 112MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.4058, + "scheduled": 5400, + "attempted": 2377, + "successful": 2377, + "errors": {}, + "dropped": 3023, + "dropped_scheduler": 0, + "dropped_concurrency": 3023, + "driver_cpu_seconds": 1.091239999999999, + "driver_cpu_fraction_one_core": 0.17035200660673633, + "successful_rps": 371.069, + "attempted_rps": 371.069, + "latency_success_ms": { + "p50": 191.565, + "p95": 717.929, + "p99": 776.566 + }, + "max_schedule_lag_ms": 9.446, + "instances": { + "62f00416-932c-44ad-8f59-c646f6379eba": 1188, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 1189 + }, + "concurrency_cap": 128, + "configuration": "growth-2", + "repeat": 1, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455782.235532625, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "44.13%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.42%", + "MemUsage": "77.88MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "29.2MB / 32.1MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.10%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "26.22%", + "MemUsage": "67.13MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "5.15MB / 5.68MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.58%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.383MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "11.5MB / 21.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.78%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "95.2MB / 102MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 487MB", + "CPUPerc": "22.60%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "15.93%", + "MemUsage": "122.4MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "139MB / 114MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455784.246592666, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.58%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.43%", + "MemUsage": "77.91MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "30.3MB / 33.2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "54.25%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "30.75%", + "MemUsage": "78.72MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "6.28MB / 6.9MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.48%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.395MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "11.6MB / 21.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.79%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "96.1MB / 103MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 494MB", + "CPUPerc": "22.98%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "15.99%", + "MemUsage": "122.8MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "141MB / 115MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455786.254312208, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "41.92%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "35.33%", + "MemUsage": "90.45MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "31.3MB / 34.3MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.28%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "28.11%", + "MemUsage": "71.95MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "7.33MB / 8.05MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.53%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.395MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "11.7MB / 21.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.05%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.54%", + "MemUsage": "13.49MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "96.9MB / 104MB", + "PIDs": "6" + }, + { + "BlockIO": "0B / 502MB", + "CPUPerc": "20.96%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.09%", + "MemUsage": "123.6MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "142MB / 116MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.2497, + "scheduled": 5400, + "attempted": 2406, + "successful": 2406, + "errors": {}, + "dropped": 2994, + "dropped_scheduler": 0, + "dropped_concurrency": 2994, + "driver_cpu_seconds": 1.160581999999998, + "driver_cpu_fraction_one_core": 0.18570354381517867, + "successful_rps": 384.981, + "attempted_rps": 384.981, + "latency_success_ms": { + "p50": 325.073, + "p95": 477.664, + "p99": 518.056 + }, + "max_schedule_lag_ms": 7.891, + "instances": { + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 1203, + "62f00416-932c-44ad-8f59-c646f6379eba": 1203 + }, + "concurrency_cap": 128, + "configuration": "growth-2", + "repeat": 2, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455788.264441583, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.86%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.46%", + "MemUsage": "77.97MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "32.2MB / 35.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "54.00%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "33.59%", + "MemUsage": "85.98MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "8.44MB / 9.27MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.62%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.402MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "11.8MB / 22MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.09%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "97.8MB / 105MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 510MB", + "CPUPerc": "21.68%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.15%", + "MemUsage": "124MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "144MB / 118MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455790.272455166, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.76%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.46%", + "MemUsage": "77.98MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "33.3MB / 36.5MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.88%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.59%", + "MemUsage": "75.76MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "9.62MB / 10.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.41%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.402MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "11.9MB / 22.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.51%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.59%", + "MemUsage": "13.55MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "98.7MB / 106MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 518MB", + "CPUPerc": "20.22%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.23%", + "MemUsage": "124.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "146MB / 119MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455792.282350791, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.15%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.46%", + "MemUsage": "77.98MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "34.5MB / 37.8MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.21%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "34.67%", + "MemUsage": "88.77MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "10.7MB / 11.7MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.48%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.391MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "12MB / 22.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.61%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "99.6MB / 107MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 525MB", + "CPUPerc": "20.55%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.31%", + "MemUsage": "125.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "147MB / 121MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455794.3099865, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.01%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.42%", + "MemUsage": "77.89MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "34.8MB / 38.2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.04%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.65%", + "MemUsage": "75.91MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "11.1MB / 12.1MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.23%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.379MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "12.1MB / 22.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.17%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.84%", + "MemUsage": "12.59MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "99.9MB / 107MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 528MB", + "CPUPerc": "1.83%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.33%", + "MemUsage": "125.4MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "148MB / 121MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.487, + "scheduled": 2400, + "attempted": 2293, + "successful": 2293, + "errors": {}, + "dropped": 107, + "dropped_scheduler": 0, + "dropped_concurrency": 107, + "driver_cpu_seconds": 0.6578289999999996, + "driver_cpu_fraction_one_core": 0.10140762413114704, + "successful_rps": 353.475, + "attempted_rps": 353.475, + "latency_success_ms": { + "p50": 116.852, + "p95": 622.574, + "p99": 828.107 + }, + "max_schedule_lag_ms": 3.858, + "instances": { + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 1146, + "62f00416-932c-44ad-8f59-c646f6379eba": 1147 + }, + "concurrency_cap": 128, + "configuration": "growth-2", + "repeat": 2, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455796.313451458, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "38.59%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "33.70%", + "MemUsage": "86.26MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "35.9MB / 39.3MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "50.93%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.69%", + "MemUsage": "76.01MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "12.1MB / 13.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.62%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.395MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "12.2MB / 22.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.29%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.06%", + "MemUsage": "12.88MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "101MB / 108MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 536MB", + "CPUPerc": "20.74%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.43%", + "MemUsage": "126.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "150MB / 122MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455798.323060125, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.31%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.48%", + "MemUsage": "78.04MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "36.9MB / 40.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "49.36%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.65%", + "MemUsage": "75.9MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "13.3MB / 14.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.66%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "12.3MB / 22.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.95%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.27%", + "MemUsage": "13.14MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "102MB / 109MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 564MB", + "CPUPerc": "23.53%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.60%", + "MemUsage": "127.5MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "151MB / 124MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455800.333092166, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.68%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "34.96%", + "MemUsage": "89.5MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "37.8MB / 41.4MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.93%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.66%", + "MemUsage": "75.93MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "14.3MB / 15.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.65%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "12.4MB / 23MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.76%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "103MB / 110MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 571MB", + "CPUPerc": "21.31%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.65%", + "MemUsage": "127.9MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "153MB / 125MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9967, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.40101400000000353, + "driver_cpu_fraction_one_core": 0.06687401760541435, + "successful_rps": 100.056, + "attempted_rps": 100.056, + "latency_success_ms": { + "p50": 4.935, + "p95": 8.921, + "p99": 42.634 + }, + "max_schedule_lag_ms": 1.286, + "instances": { + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 301, + "62f00416-932c-44ad-8f59-c646f6379eba": 299 + }, + "concurrency_cap": 128, + "configuration": "growth-2", + "repeat": 2, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455802.342712791, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "14.77%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.42%", + "MemUsage": "77.89MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "38.3MB / 42MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.22%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.66%", + "MemUsage": "75.92MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "14.5MB / 16MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.36%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "12.4MB / 23.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.21%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.86%", + "MemUsage": "12.62MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "103MB / 110MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 577MB", + "CPUPerc": "9.94%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.67%", + "MemUsage": "128MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "154MB / 126MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455804.357874125, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.17%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.43%", + "MemUsage": "77.89MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "38.5MB / 42.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "12.62%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.66%", + "MemUsage": "75.92MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "14.8MB / 16.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.13%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "12.5MB / 23.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.62%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.88%", + "MemUsage": "12.65MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "103MB / 110MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 579MB", + "CPUPerc": "8.25%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.70%", + "MemUsage": "128.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "154MB / 126MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455806.3697705, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "12.79%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.43%", + "MemUsage": "77.89MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "38.8MB / 42.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.84%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.66%", + "MemUsage": "75.92MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "15.1MB / 16.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.14%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "12.5MB / 23.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.63%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.88%", + "MemUsage": "12.65MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "103MB / 111MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 581MB", + "CPUPerc": "8.69%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.73%", + "MemUsage": "128.5MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "155MB / 126MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9948, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.4375789999999995, + "driver_cpu_fraction_one_core": 0.07299362032286852, + "successful_rps": 100.087, + "attempted_rps": 100.087, + "latency_success_ms": { + "p50": 4.987, + "p95": 10.563, + "p99": 50.754 + }, + "max_schedule_lag_ms": 5.512, + "instances": { + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 301, + "62f00416-932c-44ad-8f59-c646f6379eba": 299 + }, + "concurrency_cap": 128, + "configuration": "growth-2", + "repeat": 3, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455808.376233666, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "14.52%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.43%", + "MemUsage": "77.89MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "39.1MB / 42.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "13.75%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.66%", + "MemUsage": "75.93MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "15.3MB / 16.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.39%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "12.5MB / 23.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.91%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.90%", + "MemUsage": "12.68MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "103MB / 111MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 584MB", + "CPUPerc": "9.43%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.75%", + "MemUsage": "128.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "155MB / 127MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455810.383622666, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "17.30%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "33.60%", + "MemUsage": "86MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "39.4MB / 43.3MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "14.60%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "28.95%", + "MemUsage": "74.12MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "15.6MB / 17.3MB", + "PIDs": "10" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.48%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "12.5MB / 23.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.67%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.90%", + "MemUsage": "12.68MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "104MB / 111MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 586MB", + "CPUPerc": "9.00%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.78%", + "MemUsage": "128.8MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "156MB / 127MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455812.397932625, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.96%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.78%", + "MemUsage": "76.24MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "39.6MB / 43.6MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "14.91%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "28.95%", + "MemUsage": "74.12MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "15.9MB / 17.6MB", + "PIDs": "10" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.56%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "12.6MB / 23.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.97%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.90%", + "MemUsage": "12.68MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "104MB / 111MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 588MB", + "CPUPerc": "10.23%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.79%", + "MemUsage": "128.9MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "156MB / 127MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0026, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 1.0309420000000031, + "driver_cpu_fraction_one_core": 0.17175096821894723, + "successful_rps": 399.829, + "attempted_rps": 399.829, + "latency_success_ms": { + "p50": 2.949, + "p95": 156.776, + "p99": 191.779 + }, + "max_schedule_lag_ms": 3.834, + "instances": { + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 1200, + "62f00416-932c-44ad-8f59-c646f6379eba": 1200 + }, + "concurrency_cap": 128, + "configuration": "growth-2", + "repeat": 3, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455814.405155166, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "45.57%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.44%", + "MemUsage": "77.93MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "40.5MB / 44.5MB", + "PIDs": "44" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.67%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.07%", + "MemUsage": "74.41MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "16.7MB / 18.6MB", + "PIDs": "11" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.44%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "12.7MB / 23.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.27%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.08%", + "MemUsage": "12.9MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "105MB / 112MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 595MB", + "CPUPerc": "17.97%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.88%", + "MemUsage": "129.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "158MB / 129MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455816.412045375, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "31.26%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.41%", + "MemUsage": "77.86MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "41.6MB / 45.8MB", + "PIDs": "44" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "44.53%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.53%", + "MemUsage": "75.61MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "17.8MB / 19.7MB", + "PIDs": "40" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.48%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "12.8MB / 23.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.39%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.08%", + "MemUsage": "12.91MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "105MB / 113MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 603MB", + "CPUPerc": "18.45%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "16.98%", + "MemUsage": "130.4MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "159MB / 130MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455818.421202833, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "41.36%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.45%", + "MemUsage": "77.95MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "42.7MB / 47MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.37%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.50%", + "MemUsage": "75.53MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "18.9MB / 21MB", + "PIDs": "40" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.46%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "12.9MB / 24MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.36%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.06%", + "MemUsage": "12.88MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "106MB / 114MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 611MB", + "CPUPerc": "18.83%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "17.06%", + "MemUsage": "131.1MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "161MB / 132MB", + "PIDs": "22" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.339, + "scheduled": 5400, + "attempted": 2538, + "successful": 2538, + "errors": {}, + "dropped": 2862, + "dropped_scheduler": 0, + "dropped_concurrency": 2862, + "driver_cpu_seconds": 1.0893549999999976, + "driver_cpu_fraction_one_core": 0.1718503965428591, + "successful_rps": 400.38, + "attempted_rps": 400.38, + "latency_success_ms": { + "p50": 303.476, + "p95": 462.442, + "p99": 559.581 + }, + "max_schedule_lag_ms": 26.258, + "instances": { + "62f00416-932c-44ad-8f59-c646f6379eba": 1269, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 1269 + }, + "concurrency_cap": 128, + "configuration": "growth-2", + "repeat": 3, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455820.429381041, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.22%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.46%", + "MemUsage": "77.98MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "43.9MB / 48.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.57%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.65%", + "MemUsage": "75.91MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "20.1MB / 22.2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.31%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.375MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "13MB / 24.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.76%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "107MB / 115MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 619MB", + "CPUPerc": "20.67%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "17.15%", + "MemUsage": "131.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "163MB / 133MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455822.438945625, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.93%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.67%", + "MemUsage": "78.52MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "45.1MB / 49.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.90%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.66%", + "MemUsage": "75.94MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "21.4MB / 23.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.50%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.383MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "13.1MB / 24.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.20%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.58%", + "MemUsage": "13.55MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "108MB / 116MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 627MB", + "CPUPerc": "22.49%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "17.27%", + "MemUsage": "132.6MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "165MB / 135MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455824.446646791, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.30%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "33.21%", + "MemUsage": "85.01MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "46.2MB / 50.9MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.21%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.67%", + "MemUsage": "75.95MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "22.5MB / 24.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.44%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.387MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "13.3MB / 24.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.30%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "109MB / 117MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 635MB", + "CPUPerc": "20.92%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "17.32%", + "MemUsage": "133MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "167MB / 136MB", + "PIDs": "22" + } + ] + }, + { + "monotonic": 455826.489460333, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.92%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.42%", + "MemUsage": "77.89MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "46.6MB / 51.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.70%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.62%", + "MemUsage": "75.83MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "22.8MB / 25.2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.65%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.363MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "13.3MB / 24.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.44%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.84%", + "MemUsage": "12.6MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "110MB / 117MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 638MB", + "CPUPerc": "19.73%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "19.62%", + "MemUsage": "150.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "168MB / 137MB", + "PIDs": "23" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9947, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.4765130000000042, + "driver_cpu_fraction_one_core": 0.0794899513187198, + "successful_rps": 100.089, + "attempted_rps": 100.089, + "latency_success_ms": { + "p50": 4.939, + "p95": 7.956, + "p99": 28.1 + }, + "max_schedule_lag_ms": 1.436, + "instances": { + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 150, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 150, + "eab43aee-ab32-4113-963a-c26701e129eb": 150, + "62f00416-932c-44ad-8f59-c646f6379eba": 150 + }, + "concurrency_cap": 128, + "configuration": "growth-4", + "repeat": 1, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455837.248438333, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.23%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.72%", + "MemUsage": "76.09MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "46.8MB / 51.5MB", + "PIDs": "6" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.89%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "28.93%", + "MemUsage": "74.05MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "23MB / 25.4MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.04%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "21.91%", + "MemUsage": "56.09MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "146kB / 165kB", + "PIDs": "6" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.07%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "21.90%", + "MemUsage": "56.07MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "78.2kB / 90.3kB", + "PIDs": "6" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.19%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.62%", + "MemUsage": "3.348MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "13.3MB / 24.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.49%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.89%", + "MemUsage": "12.66MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "110MB / 118MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 648MB", + "CPUPerc": "7.76%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.32%", + "MemUsage": "140.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "168MB / 137MB", + "PIDs": "25" + } + ] + }, + { + "monotonic": 455839.265834, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.91%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.74%", + "MemUsage": "76.12MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "46.9MB / 51.6MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "8.32%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "28.93%", + "MemUsage": "74.05MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "23.1MB / 25.6MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.44%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "21.91%", + "MemUsage": "56.09MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "285kB / 318kB", + "PIDs": "6" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.22%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "21.95%", + "MemUsage": "56.19MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "282kB / 322kB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.55%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.344MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "13.3MB / 24.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.03%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.89%", + "MemUsage": "12.66MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "110MB / 118MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 650MB", + "CPUPerc": "9.85%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.43%", + "MemUsage": "141.6MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "169MB / 138MB", + "PIDs": "25" + } + ] + }, + { + "monotonic": 455841.275201291, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.95%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "33.70%", + "MemUsage": "86.27MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "47MB / 51.8MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.70%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "28.93%", + "MemUsage": "74.05MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "23.3MB / 25.7MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.08%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "21.91%", + "MemUsage": "56.09MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "418kB / 465kB", + "PIDs": "6" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.31%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "22.00%", + "MemUsage": "56.31MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "418kB / 474kB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.37%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "13.4MB / 24.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.76%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.88%", + "MemUsage": "12.65MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "110MB / 118MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 652MB", + "CPUPerc": "8.36%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "18.42%", + "MemUsage": "141.5MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "169MB / 138MB", + "PIDs": "25" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.006, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 1.1476449999999971, + "driver_cpu_fraction_one_core": 0.19108340412160874, + "successful_rps": 399.6, + "attempted_rps": 399.6, + "latency_success_ms": { + "p50": 4.663, + "p95": 295.169, + "p99": 428.531 + }, + "max_schedule_lag_ms": 9.275, + "instances": { + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 601, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 601, + "eab43aee-ab32-4113-963a-c26701e129eb": 599, + "62f00416-932c-44ad-8f59-c646f6379eba": 599 + }, + "concurrency_cap": 128, + "configuration": "growth-4", + "repeat": 1, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455843.285524666, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "17.37%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.81%", + "MemUsage": "76.31MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "47.6MB / 52.4MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "30.63%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "28.99%", + "MemUsage": "74.21MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "23.8MB / 26.3MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.38%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "25.61%", + "MemUsage": "65.57MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "943kB / 1.05MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.50%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.91%", + "MemUsage": "68.88MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "932kB / 1.04MB", + "PIDs": "13" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.77%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.62%", + "MemUsage": "3.352MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "13.5MB / 25.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.63%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.99%", + "MemUsage": "12.79MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "111MB / 119MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 660MB", + "CPUPerc": "20.73%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "19.42%", + "MemUsage": "149.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "171MB / 139MB", + "PIDs": "28" + } + ] + }, + { + "monotonic": 455845.297495541, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "38.55%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.45%", + "MemUsage": "77.95MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "48.1MB / 53MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "21.55%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.33%", + "MemUsage": "75.09MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "24.4MB / 27MB", + "PIDs": "30" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "22.35%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "23.30%", + "MemUsage": "59.64MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "1.56MB / 1.71MB", + "PIDs": "39" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "20.79%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "22.93%", + "MemUsage": "58.69MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "1.55MB / 1.72MB", + "PIDs": "28" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.46%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.379MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "13.6MB / 25.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.09%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.10%", + "MemUsage": "12.92MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "112MB / 120MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 666MB", + "CPUPerc": "24.62%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "22.68%", + "MemUsage": "174.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "173MB / 141MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455847.310089416, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "17.67%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.43%", + "MemUsage": "77.89MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "48.7MB / 53.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.71%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.33%", + "MemUsage": "75.07MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "25MB / 27.6MB", + "PIDs": "30" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "30.80%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "23.35%", + "MemUsage": "59.78MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "2.12MB / 2.34MB", + "PIDs": "39" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "30.99%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "22.94%", + "MemUsage": "58.73MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "2.12MB / 2.34MB", + "PIDs": "28" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.78%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.379MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "13.7MB / 25.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.17%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.00%", + "MemUsage": "12.8MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "113MB / 121MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 673MB", + "CPUPerc": "20.63%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "22.79%", + "MemUsage": "175MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "175MB / 143MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.2307, + "scheduled": 5400, + "attempted": 2756, + "successful": 2756, + "errors": {}, + "dropped": 2644, + "dropped_scheduler": 0, + "dropped_concurrency": 2644, + "driver_cpu_seconds": 1.1773060000000015, + "driver_cpu_fraction_one_core": 0.18895318948330153, + "successful_rps": 442.326, + "attempted_rps": 442.326, + "latency_success_ms": { + "p50": 203.99, + "p95": 782.35, + "p99": 812.384 + }, + "max_schedule_lag_ms": 4.512, + "instances": { + "eab43aee-ab32-4113-963a-c26701e129eb": 688, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 689, + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 690, + "62f00416-932c-44ad-8f59-c646f6379eba": 689 + }, + "concurrency_cap": 128, + "configuration": "growth-4", + "repeat": 1, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455849.325820958, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "22.95%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.46%", + "MemUsage": "77.97MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "49.3MB / 54.2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.63%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.63%", + "MemUsage": "75.86MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "25.6MB / 28.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.54%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "24.01%", + "MemUsage": "61.47MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "2.81MB / 3.05MB", + "PIDs": "39" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.17%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "24.25%", + "MemUsage": "62.09MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "2.78MB / 3.02MB", + "PIDs": "39" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.64%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "13.9MB / 25.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.63%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "114MB / 122MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 679MB", + "CPUPerc": "24.74%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "22.95%", + "MemUsage": "176.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "176MB / 144MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455851.334883416, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "29.95%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "33.99%", + "MemUsage": "87.02MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "50MB / 54.9MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.79%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.63%", + "MemUsage": "75.85MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "26.3MB / 29MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.63%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "25.03%", + "MemUsage": "64.09MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "3.43MB / 3.68MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.35%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "24.91%", + "MemUsage": "63.78MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "3.47MB / 3.74MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.52%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "14MB / 26MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.06%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "115MB / 123MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 685MB", + "CPUPerc": "24.92%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "23.05%", + "MemUsage": "177MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "178MB / 146MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455853.361796, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.42%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.49%", + "MemUsage": "78.04MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "50.6MB / 55.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "33.25%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "34.07%", + "MemUsage": "87.23MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "27MB / 29.7MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.12%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "28.36%", + "MemUsage": "72.61MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "4.2MB / 4.5MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "33.43%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "30.09%", + "MemUsage": "77.04MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "4.14MB / 4.44MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.52%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.406MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "14.2MB / 26.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.00%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.40%", + "MemUsage": "13.31MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "116MB / 124MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 710MB", + "CPUPerc": "25.50%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "23.21%", + "MemUsage": "178.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "181MB / 148MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.2819, + "scheduled": 5400, + "attempted": 2800, + "successful": 2800, + "errors": {}, + "dropped": 2600, + "dropped_scheduler": 0, + "dropped_concurrency": 2600, + "driver_cpu_seconds": 1.272077000000003, + "driver_cpu_fraction_one_core": 0.20250008266902153, + "successful_rps": 445.727, + "attempted_rps": 445.727, + "latency_success_ms": { + "p50": 219.412, + "p95": 615.93, + "p99": 716.073 + }, + "max_schedule_lag_ms": 20.575, + "instances": { + "eab43aee-ab32-4113-963a-c26701e129eb": 700, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 700, + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 700, + "62f00416-932c-44ad-8f59-c646f6379eba": 700 + }, + "concurrency_cap": 128, + "configuration": "growth-4", + "repeat": 2, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455855.375746083, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "37.04%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.52%", + "MemUsage": "78.12MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "51.4MB / 56.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.55%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.65%", + "MemUsage": "75.91MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "27.7MB / 30.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.49%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "25.67%", + "MemUsage": "65.72MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "4.87MB / 5.19MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.62%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "25.50%", + "MemUsage": "65.28MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "4.86MB / 5.19MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.56%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.41MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "14.3MB / 26.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.05%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "117MB / 126MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 716MB", + "CPUPerc": "25.28%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "23.37%", + "MemUsage": "179.5MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "183MB / 150MB", + "PIDs": "39" + } + ] + }, + { + "monotonic": 455857.387439666, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "27.48%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.47%", + "MemUsage": "78MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "52.1MB / 57.1MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "39.87%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.65%", + "MemUsage": "75.91MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "28.3MB / 31.1MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "38.61%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "26.36%", + "MemUsage": "67.48MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "5.54MB / 5.89MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "35.49%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.35%", + "MemUsage": "67.45MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "5.52MB / 5.87MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.55%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.67%", + "MemUsage": "3.422MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "14.5MB / 26.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.33%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.29MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "118MB / 127MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 723MB", + "CPUPerc": "24.97%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "23.42%", + "MemUsage": "179.9MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "185MB / 151MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455859.398759958, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "35.44%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.49%", + "MemUsage": "78.05MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "52.7MB / 57.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.28%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.64%", + "MemUsage": "75.89MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "29.1MB / 31.8MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.90%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "26.47%", + "MemUsage": "67.76MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "6.24MB / 6.62MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.35%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.27%", + "MemUsage": "67.25MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "6.2MB / 6.58MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.56%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.67%", + "MemUsage": "3.418MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "14.6MB / 27MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.31%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "119MB / 128MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 730MB", + "CPUPerc": "25.39%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "23.51%", + "MemUsage": "180.6MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "187MB / 153MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0015, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 1.0762420000000006, + "driver_cpu_fraction_one_core": 0.1793316575490172, + "successful_rps": 399.903, + "attempted_rps": 399.903, + "latency_success_ms": { + "p50": 3.068, + "p95": 18.634, + "p99": 60.061 + }, + "max_schedule_lag_ms": 4.44, + "instances": { + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 600, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 601, + "eab43aee-ab32-4113-963a-c26701e129eb": 601, + "62f00416-932c-44ad-8f59-c646f6379eba": 598 + }, + "concurrency_cap": 128, + "configuration": "growth-4", + "repeat": 2, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455861.409130666, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.74%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.43%", + "MemUsage": "77.91MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "53.3MB / 58.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.45%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.63%", + "MemUsage": "75.85MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "29.5MB / 32.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.53%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "26.46%", + "MemUsage": "67.73MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "6.73MB / 7.16MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.62%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.23%", + "MemUsage": "67.14MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "6.72MB / 7.16MB", + "PIDs": "43" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.70%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.406MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "14.7MB / 27.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.02%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.99%", + "MemUsage": "12.79MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "120MB / 129MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 738MB", + "CPUPerc": "18.21%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "23.59%", + "MemUsage": "181.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "188MB / 155MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455863.417481458, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "17.42%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.43%", + "MemUsage": "77.91MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "53.8MB / 59MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "20.75%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "32.86%", + "MemUsage": "84.13MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "30.1MB / 33MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.27%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "30.06%", + "MemUsage": "76.96MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "7.25MB / 7.74MB", + "PIDs": "39" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "29.57%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "31.31%", + "MemUsage": "80.14MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "7.25MB / 7.76MB", + "PIDs": "44" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.67%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.41MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "14.8MB / 27.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.07%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.99%", + "MemUsage": "12.79MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "121MB / 130MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 746MB", + "CPUPerc": "18.25%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "23.67%", + "MemUsage": "181.8MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "190MB / 156MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455865.432979541, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.51%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "34.06%", + "MemUsage": "87.2MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "54.4MB / 59.6MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.44%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.57%", + "MemUsage": "75.7MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "30.6MB / 33.6MB", + "PIDs": "40" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.86%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "26.21%", + "MemUsage": "67.11MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "7.8MB / 8.36MB", + "PIDs": "30" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.06%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.23%", + "MemUsage": "67.15MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "7.79MB / 8.36MB", + "PIDs": "43" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.56%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.41MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "14.9MB / 27.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.88%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.01%", + "MemUsage": "12.82MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "122MB / 131MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 754MB", + "CPUPerc": "17.95%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "23.79%", + "MemUsage": "182.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "192MB / 158MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9957, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.4538210000000049, + "driver_cpu_fraction_one_core": 0.07569139121082988, + "successful_rps": 100.071, + "attempted_rps": 100.071, + "latency_success_ms": { + "p50": 4.902, + "p95": 6.968, + "p99": 36.034 + }, + "max_schedule_lag_ms": 1.602, + "instances": { + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 151, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 151, + "eab43aee-ab32-4113-963a-c26701e129eb": 149, + "62f00416-932c-44ad-8f59-c646f6379eba": 149 + }, + "concurrency_cap": 128, + "configuration": "growth-4", + "repeat": 2, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455867.451434, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.51%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.44%", + "MemUsage": "77.92MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "54.6MB / 59.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.02%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.60%", + "MemUsage": "75.77MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "30.8MB / 33.9MB", + "PIDs": "36" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "17.82%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "26.16%", + "MemUsage": "66.96MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "8.02MB / 8.62MB", + "PIDs": "27" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.47%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.23%", + "MemUsage": "67.14MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "8.01MB / 8.62MB", + "PIDs": "43" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.08%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.398MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15MB / 27.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.97%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.97%", + "MemUsage": "12.77MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "122MB / 131MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 757MB", + "CPUPerc": "6.35%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "23.79%", + "MemUsage": "182.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "193MB / 158MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455869.469576583, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "20.26%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.44%", + "MemUsage": "77.91MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "54.7MB / 60.1MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.04%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.16%", + "MemUsage": "74.66MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "31MB / 34MB", + "PIDs": "18" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.22%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "25.89%", + "MemUsage": "66.29MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "8.15MB / 8.78MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.27%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.01%", + "MemUsage": "66.58MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "8.15MB / 8.78MB", + "PIDs": "30" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.08%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.402MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15MB / 27.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.18%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.98%", + "MemUsage": "12.77MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "122MB / 131MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 767MB", + "CPUPerc": "7.29%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "23.82%", + "MemUsage": "183MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "193MB / 159MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455871.486460875, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.97%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.87%", + "MemUsage": "76.47MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "54.9MB / 60.2MB", + "PIDs": "13" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "8.36%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.05%", + "MemUsage": "74.36MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "31.1MB / 34.2MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.71%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "25.85%", + "MemUsage": "66.18MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "8.29MB / 8.95MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.95%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "25.69%", + "MemUsage": "65.77MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "8.28MB / 8.95MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.69%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.398MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15MB / 27.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.84%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.96%", + "MemUsage": "12.75MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "123MB / 131MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 769MB", + "CPUPerc": "9.13%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "23.85%", + "MemUsage": "183.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "194MB / 159MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9971, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.46337299999999715, + "driver_cpu_fraction_one_core": 0.07726657238568986, + "successful_rps": 100.048, + "attempted_rps": 100.048, + "latency_success_ms": { + "p50": 4.856, + "p95": 7.386, + "p99": 44.112 + }, + "max_schedule_lag_ms": 1.296, + "instances": { + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 150, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 151, + "eab43aee-ab32-4113-963a-c26701e129eb": 151, + "62f00416-932c-44ad-8f59-c646f6379eba": 148 + }, + "concurrency_cap": 128, + "configuration": "growth-4", + "repeat": 3, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455873.500739666, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.31%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.87%", + "MemUsage": "76.48MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "55MB / 60.4MB", + "PIDs": "13" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.65%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.05%", + "MemUsage": "74.36MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "31.3MB / 34.4MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.34%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "25.86%", + "MemUsage": "66.19MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "8.43MB / 9.12MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.85%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "25.59%", + "MemUsage": "65.5MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "8.42MB / 9.11MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.63%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.398MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15.1MB / 27.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.18%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.98%", + "MemUsage": "12.78MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "123MB / 132MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 772MB", + "CPUPerc": "7.25%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "23.88%", + "MemUsage": "183.4MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "194MB / 159MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455875.514963125, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.67%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.87%", + "MemUsage": "76.47MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "55.1MB / 60.6MB", + "PIDs": "13" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.68%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "28.97%", + "MemUsage": "74.15MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "31.4MB / 34.5MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.35%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "25.75%", + "MemUsage": "65.92MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "8.56MB / 9.28MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.49%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "25.55%", + "MemUsage": "65.4MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "8.55MB / 9.28MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.51%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.402MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15.1MB / 27.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.51%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.97%", + "MemUsage": "12.76MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "123MB / 132MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 775MB", + "CPUPerc": "7.53%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "23.90%", + "MemUsage": "183.6MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "195MB / 160MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455877.528939166, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.05%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.75%", + "MemUsage": "76.17MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "55.3MB / 60.7MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.74%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "28.95%", + "MemUsage": "74.1MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "31.5MB / 34.7MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.36%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "25.75%", + "MemUsage": "65.91MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "8.7MB / 9.45MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.90%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "25.55%", + "MemUsage": "65.4MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "8.69MB / 9.44MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.55%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.398MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15.1MB / 28MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.65%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.97%", + "MemUsage": "12.76MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "123MB / 132MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 777MB", + "CPUPerc": "8.16%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "23.96%", + "MemUsage": "184MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "195MB / 160MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0024, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 1.0546369999999996, + "driver_cpu_fraction_one_core": 0.17570450303673787, + "successful_rps": 399.843, + "attempted_rps": 399.843, + "latency_success_ms": { + "p50": 2.993, + "p95": 18.611, + "p99": 68.675 + }, + "max_schedule_lag_ms": 5.152, + "instances": { + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 600, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 600, + "eab43aee-ab32-4113-963a-c26701e129eb": 601, + "62f00416-932c-44ad-8f59-c646f6379eba": 599 + }, + "concurrency_cap": 128, + "configuration": "growth-4", + "repeat": 3, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455879.541187208, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.90%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.84%", + "MemUsage": "76.38MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "55.7MB / 61.2MB", + "PIDs": "13" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.82%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "32.19%", + "MemUsage": "82.4MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "32MB / 35.2MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.65%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "29.76%", + "MemUsage": "76.18MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "9.15MB / 9.96MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "22.86%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "29.32%", + "MemUsage": "75.05MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "9.14MB / 9.96MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.59%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.41MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15.2MB / 28.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.87%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.02%", + "MemUsage": "12.83MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "124MB / 133MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 784MB", + "CPUPerc": "16.82%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "24.01%", + "MemUsage": "184.4MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "197MB / 161MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455881.548716958, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.16%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.84%", + "MemUsage": "76.39MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "56.3MB / 61.8MB", + "PIDs": "13" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.05%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.01%", + "MemUsage": "74.27MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "32.5MB / 35.8MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.14%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "25.79%", + "MemUsage": "66.03MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "9.69MB / 10.6MB", + "PIDs": "11" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.77%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "25.80%", + "MemUsage": "66.05MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "9.69MB / 10.6MB", + "PIDs": "22" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.66%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.406MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15.3MB / 28.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.90%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.04%", + "MemUsage": "12.86MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "125MB / 134MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 792MB", + "CPUPerc": "18.48%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "24.10%", + "MemUsage": "185.1MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "199MB / 163MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455883.560467583, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.51%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.84%", + "MemUsage": "76.39MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "56.8MB / 62.4MB", + "PIDs": "13" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.92%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.01%", + "MemUsage": "74.26MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "33.1MB / 36.4MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "29.70%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "25.81%", + "MemUsage": "66.08MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "10.2MB / 11.2MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.91%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "25.80%", + "MemUsage": "66.05MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "10.2MB / 11.2MB", + "PIDs": "22" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.60%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.406MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15.4MB / 28.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.89%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.04%", + "MemUsage": "12.86MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "126MB / 135MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 800MB", + "CPUPerc": "18.75%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "24.24%", + "MemUsage": "186.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "201MB / 164MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.2866, + "scheduled": 5400, + "attempted": 2497, + "successful": 2497, + "errors": {}, + "dropped": 2903, + "dropped_scheduler": 0, + "dropped_concurrency": 2903, + "driver_cpu_seconds": 1.1320750000000004, + "driver_cpu_fraction_one_core": 0.18007687364192498, + "successful_rps": 397.191, + "attempted_rps": 397.191, + "latency_success_ms": { + "p50": 279.023, + "p95": 621.578, + "p99": 815.84 + }, + "max_schedule_lag_ms": 11.368, + "instances": { + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 625, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 623, + "eab43aee-ab32-4113-963a-c26701e129eb": 625, + "62f00416-932c-44ad-8f59-c646f6379eba": 624 + }, + "concurrency_cap": 128, + "configuration": "growth-4", + "repeat": 3, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:46.698944461Z" + } + ], + "resource_samples": [ + { + "monotonic": 455885.574714541, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "33.55%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.47%", + "MemUsage": "78MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "57.5MB / 63.1MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.13%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.50%", + "MemUsage": "75.51MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "33.8MB / 37.2MB", + "PIDs": "37" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "22.18%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "26.50%", + "MemUsage": "67.84MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "10.9MB / 11.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.03%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.28%", + "MemUsage": "67.27MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "11MB / 11.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.48%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.69%", + "MemUsage": "3.441MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15.6MB / 28.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.22%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.40%", + "MemUsage": "13.32MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "127MB / 136MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 808MB", + "CPUPerc": "24.38%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "24.35%", + "MemUsage": "187MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "203MB / 166MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455887.586033291, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "20.61%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.46%", + "MemUsage": "77.98MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "58.1MB / 63.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.54%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.59%", + "MemUsage": "75.75MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "34.3MB / 37.7MB", + "PIDs": "42" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.55%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "26.50%", + "MemUsage": "67.85MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "11.4MB / 12.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.30%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.28%", + "MemUsage": "67.28MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "11.5MB / 12.5MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.29%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.68%", + "MemUsage": "3.43MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15.7MB / 29MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.82%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.58%", + "MemUsage": "13.55MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "128MB / 137MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 812MB", + "CPUPerc": "24.85%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "26.99%", + "MemUsage": "207.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "204MB / 168MB", + "PIDs": "39" + } + ] + }, + { + "monotonic": 455889.59861575, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "31.96%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.47%", + "MemUsage": "77.99MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "58.6MB / 64.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "30.57%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "33.05%", + "MemUsage": "84.61MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "34.9MB / 38.3MB", + "PIDs": "43" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "32.69%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "30.95%", + "MemUsage": "79.24MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "12MB / 12.9MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.71%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "29.74%", + "MemUsage": "76.14MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "12.1MB / 13.1MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.46%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.67%", + "MemUsage": "3.418MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15.8MB / 29.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.82%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.39%", + "MemUsage": "13.3MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "129MB / 138MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 817MB", + "CPUPerc": "24.65%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "24.56%", + "MemUsage": "188.6MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "206MB / 169MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455891.628191333, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.64%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.43%", + "MemUsage": "77.91MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "58.8MB / 64.5MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.40%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.57%", + "MemUsage": "75.69MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "35MB / 38.5MB", + "PIDs": "42" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.52%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "26.47%", + "MemUsage": "67.77MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "12.2MB / 13.2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.84%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.26%", + "MemUsage": "67.22MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "12.2MB / 13.2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.52%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.391MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15.9MB / 29.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.50%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.87%", + "MemUsage": "12.64MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "129MB / 138MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 820MB", + "CPUPerc": "0.74%", + "Container": "9798d7ed588dd0b6cc4469f9e4b8a7872d79fba1e973f0edd3e4517cab2d8da3", + "ID": "9798d7ed588d", + "MemPerc": "24.57%", + "MemUsage": "188.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "207MB / 170MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0275, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.49240700000000004, + "driver_cpu_fraction_one_core": 0.08169343579634694, + "successful_rps": 99.543, + "attempted_rps": 99.543, + "latency_success_ms": { + "p50": 5.14, + "p95": 7.358, + "p99": 27.245 + }, + "max_schedule_lag_ms": 3.905, + "instances": { + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 151, + "62f00416-932c-44ad-8f59-c646f6379eba": 150, + "eab43aee-ab32-4113-963a-c26701e129eb": 150, + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 149 + }, + "concurrency_cap": 128, + "configuration": "db-improved", + "repeat": 1, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 500000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:10:33.515601525Z" + } + ], + "resource_samples": [ + { + "monotonic": 455899.699564083, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.60%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.22%", + "MemUsage": "77.37MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "59MB / 64.7MB", + "PIDs": "31" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.95%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.27%", + "MemUsage": "74.93MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "35.1MB / 38.6MB", + "PIDs": "23" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.88%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "26.51%", + "MemUsage": "67.86MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "12.4MB / 13.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.06%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.18%", + "MemUsage": "67.03MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "12.4MB / 13.5MB", + "PIDs": "37" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.27%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.402MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15.9MB / 29.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.13%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.88%", + "MemUsage": "12.65MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "129MB / 138MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "11.61%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "12.06%", + "MemUsage": "92.66MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "710kB / 449kB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455901.713404833, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.52%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.79%", + "MemUsage": "76.25MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "59.1MB / 64.9MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.71%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.00%", + "MemUsage": "74.24MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "35.3MB / 38.8MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.29%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "25.83%", + "MemUsage": "66.13MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "12.5MB / 13.6MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.50%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "25.64%", + "MemUsage": "65.63MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "12.5MB / 13.6MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.56%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.85%", + "MemUsage": "3.648MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "15.9MB / 29.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.53%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.90%", + "MemUsage": "12.67MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "129MB / 139MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "10.35%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "12.54%", + "MemUsage": "96.32MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "1.23MB / 832kB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455903.724549125, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "14.07%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.79%", + "MemUsage": "76.25MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "59.2MB / 65MB", + "PIDs": "8" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.54%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "33.43%", + "MemUsage": "85.59MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "35.5MB / 39MB", + "PIDs": "10" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.46%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "29.79%", + "MemUsage": "76.27MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "12.6MB / 13.8MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "13.10%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "29.31%", + "MemUsage": "75.04MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "12.6MB / 13.8MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.49%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.391MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "16MB / 29.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.18%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.88%", + "MemUsage": "12.65MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "130MB / 139MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "7.26%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "12.63%", + "MemUsage": "97.02MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "1.72MB / 1.2MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0028, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 1.021259999999998, + "driver_cpu_fraction_one_core": 0.17013195582514973, + "successful_rps": 399.815, + "attempted_rps": 399.815, + "latency_success_ms": { + "p50": 2.896, + "p95": 5.783, + "p99": 56.927 + }, + "max_schedule_lag_ms": 3.649, + "instances": { + "62f00416-932c-44ad-8f59-c646f6379eba": 600, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 601, + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 599, + "eab43aee-ab32-4113-963a-c26701e129eb": 600 + }, + "concurrency_cap": 128, + "configuration": "db-improved", + "repeat": 1, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 500000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:10:33.515601525Z" + } + ], + "resource_samples": [ + { + "monotonic": 455905.731907041, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.73%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.77%", + "MemUsage": "76.21MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "59.8MB / 65.6MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.84%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.00%", + "MemUsage": "74.25MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "36MB / 39.6MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "14.76%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "25.91%", + "MemUsage": "66.34MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "13.2MB / 14.4MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.28%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "25.67%", + "MemUsage": "65.72MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "13.2MB / 14.4MB", + "PIDs": "11" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.58%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.406MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "16.1MB / 29.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.76%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.01%", + "MemUsage": "12.81MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "130MB / 140MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "17.21%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "12.93%", + "MemUsage": "99.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "3.51MB / 2.69MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455907.743378375, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.80%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.85%", + "MemUsage": "76.41MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "60.3MB / 66.2MB", + "PIDs": "13" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "29.23%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.05%", + "MemUsage": "74.36MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "36.5MB / 40.2MB", + "PIDs": "13" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.87%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "25.91%", + "MemUsage": "66.34MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "13.7MB / 15MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "29.68%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "25.68%", + "MemUsage": "65.75MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "13.7MB / 15MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.57%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.406MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "16.2MB / 29.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.98%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.02%", + "MemUsage": "12.83MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "131MB / 140MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "18.38%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "13.06%", + "MemUsage": "100.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "5.33MB / 4.2MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455909.754110208, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.85%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.85%", + "MemUsage": "76.41MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "60.8MB / 66.8MB", + "PIDs": "13" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.77%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.05%", + "MemUsage": "74.36MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "37.1MB / 40.8MB", + "PIDs": "13" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.62%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "25.91%", + "MemUsage": "66.34MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "14.2MB / 15.6MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.26%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "25.68%", + "MemUsage": "65.75MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "14.2MB / 15.6MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.63%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.406MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "16.3MB / 30.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.87%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.97%", + "MemUsage": "12.76MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "132MB / 141MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "17.76%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "13.13%", + "MemUsage": "100.9MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "7.14MB / 5.7MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0064, + "scheduled": 5400, + "attempted": 5302, + "successful": 5302, + "errors": {}, + "dropped": 98, + "dropped_scheduler": 0, + "dropped_concurrency": 98, + "driver_cpu_seconds": 1.7981459999999956, + "driver_cpu_fraction_one_core": 0.29937264527911367, + "successful_rps": 882.726, + "attempted_rps": 882.726, + "latency_success_ms": { + "p50": 4.205, + "p95": 220.376, + "p99": 307.411 + }, + "max_schedule_lag_ms": 3.933, + "instances": { + "62f00416-932c-44ad-8f59-c646f6379eba": 1325, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 1325, + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 1326, + "eab43aee-ab32-4113-963a-c26701e129eb": 1326 + }, + "concurrency_cap": 128, + "configuration": "db-improved", + "repeat": 1, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 500000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:10:33.515601525Z" + } + ], + "resource_samples": [ + { + "monotonic": 455911.768150583, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "42.95%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.90%", + "MemUsage": "76.55MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "62.1MB / 68.2MB", + "PIDs": "16" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "43.76%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.62%", + "MemUsage": "75.84MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "38.3MB / 42.1MB", + "PIDs": "44" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "39.71%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "26.22%", + "MemUsage": "67.12MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "15.5MB / 16.9MB", + "PIDs": "25" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "42.14%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.30%", + "MemUsage": "67.33MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "15.5MB / 16.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.63%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.406MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "16.5MB / 30.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "11.23%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.00%", + "MemUsage": "12.8MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "134MB / 144MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "44.73%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "13.35%", + "MemUsage": "102.5MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "11.1MB / 8.95MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455913.780111, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "46.54%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.24%", + "MemUsage": "77.42MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "63.4MB / 69.6MB", + "PIDs": "34" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "45.92%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "32.79%", + "MemUsage": "83.95MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "39.7MB / 43.5MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "42.94%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "29.29%", + "MemUsage": "74.97MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "16.8MB / 18.3MB", + "PIDs": "26" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "43.28%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "29.56%", + "MemUsage": "75.67MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "16.8MB / 18.2MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.56%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.402MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "16.8MB / 31.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "10.84%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.10%", + "MemUsage": "12.92MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "136MB / 146MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "43.63%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "13.64%", + "MemUsage": "104.8MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "15.1MB / 12.3MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455915.794339583, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "39.46%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.24%", + "MemUsage": "77.41MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "64.7MB / 70.9MB", + "PIDs": "34" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "39.06%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.62%", + "MemUsage": "75.83MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "40.9MB / 44.9MB", + "PIDs": "44" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "41.72%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "26.19%", + "MemUsage": "67.05MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "18.1MB / 19.7MB", + "PIDs": "29" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "38.77%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.51%", + "MemUsage": "67.86MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "18.1MB / 19.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.61%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.406MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "17MB / 31.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "10.63%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.86%", + "MemUsage": "12.62MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "139MB / 148MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "40.23%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "13.85%", + "MemUsage": "106.4MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "19.1MB / 15.6MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0468, + "scheduled": 5400, + "attempted": 5298, + "successful": 5298, + "errors": {}, + "dropped": 102, + "dropped_scheduler": 0, + "dropped_concurrency": 102, + "driver_cpu_seconds": 1.9070609999999988, + "driver_cpu_fraction_one_core": 0.31538257716045937, + "successful_rps": 876.161, + "attempted_rps": 876.161, + "latency_success_ms": { + "p50": 4.775, + "p95": 223.691, + "p99": 307.446 + }, + "max_schedule_lag_ms": 6.516, + "instances": { + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 1325, + "eab43aee-ab32-4113-963a-c26701e129eb": 1325, + "62f00416-932c-44ad-8f59-c646f6379eba": 1325, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 1323 + }, + "concurrency_cap": 128, + "configuration": "db-improved", + "repeat": 2, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 500000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:10:33.515601525Z" + } + ], + "resource_samples": [ + { + "monotonic": 455917.806489666, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "35.83%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.45%", + "MemUsage": "77.95MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "65.9MB / 72.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "46.92%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "34.75%", + "MemUsage": "88.96MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "42MB / 46.1MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "44.78%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "31.53%", + "MemUsage": "80.72MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "19.3MB / 21MB", + "PIDs": "30" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "46.09%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.90%", + "MemUsage": "68.87MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "19.2MB / 20.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.28%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.398MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "17.2MB / 32MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.98%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.40%", + "MemUsage": "13.31MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "141MB / 150MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "34.94%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "14.09%", + "MemUsage": "108.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "22.8MB / 18.7MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455919.82098875, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "47.21%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "34.27%", + "MemUsage": "87.72MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "67.2MB / 73.6MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "41.71%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.64%", + "MemUsage": "75.89MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "43.5MB / 47.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "42.84%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "28.32%", + "MemUsage": "72.5MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "20.6MB / 22.4MB", + "PIDs": "29" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "41.67%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.86%", + "MemUsage": "68.77MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "20.6MB / 22.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.66%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.67%", + "MemUsage": "3.422MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "17.5MB / 32.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "10.83%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.13%", + "MemUsage": "12.97MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "143MB / 153MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "42.19%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "14.29%", + "MemUsage": "109.8MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "27MB / 22.2MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455921.833646958, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "40.58%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.45%", + "MemUsage": "77.95MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "68.5MB / 75MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "49.98%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.73%", + "MemUsage": "76.12MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "44.7MB / 49MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.09%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "28.44%", + "MemUsage": "72.8MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "21.9MB / 23.7MB", + "PIDs": "35" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "50.24%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "27.51%", + "MemUsage": "70.43MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "21.9MB / 23.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.20%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.67%", + "MemUsage": "3.414MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "17.7MB / 33MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "10.00%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.07%", + "MemUsage": "12.89MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "145MB / 155MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "40.52%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "14.48%", + "MemUsage": "111.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "31MB / 25.5MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0495, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 1.0228139999999968, + "driver_cpu_fraction_one_core": 0.16907670333282343, + "successful_rps": 396.73, + "attempted_rps": 396.73, + "latency_success_ms": { + "p50": 2.888, + "p95": 5.889, + "p99": 55.708 + }, + "max_schedule_lag_ms": 2.731, + "instances": { + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 601, + "62f00416-932c-44ad-8f59-c646f6379eba": 599, + "eab43aee-ab32-4113-963a-c26701e129eb": 601, + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 599 + }, + "concurrency_cap": 128, + "configuration": "db-improved", + "repeat": 2, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 500000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:10:33.515601525Z" + } + ], + "resource_samples": [ + { + "monotonic": 455923.843213791, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "29.11%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.45%", + "MemUsage": "77.96MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "69MB / 75.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.97%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.84%", + "MemUsage": "76.38MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "45.3MB / 49.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.14%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "28.44%", + "MemUsage": "72.8MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "22.4MB / 24.3MB", + "PIDs": "35" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.49%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "27.49%", + "MemUsage": "70.39MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "22.4MB / 24.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.60%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.406MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "17.8MB / 33.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.10%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.97%", + "MemUsage": "12.76MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "146MB / 156MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "17.06%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "14.60%", + "MemUsage": "112.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "32.8MB / 27MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455925.856015541, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.95%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.45%", + "MemUsage": "77.96MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "69.6MB / 76.2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.06%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.74%", + "MemUsage": "76.13MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "45.8MB / 50.2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.39%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "28.44%", + "MemUsage": "72.8MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "23MB / 24.9MB", + "PIDs": "35" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.18%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "27.50%", + "MemUsage": "70.4MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "23MB / 24.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.57%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.406MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "17.9MB / 33.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.73%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.03%", + "MemUsage": "12.84MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "147MB / 157MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "17.88%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "14.67%", + "MemUsage": "112.6MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "34.6MB / 28.5MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455927.866134208, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.96%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.23%", + "MemUsage": "77.38MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "70.1MB / 76.8MB", + "PIDs": "31" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.97%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.74%", + "MemUsage": "76.13MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "46.3MB / 50.8MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.08%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "32.15%", + "MemUsage": "82.29MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "23.5MB / 25.5MB", + "PIDs": "36" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.57%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "32.42%", + "MemUsage": "83MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "23.5MB / 25.5MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.54%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.395MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "18.1MB / 33.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.81%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.03%", + "MemUsage": "12.84MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "147MB / 157MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "17.54%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "14.78%", + "MemUsage": "113.5MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "36.4MB / 30MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9954, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.4979380000000049, + "driver_cpu_fraction_one_core": 0.08305383954688951, + "successful_rps": 100.077, + "attempted_rps": 100.077, + "latency_success_ms": { + "p50": 4.93, + "p95": 7.355, + "p99": 38.442 + }, + "max_schedule_lag_ms": 1.369, + "instances": { + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 150, + "62f00416-932c-44ad-8f59-c646f6379eba": 150, + "eab43aee-ab32-4113-963a-c26701e129eb": 151, + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 149 + }, + "concurrency_cap": 128, + "configuration": "db-improved", + "repeat": 2, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 500000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:10:33.515601525Z" + } + ], + "resource_samples": [ + { + "monotonic": 455929.876417375, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.02%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "34.50%", + "MemUsage": "88.33MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "70.2MB / 77MB", + "PIDs": "32" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.11%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.50%", + "MemUsage": "75.52MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "46.5MB / 50.9MB", + "PIDs": "30" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.88%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "28.44%", + "MemUsage": "72.8MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "23.6MB / 25.7MB", + "PIDs": "35" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.06%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "27.50%", + "MemUsage": "70.39MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "23.6MB / 25.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.61%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.395MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "18.1MB / 33.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.47%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.00%", + "MemUsage": "12.8MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "148MB / 158MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "8.08%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "14.81%", + "MemUsage": "113.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "37MB / 30.4MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455931.893479916, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.76%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.89%", + "MemUsage": "76.53MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "70.4MB / 77.1MB", + "PIDs": "13" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.65%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.26%", + "MemUsage": "74.91MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "46.6MB / 51.1MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.43%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "28.04%", + "MemUsage": "71.78MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "23.8MB / 25.9MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.91%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.92%", + "MemUsage": "68.92MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "23.8MB / 25.9MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.27%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.391MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "18.1MB / 33.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.93%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.00%", + "MemUsage": "12.8MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "148MB / 158MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "6.66%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "14.83%", + "MemUsage": "113.9MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "37.5MB / 30.8MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455933.904889416, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.32%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.87%", + "MemUsage": "76.47MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "70.5MB / 77.3MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.00%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.16%", + "MemUsage": "74.65MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "46.7MB / 51.3MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.73%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "28.04%", + "MemUsage": "71.78MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "23.9MB / 26MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.32%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.92%", + "MemUsage": "68.92MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "23.9MB / 26MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.42%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.391MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "18.1MB / 33.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.12%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.98%", + "MemUsage": "12.77MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "148MB / 158MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "18.18%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "15.23%", + "MemUsage": "117MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "38MB / 31.1MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 100, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 5.9962, + "scheduled": 600, + "attempted": 600, + "successful": 600, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.46112600000000015, + "driver_cpu_fraction_one_core": 0.07690383126672143, + "successful_rps": 100.064, + "attempted_rps": 100.064, + "latency_success_ms": { + "p50": 5.003, + "p95": 7.536, + "p99": 39.256 + }, + "max_schedule_lag_ms": 1.737, + "instances": { + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 151, + "62f00416-932c-44ad-8f59-c646f6379eba": 151, + "eab43aee-ab32-4113-963a-c26701e129eb": 148, + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 150 + }, + "concurrency_cap": 128, + "configuration": "db-improved", + "repeat": 3, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 500000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:10:33.515601525Z" + } + ], + "resource_samples": [ + { + "monotonic": 455935.924946791, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.44%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.87%", + "MemUsage": "76.47MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "70.6MB / 77.5MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.71%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.06%", + "MemUsage": "74.4MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "46.9MB / 51.4MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.68%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "27.98%", + "MemUsage": "71.63MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "24MB / 26.2MB", + "PIDs": "9" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.58%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.90%", + "MemUsage": "68.86MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "24MB / 26.2MB", + "PIDs": "11" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.51%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.391MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "18.2MB / 33.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.75%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.00%", + "MemUsage": "12.8MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "148MB / 158MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "8.73%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "15.28%", + "MemUsage": "117.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "38.5MB / 31.5MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455937.94033775, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.37%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.77%", + "MemUsage": "76.22MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "70.8MB / 77.6MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.77%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.06%", + "MemUsage": "74.4MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "47MB / 51.6MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.65%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "27.94%", + "MemUsage": "71.53MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "24.2MB / 26.4MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.76%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.82%", + "MemUsage": "68.66MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "24.2MB / 26.4MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.12%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.387MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "18.2MB / 33.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.39%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.00%", + "MemUsage": "12.8MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "149MB / 158MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "7.75%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "15.32%", + "MemUsage": "117.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "39MB / 31.9MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455939.958123125, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.77%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.77%", + "MemUsage": "76.22MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "70.9MB / 77.8MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.37%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.06%", + "MemUsage": "74.4MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "47.1MB / 51.8MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.99%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "27.94%", + "MemUsage": "71.52MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "24.3MB / 26.5MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.08%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.82%", + "MemUsage": "68.66MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "24.3MB / 26.5MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.13%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.391MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "18.2MB / 33.9MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.35%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.97%", + "MemUsage": "12.77MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "149MB / 159MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "8.31%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "15.30%", + "MemUsage": "117.5MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "39.5MB / 32.3MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 400, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0025, + "scheduled": 2400, + "attempted": 2400, + "successful": 2400, + "errors": {}, + "dropped": 0, + "dropped_scheduler": 0, + "dropped_concurrency": 0, + "driver_cpu_seconds": 0.9718030000000013, + "driver_cpu_fraction_one_core": 0.16190009251046095, + "successful_rps": 399.833, + "attempted_rps": 399.833, + "latency_success_ms": { + "p50": 2.956, + "p95": 6.722, + "p99": 57.082 + }, + "max_schedule_lag_ms": 4.136, + "instances": { + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 601, + "62f00416-932c-44ad-8f59-c646f6379eba": 600, + "eab43aee-ab32-4113-963a-c26701e129eb": 600, + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 599 + }, + "concurrency_cap": 128, + "configuration": "db-improved", + "repeat": 3, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 500000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:10:33.515601525Z" + } + ], + "resource_samples": [ + { + "monotonic": 455941.968851625, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.17%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.77%", + "MemUsage": "76.22MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "71.4MB / 78.4MB", + "PIDs": "7" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.75%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.13%", + "MemUsage": "74.56MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "47.7MB / 52.4MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "14.66%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "27.98%", + "MemUsage": "71.64MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "24.8MB / 27.1MB", + "PIDs": "11" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "17.30%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.88%", + "MemUsage": "68.82MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "24.8MB / 27.1MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.54%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.395MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "18.4MB / 34.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.70%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.07%", + "MemUsage": "12.89MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "150MB / 160MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "17.30%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "15.46%", + "MemUsage": "118.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "41.3MB / 33.8MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455943.97847075, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "19.47%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.83%", + "MemUsage": "76.38MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "72MB / 79MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "16.80%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.13%", + "MemUsage": "74.56MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "48.2MB / 53MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.33%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "31.65%", + "MemUsage": "81.03MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "25.4MB / 27.7MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "20.44%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "30.12%", + "MemUsage": "77.11MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "25.4MB / 27.7MB", + "PIDs": "13" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.71%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.395MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "18.5MB / 34.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.07%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.07%", + "MemUsage": "12.89MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "150MB / 160MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "19.49%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "15.50%", + "MemUsage": "119MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "43.1MB / 35.3MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455945.990965833, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.35%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "29.84%", + "MemUsage": "76.38MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "72.5MB / 79.6MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.01%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.13%", + "MemUsage": "74.56MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "48.8MB / 53.6MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "17.63%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "28.00%", + "MemUsage": "71.69MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "25.9MB / 28.3MB", + "PIDs": "12" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "18.58%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "26.90%", + "MemUsage": "68.87MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "25.9MB / 28.3MB", + "PIDs": "13" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.87%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.395MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "18.6MB / 34.6MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.61%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.02%", + "MemUsage": "12.82MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "151MB / 161MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "21.07%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "15.57%", + "MemUsage": "119.6MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "44.9MB / 36.8MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.0178, + "scheduled": 5400, + "attempted": 5302, + "successful": 5302, + "errors": {}, + "dropped": 98, + "dropped_scheduler": 0, + "dropped_concurrency": 98, + "driver_cpu_seconds": 1.6759139999999988, + "driver_cpu_fraction_one_core": 0.27849467998379246, + "successful_rps": 881.057, + "attempted_rps": 881.057, + "latency_success_ms": { + "p50": 5.848, + "p95": 273.628, + "p99": 413.754 + }, + "max_schedule_lag_ms": 5.155, + "instances": { + "6b947ad2-de4e-485c-a6d5-e65519f635f6": 1326, + "eab43aee-ab32-4113-963a-c26701e129eb": 1324, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 1327, + "62f00416-932c-44ad-8f59-c646f6379eba": 1325 + }, + "concurrency_cap": 128, + "configuration": "db-improved", + "repeat": 3, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.63328953Z" + }, + { + "id": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:09:29.56615491Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 500000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:10:33.515601525Z" + } + ], + "resource_samples": [ + { + "monotonic": 455948.003161083, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "39.95%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.38%", + "MemUsage": "77.77MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "73.7MB / 80.9MB", + "PIDs": "41" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "48.86%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.10%", + "MemUsage": "74.5MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "50MB / 54.9MB", + "PIDs": "39" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "49.43%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "28.37%", + "MemUsage": "72.63MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "27MB / 29.6MB", + "PIDs": "30" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "48.81%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "27.51%", + "MemUsage": "70.42MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "27.1MB / 29.6MB", + "PIDs": "44" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.33%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.406MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "18.8MB / 35MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "9.74%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.33%", + "MemUsage": "13.22MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "153MB / 163MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "41.27%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "15.79%", + "MemUsage": "121.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "48.8MB / 40MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455950.015736833, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "46.26%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "33.89%", + "MemUsage": "86.76MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "75MB / 82.2MB", + "PIDs": "42" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "45.67%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.10%", + "MemUsage": "74.5MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "51.3MB / 56.3MB", + "PIDs": "39" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "45.10%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "28.57%", + "MemUsage": "73.14MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "28.4MB / 31.1MB", + "PIDs": "42" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "45.27%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "27.49%", + "MemUsage": "70.36MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "28.5MB / 31MB", + "PIDs": "44" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.78%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.391MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "19MB / 35.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "12.19%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.19%", + "MemUsage": "13.05MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "156MB / 166MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "46.81%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "16.01%", + "MemUsage": "122.9MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "52.8MB / 43.4MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455952.034145291, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "48.52%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.46%", + "MemUsage": "77.96MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "76.4MB / 83.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "46.47%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.10%", + "MemUsage": "74.5MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "52.6MB / 57.7MB", + "PIDs": "39" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "51.08%", + "Container": "59ebd72b4c7b8daaaa9fc9198fc185c2be3b5d8932fbc75fed68b96b3ceb454f", + "ID": "59ebd72b4c7b", + "MemPerc": "28.57%", + "MemUsage": "73.14MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "29.7MB / 32.4MB", + "PIDs": "42" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "44.90%", + "Container": "4602dcce1688ee155a2864b5c10104e98d414e0348481d49d3384a09f97e6075", + "ID": "4602dcce1688", + "MemPerc": "27.48%", + "MemUsage": "70.35MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "29.7MB / 32.4MB", + "PIDs": "44" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.41%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.395MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "19.3MB / 36MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "11.54%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.04%", + "MemUsage": "12.85MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "158MB / 168MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "46.09%", + "Container": "b1b437f9b704a59d6d8b18c3d6a99629d55913d2a8b61944482f3de43718c8d3", + "ID": "b1b437f9b704", + "MemPerc": "16.18%", + "MemUsage": "124.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "56.9MB / 46.7MB", + "PIDs": "38" + } + ] + } + ] + } + ], + "notes": [ + "PostgreSQL intentionally constrained to 0.25CPU to expose its resource boundary.", + "Open-loop scheduler drops if concurrency cap128 or lag>250ms; no hidden backlog.", + "Only successes enter latency percentiles; wall time includes draining requests." + ], + "ended_at": "2026-11-06T15:11:38.519145+00:00" +} diff --git a/evidence/scaling-final.png b/evidence/scaling-final.png new file mode 100644 index 0000000000000000000000000000000000000000..3e6ae85ad0f9ee5020a2954599cdcfdf2b6bb882 GIT binary patch literal 106330 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%0A&Gf9HO^nj!Z={S$Ql^; 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 VUE^Ly0r3aaRkV&%kDkBv{{U>{DrEow literal 0 HcmV?d00001 diff --git a/evidence/scaling-final.svg b/evidence/scaling-final.svg new file mode 100644 index 00000000..ba6d62e7 --- /dev/null +++ b/evidence/scaling-final.svg @@ -0,0 +1,2691 @@ + + + + + + + + 2026-11-06T18:15:53.855682 + image/svg+xml + + + Matplotlib v3.10.8, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/evidence/scaling-pilot-aiohttp.json b/evidence/scaling-pilot-aiohttp.json new file mode 100644 index 00000000..fac80852 --- /dev/null +++ b/evidence/scaling-pilot-aiohttp.json @@ -0,0 +1,28 @@ +{ + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 600, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.1991, + "scheduled": 3600, + "attempted": 2624, + "successful": 2624, + "errors": {}, + "dropped": 976, + "dropped_scheduler": 0, + "dropped_concurrency": 976, + "driver_cpu_seconds": 1.237524, + "driver_cpu_fraction_one_core": 0.19963119577564414, + "successful_rps": 423.29, + "attempted_rps": 423.29, + "latency_success_ms": { + "p50": 280.202, + "p95": 396.953, + "p99": 483.614 + }, + "max_schedule_lag_ms": 4.839, + "instances": { + "02ae80f9-f61b-4964-ab16-b836523904d3": 1313, + "52e57fca-356b-4ffc-8446-60f6e871d1c8": 1311 + }, + "concurrency_cap": 128 +} diff --git a/evidence/scaling-pilot-causal.json b/evidence/scaling-pilot-causal.json new file mode 100644 index 00000000..458f8001 --- /dev/null +++ b/evidence/scaling-pilot-causal.json @@ -0,0 +1,856 @@ +[ + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 8, + "elapsed_including_drain_seconds": 8.2727, + "scheduled": 7200, + "attempted": 3148, + "successful": 3145, + "errors": { + "503": 3 + }, + "dropped": 4052, + "dropped_scheduler": 0, + "dropped_concurrency": 4052, + "driver_cpu_seconds": 1.437157, + "driver_cpu_fraction_one_core": 0.17372256610626258, + "successful_rps": 380.165, + "attempted_rps": 380.527, + "latency_success_ms": { + "p50": 282.476, + "p95": 676.027, + "p99": 1311.087 + }, + "max_schedule_lag_ms": 7.118, + "instances": { + "c0034232-3cda-4d6e-a3bf-7e649636f924": 787, + "b5395b66-8f7c-4f58-bb34-a04b9ad100d0": 786, + "ff56195f-409f-464a-a76b-7c01f9e08ad1": 784, + "4236ea3c-10a3-4d07-bf15-1cc5c719fb42": 788 + }, + "concurrency_cap": 128, + "pg_cpu": 0.25, + "actual_containers": [ + { + "id": "7b230a73710c5a6a2ba381d102281ebdd211c4df7ecdbe859c62796e68180848", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:03:04.540123598Z" + }, + { + "id": "466a9c57a700191613da1220099ba75caa787a64b4744611b8d09d04cd4ba5e4", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:03:04.446553121Z" + }, + { + "id": "6295c582c2a0ca50e6fc93e17a84ed14a09919fbc46264d422fb83397b3a10fa", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:03:04.612162729Z" + }, + { + "id": "1b9796815fe30621cdc589ea8eb741e712dd354df8931ef74f9a2ef0f1928b3e", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:03:04.698668707Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "7f9fa5c30fc5026ff6329df8987f2d853d16f99c1dcbac0339f1909e227e8d6a", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:01:12.408070528Z" + } + ], + "resource_samples": [ + { + "monotonic": 455452.363337958, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.83%", + "Container": "7b230a73710c5a6a2ba381d102281ebdd211c4df7ecdbe859c62796e68180848", + "ID": "7b230a73710c", + "MemPerc": "23.58%", + "MemUsage": "60.37MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "301kB / 322kB", + "PIDs": "41" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.55%", + "Container": "466a9c57a700191613da1220099ba75caa787a64b4744611b8d09d04cd4ba5e4", + "ID": "466a9c57a700", + "MemPerc": "23.37%", + "MemUsage": "59.83MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "257kB / 267kB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "27.54%", + "Container": "6295c582c2a0ca50e6fc93e17a84ed14a09919fbc46264d422fb83397b3a10fa", + "ID": "6295c582c2a0", + "MemPerc": "22.90%", + "MemUsage": "58.64MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "326kB / 361kB", + "PIDs": "35" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "27.22%", + "Container": "1b9796815fe30621cdc589ea8eb741e712dd354df8931ef74f9a2ef0f1928b3e", + "ID": "1b9796815fe3", + "MemPerc": "23.60%", + "MemUsage": "60.43MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "277kB / 289kB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.18%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "1.24MB / 2.35MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "3.62%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.30%", + "MemUsage": "13.18MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "13MB / 13.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 618kB", + "CPUPerc": "27.21%", + "Container": "7f9fa5c30fc5026ff6329df8987f2d853d16f99c1dcbac0339f1909e227e8d6a", + "ID": "7f9fa5c30fc5", + "MemPerc": "11.29%", + "MemUsage": "86.69MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "9.26MB / 7.37MB", + "PIDs": "35" + } + ] + }, + { + "monotonic": 455454.376392708, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.48%", + "Container": "7b230a73710c5a6a2ba381d102281ebdd211c4df7ecdbe859c62796e68180848", + "ID": "7b230a73710c", + "MemPerc": "24.00%", + "MemUsage": "61.43MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "952kB / 1MB", + "PIDs": "41" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.75%", + "Container": "466a9c57a700191613da1220099ba75caa787a64b4744611b8d09d04cd4ba5e4", + "ID": "466a9c57a700", + "MemPerc": "24.01%", + "MemUsage": "61.46MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "894kB / 925kB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.87%", + "Container": "6295c582c2a0ca50e6fc93e17a84ed14a09919fbc46264d422fb83397b3a10fa", + "ID": "6295c582c2a0", + "MemPerc": "23.35%", + "MemUsage": "59.78MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "973kB / 1.04MB", + "PIDs": "35" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.39%", + "Container": "1b9796815fe30621cdc589ea8eb741e712dd354df8931ef74f9a2ef0f1928b3e", + "ID": "1b9796815fe3", + "MemPerc": "24.16%", + "MemUsage": "61.86MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "920kB / 960kB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.46%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.61%", + "MemUsage": "3.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "1.38MB / 2.58MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.92%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.31%", + "MemUsage": "13.19MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "14MB / 14.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 618kB", + "CPUPerc": "25.37%", + "Container": "7f9fa5c30fc5026ff6329df8987f2d853d16f99c1dcbac0339f1909e227e8d6a", + "ID": "7f9fa5c30fc5", + "MemPerc": "13.54%", + "MemUsage": "104MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "11.9MB / 9.57MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455456.391487458, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "31.86%", + "Container": "7b230a73710c5a6a2ba381d102281ebdd211c4df7ecdbe859c62796e68180848", + "ID": "7b230a73710c", + "MemPerc": "24.58%", + "MemUsage": "62.93MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "1.67MB / 1.76MB", + "PIDs": "41" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "29.31%", + "Container": "466a9c57a700191613da1220099ba75caa787a64b4744611b8d09d04cd4ba5e4", + "ID": "466a9c57a700", + "MemPerc": "24.98%", + "MemUsage": "63.96MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "1.58MB / 1.63MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "27.08%", + "Container": "6295c582c2a0ca50e6fc93e17a84ed14a09919fbc46264d422fb83397b3a10fa", + "ID": "6295c582c2a0", + "MemPerc": "24.04%", + "MemUsage": "61.55MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "1.68MB / 1.78MB", + "PIDs": "36" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "33.68%", + "Container": "1b9796815fe30621cdc589ea8eb741e712dd354df8931ef74f9a2ef0f1928b3e", + "ID": "1b9796815fe3", + "MemPerc": "24.68%", + "MemUsage": "63.19MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "1.65MB / 1.73MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.60%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "1.53MB / 2.83MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "6.42%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.31%", + "MemUsage": "13.19MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "15.1MB / 16MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 618kB", + "CPUPerc": "26.35%", + "Container": "7f9fa5c30fc5026ff6329df8987f2d853d16f99c1dcbac0339f1909e227e8d6a", + "ID": "7f9fa5c30fc5", + "MemPerc": "13.64%", + "MemUsage": "104.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "14MB / 11.4MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455458.406224, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.33%", + "Container": "7b230a73710c5a6a2ba381d102281ebdd211c4df7ecdbe859c62796e68180848", + "ID": "7b230a73710c", + "MemPerc": "25.14%", + "MemUsage": "64.35MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "2.4MB / 2.53MB", + "PIDs": "41" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "27.04%", + "Container": "466a9c57a700191613da1220099ba75caa787a64b4744611b8d09d04cd4ba5e4", + "ID": "466a9c57a700", + "MemPerc": "25.70%", + "MemUsage": "65.8MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "2.28MB / 2.37MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.01%", + "Container": "6295c582c2a0ca50e6fc93e17a84ed14a09919fbc46264d422fb83397b3a10fa", + "ID": "6295c582c2a0", + "MemPerc": "24.70%", + "MemUsage": "63.24MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "2.39MB / 2.52MB", + "PIDs": "36" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.13%", + "Container": "1b9796815fe30621cdc589ea8eb741e712dd354df8931ef74f9a2ef0f1928b3e", + "ID": "1b9796815fe3", + "MemPerc": "25.51%", + "MemUsage": "65.31MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "2.35MB / 2.45MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.60%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "1.69MB / 3.09MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.92%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.29%", + "MemUsage": "13.17MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "16.2MB / 17.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 618kB", + "CPUPerc": "25.53%", + "Container": "7f9fa5c30fc5026ff6329df8987f2d853d16f99c1dcbac0339f1909e227e8d6a", + "ID": "7f9fa5c30fc5", + "MemPerc": "13.75%", + "MemUsage": "105.6MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "16.1MB / 13.2MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 8, + "elapsed_including_drain_seconds": 8.0146, + "scheduled": 7200, + "attempted": 7048, + "successful": 7048, + "errors": {}, + "dropped": 152, + "dropped_scheduler": 0, + "dropped_concurrency": 152, + "driver_cpu_seconds": 2.5354680000000003, + "driver_cpu_fraction_one_core": 0.31635691038405095, + "successful_rps": 879.395, + "attempted_rps": 879.395, + "latency_success_ms": { + "p50": 7.316, + "p95": 185.956, + "p99": 250.607 + }, + "max_schedule_lag_ms": 11.95, + "instances": { + "ff56195f-409f-464a-a76b-7c01f9e08ad1": 1763, + "4236ea3c-10a3-4d07-bf15-1cc5c719fb42": 1761, + "c0034232-3cda-4d6e-a3bf-7e649636f924": 1763, + "b5395b66-8f7c-4f58-bb34-a04b9ad100d0": 1761 + }, + "concurrency_cap": 128, + "pg_cpu": 0.5, + "actual_containers": [ + { + "id": "7b230a73710c5a6a2ba381d102281ebdd211c4df7ecdbe859c62796e68180848", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:03:04.540123598Z" + }, + { + "id": "466a9c57a700191613da1220099ba75caa787a64b4744611b8d09d04cd4ba5e4", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:03:04.446553121Z" + }, + { + "id": "6295c582c2a0ca50e6fc93e17a84ed14a09919fbc46264d422fb83397b3a10fa", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:03:04.612162729Z" + }, + { + "id": "1b9796815fe30621cdc589ea8eb741e712dd354df8931ef74f9a2ef0f1928b3e", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:03:04.698668707Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "959bdd509fa56040952c99c14d512c8a067fce18b2faeeae241f1ecde077743f", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 500000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:03:20.188186411Z" + } + ], + "resource_samples": [ + { + "monotonic": 455466.379024125, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "46.98%", + "Container": "7b230a73710c5a6a2ba381d102281ebdd211c4df7ecdbe859c62796e68180848", + "ID": "7b230a73710c", + "MemPerc": "31.01%", + "MemUsage": "79.38MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "3.57MB / 3.78MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "50.39%", + "Container": "466a9c57a700191613da1220099ba75caa787a64b4744611b8d09d04cd4ba5e4", + "ID": "466a9c57a700", + "MemPerc": "30.17%", + "MemUsage": "77.23MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "3.66MB / 3.89MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.91%", + "Container": "6295c582c2a0ca50e6fc93e17a84ed14a09919fbc46264d422fb83397b3a10fa", + "ID": "6295c582c2a0", + "MemPerc": "30.99%", + "MemUsage": "79.34MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "3.63MB / 3.86MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "50.81%", + "Container": "1b9796815fe30621cdc589ea8eb741e712dd354df8931ef74f9a2ef0f1928b3e", + "ID": "1b9796815fe3", + "MemPerc": "29.24%", + "MemUsage": "74.86MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "3.68MB / 3.92MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.30%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.367MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "1.94MB / 3.55MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "10.12%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.29%", + "MemUsage": "13.17MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "17.3MB / 18.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "38.68%", + "Container": "959bdd509fa56040952c99c14d512c8a067fce18b2faeeae241f1ecde077743f", + "ID": "959bdd509fa5", + "MemPerc": "12.32%", + "MemUsage": "94.59MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "3.91MB / 3.15MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455468.392502291, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "46.79%", + "Container": "7b230a73710c5a6a2ba381d102281ebdd211c4df7ecdbe859c62796e68180848", + "ID": "7b230a73710c", + "MemPerc": "26.08%", + "MemUsage": "66.78MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "4.99MB / 5.33MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "43.23%", + "Container": "466a9c57a700191613da1220099ba75caa787a64b4744611b8d09d04cd4ba5e4", + "ID": "466a9c57a700", + "MemPerc": "26.09%", + "MemUsage": "66.79MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "4.98MB / 5.31MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "43.48%", + "Container": "6295c582c2a0ca50e6fc93e17a84ed14a09919fbc46264d422fb83397b3a10fa", + "ID": "6295c582c2a0", + "MemPerc": "25.95%", + "MemUsage": "66.42MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "4.98MB / 5.32MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "43.16%", + "Container": "1b9796815fe30621cdc589ea8eb741e712dd354df8931ef74f9a2ef0f1928b3e", + "ID": "1b9796815fe3", + "MemPerc": "26.01%", + "MemUsage": "66.59MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "4.99MB / 5.33MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.87%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.63%", + "MemUsage": "3.371MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "2.2MB / 4.05MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "11.16%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.92%", + "MemUsage": "12.69MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "20.6MB / 22.1MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "44.61%", + "Container": "959bdd509fa56040952c99c14d512c8a067fce18b2faeeae241f1ecde077743f", + "ID": "959bdd509fa5", + "MemPerc": "12.54%", + "MemUsage": "96.34MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "8.14MB / 6.61MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455470.405836208, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "50.30%", + "Container": "7b230a73710c5a6a2ba381d102281ebdd211c4df7ecdbe859c62796e68180848", + "ID": "7b230a73710c", + "MemPerc": "27.32%", + "MemUsage": "69.93MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "6.23MB / 6.65MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "49.82%", + "Container": "466a9c57a700191613da1220099ba75caa787a64b4744611b8d09d04cd4ba5e4", + "ID": "466a9c57a700", + "MemPerc": "27.01%", + "MemUsage": "69.15MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "6.2MB / 6.6MB", + "PIDs": "44" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "52.91%", + "Container": "6295c582c2a0ca50e6fc93e17a84ed14a09919fbc46264d422fb83397b3a10fa", + "ID": "6295c582c2a0", + "MemPerc": "26.88%", + "MemUsage": "68.8MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "6.27MB / 6.71MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "47.40%", + "Container": "1b9796815fe30621cdc589ea8eb741e712dd354df8931ef74f9a2ef0f1928b3e", + "ID": "1b9796815fe3", + "MemPerc": "32.01%", + "MemUsage": "81.93MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "6.23MB / 6.64MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.19%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.379MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "2.44MB / 4.51MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "9.61%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.51%", + "MemUsage": "13.45MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "22.7MB / 24.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "38.21%", + "Container": "959bdd509fa56040952c99c14d512c8a067fce18b2faeeae241f1ecde077743f", + "ID": "959bdd509fa5", + "MemPerc": "12.77%", + "MemUsage": "98.11MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "12MB / 9.75MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455472.420390708, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "41.74%", + "Container": "7b230a73710c5a6a2ba381d102281ebdd211c4df7ecdbe859c62796e68180848", + "ID": "7b230a73710c", + "MemPerc": "28.53%", + "MemUsage": "73.04MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "7.56MB / 8.08MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "38.87%", + "Container": "466a9c57a700191613da1220099ba75caa787a64b4744611b8d09d04cd4ba5e4", + "ID": "466a9c57a700", + "MemPerc": "28.56%", + "MemUsage": "73.11MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "7.56MB / 8.06MB", + "PIDs": "44" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "41.51%", + "Container": "6295c582c2a0ca50e6fc93e17a84ed14a09919fbc46264d422fb83397b3a10fa", + "ID": "6295c582c2a0", + "MemPerc": "28.46%", + "MemUsage": "72.85MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "7.55MB / 8.08MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "41.91%", + "Container": "1b9796815fe30621cdc589ea8eb741e712dd354df8931ef74f9a2ef0f1928b3e", + "ID": "1b9796815fe3", + "MemPerc": "28.19%", + "MemUsage": "72.16MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "7.56MB / 8.08MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.46%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.62%", + "MemUsage": "3.359MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "2.69MB / 5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "9.60%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.76%", + "MemUsage": "12.49MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "25MB / 26.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "39.76%", + "Container": "959bdd509fa56040952c99c14d512c8a067fce18b2faeeae241f1ecde077743f", + "ID": "959bdd509fa5", + "MemPerc": "12.91%", + "MemUsage": "99.13MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "16.1MB / 13.2MB", + "PIDs": "38" + } + ] + } + ] + } +] diff --git a/evidence/scaling-pilot.json b/evidence/scaling-pilot.json new file mode 100644 index 00000000..b9c0a446 --- /dev/null +++ b/evidence/scaling-pilot.json @@ -0,0 +1,24 @@ +{ + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 300, + "requested_duration_seconds": 6.0, + "elapsed_including_drain_seconds": 6.123, + "scheduled": 1800, + "attempted": 1167, + "successful": 1167, + "errors": {}, + "dropped": 633, + "successful_rps": 190.594, + "attempted_rps": 190.594, + "latency_success_ms": { + "p50": 53.814, + "p95": 240.729, + "p99": 288.121 + }, + "max_schedule_lag_ms": 312.744, + "instances": { + "02ae80f9-f61b-4964-ab16-b836523904d3": 583, + "52e57fca-356b-4ffc-8446-60f6e871d1c8": 584 + }, + "concurrency_cap": 128 +} diff --git a/evidence/scaling-reversal.json b/evidence/scaling-reversal.json new file mode 100644 index 00000000..ed92599f --- /dev/null +++ b/evidence/scaling-reversal.json @@ -0,0 +1,1123 @@ +{ + "runs": [ + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6, + "elapsed_including_drain_seconds": 6.2758, + "scheduled": 5400, + "attempted": 2585, + "successful": 2580, + "errors": { + "503": 5 + }, + "dropped": 2815, + "dropped_scheduler": 0, + "dropped_concurrency": 2815, + "driver_cpu_seconds": 0.712342, + "driver_cpu_fraction_one_core": 0.11350725490002163, + "successful_rps": 411.104, + "attempted_rps": 411.901, + "latency_success_ms": { + "p50": 297.831, + "p95": 497.705, + "p99": 632.68 + }, + "max_schedule_lag_ms": 2.156, + "instances": { + "fe871d7b-b13a-42f6-a61d-70e7b1111fb7": 644, + "62f00416-932c-44ad-8f59-c646f6379eba": 647, + "8095e6fe-388f-46a4-b707-c30fa7263e93": 644, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 645 + }, + "concurrency_cap": 128, + "configuration": "db-reverted", + "repeat": 1, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "0d9be17896ec9761ec41357105f2d70f0ab2a915cc84da9db3b756e93dc07fbf", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:11:53.902450026Z" + }, + { + "id": "b61cd8edc9b4e8701ba60608f19088fab8e9a3176e54d4d75392994e2b2dc783", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:11:53.822225113Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "e34fdad57fe670cec6ad5d5f24e6c7f1b0d5a010631b46fad485facdd0e1888c", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:11:50.135236244Z" + } + ], + "resource_samples": [ + { + "monotonic": 455981.6443385, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "33.24%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.50%", + "MemUsage": "78.08MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "76.9MB / 84.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "15.84%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.17%", + "MemUsage": "74.68MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "52.8MB / 57.9MB", + "PIDs": "41" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "34.65%", + "Container": "0d9be17896ec9761ec41357105f2d70f0ab2a915cc84da9db3b756e93dc07fbf", + "ID": "0d9be17896ec", + "MemPerc": "23.51%", + "MemUsage": "60.19MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "497kB / 526kB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "34.77%", + "Container": "b61cd8edc9b4e8701ba60608f19088fab8e9a3176e54d4d75392994e2b2dc783", + "ID": "b61cd8edc9b4", + "MemPerc": "23.56%", + "MemUsage": "60.32MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "499kB / 526kB", + "PIDs": "44" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.86%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.391MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "19.4MB / 36.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.15%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.42%", + "MemUsage": "13.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "159MB / 169MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "24.65%", + "Container": "e34fdad57fe670cec6ad5d5f24e6c7f1b0d5a010631b46fad485facdd0e1888c", + "ID": "e34fdad57fe6", + "MemPerc": "12.77%", + "MemUsage": "98.07MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "1.61MB / 1.31MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455983.656225125, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.97%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.48%", + "MemUsage": "78.03MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "77.6MB / 85MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.56%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.25%", + "MemUsage": "74.88MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "53.8MB / 58.9MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.53%", + "Container": "0d9be17896ec9761ec41357105f2d70f0ab2a915cc84da9db3b756e93dc07fbf", + "ID": "0d9be17896ec", + "MemPerc": "24.00%", + "MemUsage": "61.43MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "1.19MB / 1.25MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "23.54%", + "Container": "b61cd8edc9b4e8701ba60608f19088fab8e9a3176e54d4d75392994e2b2dc783", + "ID": "b61cd8edc9b4", + "MemPerc": "24.17%", + "MemUsage": "61.88MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "1.18MB / 1.23MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.88%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.64%", + "MemUsage": "3.383MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "19.6MB / 36.4MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.28%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.42%", + "MemUsage": "13.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "160MB / 170MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "24.28%", + "Container": "e34fdad57fe670cec6ad5d5f24e6c7f1b0d5a010631b46fad485facdd0e1888c", + "ID": "e34fdad57fe6", + "MemPerc": "13.06%", + "MemUsage": "100.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "3.61MB / 3.05MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455985.668590625, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.02%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.49%", + "MemUsage": "78.06MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "78.3MB / 85.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.91%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.23%", + "MemUsage": "74.83MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "54.6MB / 59.8MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "29.76%", + "Container": "0d9be17896ec9761ec41357105f2d70f0ab2a915cc84da9db3b756e93dc07fbf", + "ID": "0d9be17896ec", + "MemPerc": "24.82%", + "MemUsage": "63.54MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "1.91MB / 2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "28.83%", + "Container": "b61cd8edc9b4e8701ba60608f19088fab8e9a3176e54d4d75392994e2b2dc783", + "ID": "b61cd8edc9b4", + "MemPerc": "25.06%", + "MemUsage": "64.14MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "1.89MB / 1.96MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.95%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.391MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "19.7MB / 36.7MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.66%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.41%", + "MemUsage": "13.32MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "161MB / 172MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "24.87%", + "Container": "e34fdad57fe670cec6ad5d5f24e6c7f1b0d5a010631b46fad485facdd0e1888c", + "ID": "e34fdad57fe6", + "MemPerc": "13.42%", + "MemUsage": "103.1MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "5.77MB / 4.91MB", + "PIDs": "44" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6, + "elapsed_including_drain_seconds": 6.2592, + "scheduled": 5400, + "attempted": 2951, + "successful": 2951, + "errors": {}, + "dropped": 2449, + "dropped_scheduler": 0, + "dropped_concurrency": 2449, + "driver_cpu_seconds": 1.2540499999999999, + "driver_cpu_fraction_one_core": 0.200352953758204, + "successful_rps": 471.464, + "attempted_rps": 471.464, + "latency_success_ms": { + "p50": 222.873, + "p95": 561.598, + "p99": 599.631 + }, + "max_schedule_lag_ms": 5.335, + "instances": { + "8095e6fe-388f-46a4-b707-c30fa7263e93": 739, + "fe871d7b-b13a-42f6-a61d-70e7b1111fb7": 739, + "62f00416-932c-44ad-8f59-c646f6379eba": 737, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 736 + }, + "concurrency_cap": 128, + "configuration": "db-reverted", + "repeat": 2, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "0d9be17896ec9761ec41357105f2d70f0ab2a915cc84da9db3b756e93dc07fbf", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:11:53.902450026Z" + }, + { + "id": "b61cd8edc9b4e8701ba60608f19088fab8e9a3176e54d4d75392994e2b2dc783", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:11:53.822225113Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "e34fdad57fe670cec6ad5d5f24e6c7f1b0d5a010631b46fad485facdd0e1888c", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:11:50.135236244Z" + } + ], + "resource_samples": [ + { + "monotonic": 455987.685633291, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "33.60%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "34.13%", + "MemUsage": "87.36MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "79MB / 86.5MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.64%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.24%", + "MemUsage": "74.87MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "55.3MB / 60.5MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.43%", + "Container": "0d9be17896ec9761ec41357105f2d70f0ab2a915cc84da9db3b756e93dc07fbf", + "ID": "0d9be17896ec", + "MemPerc": "25.58%", + "MemUsage": "65.49MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "2.6MB / 2.72MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.06%", + "Container": "b61cd8edc9b4e8701ba60608f19088fab8e9a3176e54d4d75392994e2b2dc783", + "ID": "b61cd8edc9b4", + "MemPerc": "25.64%", + "MemUsage": "65.65MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "2.6MB / 2.71MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.93%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.395MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "19.9MB / 37MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.63%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.42%", + "MemUsage": "13.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "162MB / 173MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 225kB", + "CPUPerc": "25.04%", + "Container": "e34fdad57fe670cec6ad5d5f24e6c7f1b0d5a010631b46fad485facdd0e1888c", + "ID": "e34fdad57fe6", + "MemPerc": "13.38%", + "MemUsage": "102.7MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "7.91MB / 6.76MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455989.709916583, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "27.76%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.48%", + "MemUsage": "78.03MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "79.8MB / 87.3MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "35.26%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.25%", + "MemUsage": "74.87MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "56MB / 61.2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "30.94%", + "Container": "0d9be17896ec9761ec41357105f2d70f0ab2a915cc84da9db3b756e93dc07fbf", + "ID": "0d9be17896ec", + "MemPerc": "26.16%", + "MemUsage": "66.96MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "3.35MB / 3.51MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "27.89%", + "Container": "b61cd8edc9b4e8701ba60608f19088fab8e9a3176e54d4d75392994e2b2dc783", + "ID": "b61cd8edc9b4", + "MemPerc": "26.42%", + "MemUsage": "67.64MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "3.29MB / 3.41MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.96%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.67%", + "MemUsage": "3.422MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "20MB / 37.2MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.74%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.42%", + "MemUsage": "13.33MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "163MB / 174MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "25.54%", + "Container": "e34fdad57fe670cec6ad5d5f24e6c7f1b0d5a010631b46fad485facdd0e1888c", + "ID": "e34fdad57fe6", + "MemPerc": "13.57%", + "MemUsage": "104.3MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "10.1MB / 8.64MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455991.723107583, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "35.39%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.60%", + "MemUsage": "78.32MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "80.4MB / 88MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "27.71%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.24%", + "MemUsage": "74.87MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "56.7MB / 62MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "39.02%", + "Container": "0d9be17896ec9761ec41357105f2d70f0ab2a915cc84da9db3b756e93dc07fbf", + "ID": "0d9be17896ec", + "MemPerc": "26.26%", + "MemUsage": "67.21MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "4.07MB / 4.26MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "34.62%", + "Container": "b61cd8edc9b4e8701ba60608f19088fab8e9a3176e54d4d75392994e2b2dc783", + "ID": "b61cd8edc9b4", + "MemPerc": "30.01%", + "MemUsage": "76.82MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "4MB / 4.15MB", + "PIDs": "46" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.95%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.66%", + "MemUsage": "3.41MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "20.2MB / 37.5MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.74%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.42%", + "MemUsage": "13.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "164MB / 175MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "25.00%", + "Container": "e34fdad57fe670cec6ad5d5f24e6c7f1b0d5a010631b46fad485facdd0e1888c", + "ID": "e34fdad57fe6", + "MemPerc": "13.66%", + "MemUsage": "104.9MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "12.2MB / 10.5MB", + "PIDs": "38" + } + ] + } + ] + }, + { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": 900, + "requested_duration_seconds": 6, + "elapsed_including_drain_seconds": 6.2912, + "scheduled": 5400, + "attempted": 2928, + "successful": 2928, + "errors": {}, + "dropped": 2472, + "dropped_scheduler": 0, + "dropped_concurrency": 2472, + "driver_cpu_seconds": 1.3145570000000002, + "driver_cpu_fraction_one_core": 0.20895186471310248, + "successful_rps": 465.411, + "attempted_rps": 465.411, + "latency_success_ms": { + "p50": 181.871, + "p95": 710.289, + "p99": 795.275 + }, + "max_schedule_lag_ms": 5.86, + "instances": { + "8095e6fe-388f-46a4-b707-c30fa7263e93": 733, + "e6d47a9f-86c9-46d5-ae8d-42304131802b": 731, + "62f00416-932c-44ad-8f59-c646f6379eba": 732, + "fe871d7b-b13a-42f6-a61d-70e7b1111fb7": 732 + }, + "concurrency_cap": 128, + "configuration": "db-reverted", + "repeat": 3, + "actual_containers": [ + { + "id": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:07:14.313313121Z" + }, + { + "id": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:08:22.83720228Z" + }, + { + "id": "0d9be17896ec9761ec41357105f2d70f0ab2a915cc84da9db3b756e93dc07fbf", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:11:53.902450026Z" + }, + { + "id": "b61cd8edc9b4e8701ba60608f19088fab8e9a3176e54d4d75392994e2b2dc783", + "service": "api", + "image_id": "sha256:063daf6c19e2f71aa3de09aabf8f242a5ce1ef9e1a06e3d5084881b3d20df868", + "image": "mtusi-vasilev:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "started_at": "2026-11-06T15:11:53.822225113Z" + }, + { + "id": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "service": "cache", + "image_id": "sha256:d827e7f7552cdee40cc7482dbae9da020f42bc47669af6f71182a4ef76a22773", + "image": "valkey/valkey:8.1.3-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:08.17509564Z" + }, + { + "id": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "service": "lb", + "image_id": "sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "image": "haproxy:3.2-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "started_at": "2026-11-06T14:55:17.600378891Z" + }, + { + "id": "e34fdad57fe670cec6ad5d5f24e6c7f1b0d5a010631b46fad485facdd0e1888c", + "service": "postgres", + "image_id": "sha256:742f40ea20b9ff2ff31db5458d127452988a2164df9e17441e191f3b72252193", + "image": "postgres:17.10-alpine", + "nano_cpus": 250000000, + "memory_bytes": 805306368, + "started_at": "2026-11-06T15:11:50.135236244Z" + } + ], + "resource_samples": [ + { + "monotonic": 455993.732417791, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "29.02%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.50%", + "MemUsage": "78.07MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "81.2MB / 88.7MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "27.93%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.28%", + "MemUsage": "74.95MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "57.3MB / 62.6MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.12%", + "Container": "0d9be17896ec9761ec41357105f2d70f0ab2a915cc84da9db3b756e93dc07fbf", + "ID": "0d9be17896ec", + "MemPerc": "26.26%", + "MemUsage": "67.23MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "4.8MB / 5.03MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "25.31%", + "Container": "b61cd8edc9b4e8701ba60608f19088fab8e9a3176e54d4d75392994e2b2dc783", + "ID": "b61cd8edc9b4", + "MemPerc": "26.42%", + "MemUsage": "67.63MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "4.79MB / 5MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.98%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.68%", + "MemUsage": "3.43MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "20.3MB / 37.8MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.43%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.42%", + "MemUsage": "13.33MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "165MB / 177MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 258kB", + "CPUPerc": "25.00%", + "Container": "e34fdad57fe670cec6ad5d5f24e6c7f1b0d5a010631b46fad485facdd0e1888c", + "ID": "e34fdad57fe6", + "MemPerc": "13.83%", + "MemUsage": "106.2MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "14.3MB / 12.3MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455995.744431958, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "30.03%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.50%", + "MemUsage": "78.07MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "81.9MB / 89.5MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "29.46%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.54%", + "MemUsage": "75.63MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "58MB / 63.3MB", + "PIDs": "51" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "36.41%", + "Container": "0d9be17896ec9761ec41357105f2d70f0ab2a915cc84da9db3b756e93dc07fbf", + "ID": "0d9be17896ec", + "MemPerc": "26.64%", + "MemUsage": "68.2MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "5.46MB / 5.72MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "39.12%", + "Container": "b61cd8edc9b4e8701ba60608f19088fab8e9a3176e54d4d75392994e2b2dc783", + "ID": "b61cd8edc9b4", + "MemPerc": "26.61%", + "MemUsage": "68.11MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "5.48MB / 5.72MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.99%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.67%", + "MemUsage": "3.418MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "20.5MB / 38MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.74%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.42%", + "MemUsage": "13.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "166MB / 178MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "24.92%", + "Container": "e34fdad57fe670cec6ad5d5f24e6c7f1b0d5a010631b46fad485facdd0e1888c", + "ID": "e34fdad57fe6", + "MemPerc": "13.93%", + "MemUsage": "106.9MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "16.4MB / 14.1MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455997.757319291, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "22.92%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.49%", + "MemUsage": "78.05MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "82.6MB / 90.2MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "26.95%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.29%", + "MemUsage": "74.98MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "58.6MB / 64MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.85%", + "Container": "0d9be17896ec9761ec41357105f2d70f0ab2a915cc84da9db3b756e93dc07fbf", + "ID": "0d9be17896ec", + "MemPerc": "26.63%", + "MemUsage": "68.18MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "6.17MB / 6.46MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "24.90%", + "Container": "b61cd8edc9b4e8701ba60608f19088fab8e9a3176e54d4d75392994e2b2dc783", + "ID": "b61cd8edc9b4", + "MemPerc": "26.60%", + "MemUsage": "68.11MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "6.18MB / 6.45MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.93%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.67%", + "MemUsage": "3.418MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "20.6MB / 38.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "5.56%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "10.42%", + "MemUsage": "13.34MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "167MB / 179MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "24.50%", + "Container": "e34fdad57fe670cec6ad5d5f24e6c7f1b0d5a010631b46fad485facdd0e1888c", + "ID": "e34fdad57fe6", + "MemPerc": "14.00%", + "MemUsage": "107.6MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "18.5MB / 15.9MB", + "PIDs": "38" + } + ] + }, + { + "monotonic": 455999.770567333, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.13%", + "Container": "28cfd13a04e9cb7efc426277afa1d51f297898b266ff14d25de06d4e4047059c", + "ID": "28cfd13a04e9", + "MemPerc": "30.47%", + "MemUsage": "78MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-3", + "NetIO": "82.8MB / 90.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "17.02%", + "Container": "c07b53a5cb711745f634d4feb044e197e46923210e87d8d29a49a9736453d909", + "ID": "c07b53a5cb71", + "MemPerc": "29.23%", + "MemUsage": "74.84MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-4", + "NetIO": "59MB / 64.4MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.87%", + "Container": "0d9be17896ec9761ec41357105f2d70f0ab2a915cc84da9db3b756e93dc07fbf", + "ID": "0d9be17896ec", + "MemPerc": "26.61%", + "MemUsage": "68.13MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-5", + "NetIO": "6.38MB / 6.69MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "4.42%", + "Container": "b61cd8edc9b4e8701ba60608f19088fab8e9a3176e54d4d75392994e2b2dc783", + "ID": "b61cd8edc9b4", + "MemPerc": "26.58%", + "MemUsage": "68.05MiB / 256MiB", + "Name": "mtusi-vasilev-lab3-api-6", + "NetIO": "6.39MB / 6.68MB", + "PIDs": "45" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.18%", + "Container": "70f74d15b87ae6cb1da93075b8ad97bee9e84d1520bd8c02ea78c3e6561e79e6", + "ID": "70f74d15b87a", + "MemPerc": "2.65%", + "MemUsage": "3.391MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-cache-1", + "NetIO": "20.7MB / 38.3MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.34%", + "Container": "b22fb4be1076ad3b5beff1fbb0108832ee91ac7aac4cc85afab33c502cfb3d04", + "ID": "b22fb4be1076", + "MemPerc": "9.87%", + "MemUsage": "12.64MiB / 128MiB", + "Name": "mtusi-vasilev-lab3-lb-1", + "NetIO": "168MB / 180MB", + "PIDs": "5" + }, + { + "BlockIO": "0B / 422kB", + "CPUPerc": "0.36%", + "Container": "e34fdad57fe670cec6ad5d5f24e6c7f1b0d5a010631b46fad485facdd0e1888c", + "ID": "e34fdad57fe6", + "MemPerc": "14.03%", + "MemUsage": "107.8MiB / 768MiB", + "Name": "mtusi-vasilev-lab3-postgres-1", + "NetIO": "19.2MB / 16.5MB", + "PIDs": "38" + } + ] + } + ] + } + ] +} diff --git a/evidence/scaling-reversal.txt b/evidence/scaling-reversal.txt new file mode 100644 index 00000000..3cb99cc2 --- /dev/null +++ b/evidence/scaling-reversal.txt @@ -0,0 +1,91 @@ + Container mtusi-vasilev-lab3-cache-1 Running + Container mtusi-vasilev-lab3-api-3 Running + Container mtusi-vasilev-lab3-api-4 Running + Container mtusi-vasilev-lab3-lb-1 Running + Container mtusi-vasilev-lab3-api-6 Creating + Container mtusi-vasilev-lab3-api-5 Creating + Container mtusi-vasilev-lab3-postgres-1 Recreate + Container mtusi-vasilev-lab3-api-6 Created + Container mtusi-vasilev-lab3-api-5 Created + Container mtusi-vasilev-lab3-postgres-1 Recreated + Container mtusi-vasilev-lab3-postgres-1 Starting + Container mtusi-vasilev-lab3-postgres-1 Started + Container mtusi-vasilev-lab3-postgres-1 Waiting + Container mtusi-vasilev-lab3-postgres-1 Healthy + Container mtusi-vasilev-lab3-migrate-1 Starting + Container mtusi-vasilev-lab3-migrate-1 Started + Container mtusi-vasilev-lab3-migrate-1 Waiting + Container mtusi-vasilev-lab3-cache-1 Waiting + Container mtusi-vasilev-lab3-cache-1 Healthy + Container mtusi-vasilev-lab3-migrate-1 Exited + Container mtusi-vasilev-lab3-api-6 Starting + Container mtusi-vasilev-lab3-api-6 Started + Container mtusi-vasilev-lab3-api-5 Starting + Container mtusi-vasilev-lab3-api-5 Started + Container mtusi-vasilev-lab3-api-6 Waiting + Container mtusi-vasilev-lab3-api-5 Waiting + Container mtusi-vasilev-lab3-api-4 Waiting + Container mtusi-vasilev-lab3-api-3 Waiting + Container mtusi-vasilev-lab3-api-6 Healthy + Container mtusi-vasilev-lab3-api-5 Healthy + Container mtusi-vasilev-lab3-api-4 Healthy + Container mtusi-vasilev-lab3-api-3 Healthy + Container mtusi-vasilev-lab3-postgres-1 Waiting + Container mtusi-vasilev-lab3-cache-1 Waiting + Container mtusi-vasilev-lab3-migrate-1 Waiting + Container mtusi-vasilev-lab3-api-6 Waiting + Container mtusi-vasilev-lab3-api-5 Waiting + Container mtusi-vasilev-lab3-api-4 Waiting + Container mtusi-vasilev-lab3-api-3 Waiting + Container mtusi-vasilev-lab3-lb-1 Waiting + Container mtusi-vasilev-lab3-cache-1 Healthy + Container mtusi-vasilev-lab3-migrate-1 Exited + Container mtusi-vasilev-lab3-lb-1 Healthy + Container mtusi-vasilev-lab3-postgres-1 Healthy + Container mtusi-vasilev-lab3-api-6 Healthy + Container mtusi-vasilev-lab3-api-5 Healthy + Container mtusi-vasilev-lab3-api-4 Healthy + Container mtusi-vasilev-lab3-api-3 Healthy +{"repeat": 1, "successful_rps": 411.104, "dropped": 2815, "errors": {"503": 5}} +{"repeat": 2, "successful_rps": 471.464, "dropped": 2449, "errors": {}} +{"repeat": 3, "successful_rps": 465.411, "dropped": 2472, "errors": {}} + Container mtusi-vasilev-lab3-cache-1 Running + Container mtusi-vasilev-lab3-api-3 Running + Container mtusi-vasilev-lab3-api-4 Running + Container mtusi-vasilev-lab3-lb-1 Running + Container mtusi-vasilev-lab3-api-5 Stopping + Container mtusi-vasilev-lab3-postgres-1 Recreate + Container mtusi-vasilev-lab3-api-6 Stopping + Container mtusi-vasilev-lab3-postgres-1 Recreated + Container mtusi-vasilev-lab3-api-5 Stopped + Container mtusi-vasilev-lab3-api-5 Removing + Container mtusi-vasilev-lab3-api-5 Removed + Container mtusi-vasilev-lab3-api-6 Stopped + Container mtusi-vasilev-lab3-api-6 Removing + Container mtusi-vasilev-lab3-api-6 Removed + Container mtusi-vasilev-lab3-postgres-1 Starting + Container mtusi-vasilev-lab3-postgres-1 Started + Container mtusi-vasilev-lab3-postgres-1 Waiting + Container mtusi-vasilev-lab3-postgres-1 Healthy + Container mtusi-vasilev-lab3-migrate-1 Starting + Container mtusi-vasilev-lab3-migrate-1 Started + Container mtusi-vasilev-lab3-migrate-1 Waiting + Container mtusi-vasilev-lab3-cache-1 Waiting + Container mtusi-vasilev-lab3-cache-1 Healthy + Container mtusi-vasilev-lab3-migrate-1 Exited + Container mtusi-vasilev-lab3-api-4 Waiting + Container mtusi-vasilev-lab3-api-3 Waiting + Container mtusi-vasilev-lab3-api-4 Healthy + Container mtusi-vasilev-lab3-api-3 Healthy + Container mtusi-vasilev-lab3-cache-1 Waiting + Container mtusi-vasilev-lab3-migrate-1 Waiting + Container mtusi-vasilev-lab3-api-4 Waiting + Container mtusi-vasilev-lab3-api-3 Waiting + Container mtusi-vasilev-lab3-lb-1 Waiting + Container mtusi-vasilev-lab3-postgres-1 Waiting + Container mtusi-vasilev-lab3-migrate-1 Exited + Container mtusi-vasilev-lab3-lb-1 Healthy + Container mtusi-vasilev-lab3-cache-1 Healthy + Container mtusi-vasilev-lab3-postgres-1 Healthy + Container mtusi-vasilev-lab3-api-4 Healthy + Container mtusi-vasilev-lab3-api-3 Healthy diff --git a/evidence/smoke-final.txt b/evidence/smoke-final.txt new file mode 100644 index 00000000..16a54ca3 --- /dev/null +++ b/evidence/smoke-final.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://127.0.0.1:8083" +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/tests-final.txt b/evidence/tests-final.txt new file mode 100644 index 00000000..d3f6ea76 --- /dev/null +++ b/evidence/tests-final.txt @@ -0,0 +1,4 @@ +BASE_URL=http://127.0.0.1:8083 uv run --locked pytest -q +........................................................................ [ 93%] +..... [100%] +77 passed in 26.61s diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg index ae5f764a..62b0a227 100644 --- a/infra/haproxy.cfg +++ b/infra/haproxy.cfg @@ -25,6 +25,8 @@ resolvers docker frontend public bind :8080 + http-request set-var(txn.lb_request_id) uuid() + http-request return status 503 content-type application/json lf-string '{"error":{"code":"unavailable","message":"No ready API","request_id":"%[var(txn.lb_request_id)]"}}' hdr X-Request-Id '%[var(txn.lb_request_id)]' if { nbsrv(apis) eq 0 } default_backend apis backend apis diff --git a/pyproject.toml b/pyproject.toml index 88cce7c2..703ce0ea 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,7 +5,15 @@ requires-python = ">=3.12,<3.13" dependencies = ["fastapi", "uvicorn", "psycopg[binary,pool]", "redis", "argon2-cffi"] [dependency-groups] -dev = ["pytest", "httpx", "ruff", "openapi-spec-validator", "jsonschema"] +dev = [ + "pytest", + "httpx", + "ruff", + "openapi-spec-validator", + "jsonschema", + "matplotlib==3.10.8", + "aiohttp==3.13.3", +] [tool.ruff] target-version = "py312" diff --git a/research/README.md b/research/README.md new file mode 100644 index 00000000..ee1285bb --- /dev/null +++ b/research/README.md @@ -0,0 +1,48 @@ +# Трек1 — цена масштабирования + +Гипотеза: при общей ограниченной PostgreSQL рост числа API не даёт линейного роста подтверждённых записей. Выделение CPU общей БД должно повысить пропускную способность, если именно её квота является активным ограничением. + +## Повторение + +Из корня отдельного репозитория, без других нагрузок на Docker-хосте: + +```sh +make up +uv sync --locked --python 3.12 +uv run --locked python research/run.py --duration 6 --rates 100,400,900 --repeats 3 --output evidence/scaling-repeat.json +uv run --locked python research/analyze.py evidence/scaling-repeat.json +``` + +Скрипт создаёт синтетические данные. Существующие данные не удаляются. После опыта возвращает штатные2API,0.5CPU/256MiBкаждая, PostgreSQL1CPU/768MiB. Не запускайте одновременно тесты отказов, другие labs, backup или компиляцию. Сессия должна успеть остаться действительной на протяжении опыта. + +## Матрица + +1. Fixed-total: 1/2/4API, суммарно1CPU и1024MiB (1×1CPU/1024,2×0.5/512,4×0.25/256). +2. Growth: 1/2/4API, по0.5CPU/256MiB на процесс. +3. Controlled improvement: те же4API по0.5CPU/256MiB; CPU PostgreSQL0.25→0.5, RAM768MiB неизменна. + +БД в исходной матрице **намеренно** ограничена0.25CPU, чтобы экспериментально установить её ресурсную границу. Это не утверждение о максимальной производительности PostgreSQL или штатного стенда. + +Для каждой конфигурации offered rates100/400/900POST/s, три повтора по6s, порядок скоростей чередуется. Fresh chat на каждый прогон; одинаковые пользователь, авторизация, payload и семантика уникальных Idempotency-Key. Короткая история растёт внутри прогона; накопление строк в общей БД и checkpoint могут влиять на результат. + +## Генератор и метрики + +Собственный asyncio/aiohttp open-loop генератор с keepalive. Планирует определённое число запросов по времени, не ждёт окончания предыдущего. При128in-flight или отставании планировщика>250ms слот считается dropped, скрытая бесконечная очередь не создаётся. Таймаут6s; прозрачных повторов нет. + +Сохраняются scheduled, attempted, successful201, ошибки по классам/HTTPкоду, dropped, schedulerlag, successfulRPS и attemptedRPS отдельно. RPS считается по реальному времени, включающему завершение отправленных запросов. Percentiles включают только успешные запросы, поэтому при ошибках/дропах их нельзя читать отдельно от этих счётчиков. + +Docker inspect сохраняет actual CPU/RAM каждой API и БД, проверяются точные значения и число реплик. Docker stats сохраняет исходные временные samples всех сервисов. CPU складывается по API на одном timestamp, память тоже суммируется, затем агрегируется — не усредняется между репликами. + +## Ограничения + +Один Docker Desktop хост, короткие локальные серии и ограниченный генератор. Schedulerlag/drops ограничивают интерпретацию offered ceiling. Для вывода о DBquota нужны совместно: достигнутая CPUквота БД, плато при ростеAPI/нагрузки и контролируемое улучшение при изменении **только** CPU БД. Внешнюю сеть, отказ узла, репликацию БД, промышленный SLA и exactly-once доставку опыт не доказывает. + +Первичные источники: [HAProxy3.2](https://docs.haproxy.org/3.2/configuration.html), [Compose service specification](https://docs.docker.com/reference/compose-file/services/). + +## Калибровка генератора + +HTTPxpilot при300offered/s показал schedulerlag312ms и633drops. Он исключён из основной матрицы. В окончательном генераторе aiohttp при900offered/s на4API driverCPU составлял0.174/0.316одногоядра, scheduler drops0; рост PGquota0.25→0.5 дал380.165→879.395successfulRPS. Это калибровка, отдельная от63измерений основной матрицы; сырые pilotфайлы сохранены. + +## Дополнительный обратный контроль + +После основной матрицы `uv run --locked python research/reversal.py` возвращает PostgreSQL0.25CPUпри техже4API, выполняет3×6sна900offered/s и восстанавливает штатный стенд. Результат отдельно в evidence/scaling-reversal.json, в63основных прогона он не включается. После основного опыта CPUконтроль далмедиану465.411RPSпротив881.06при0.5CPU, что снижает риск объяснить выигрыш только поздним прогревом. diff --git a/research/analyze.py b/research/analyze.py new file mode 100644 index 00000000..5f4b9390 --- /dev/null +++ b/research/analyze.py @@ -0,0 +1,166 @@ +"""Summarize successes separately from offered/attempted requests and sum replica resources.""" + +import json +import re +import statistics +import sys +from collections import defaultdict +from pathlib import Path + + +def memory_bytes(text): + value, unit = re.fullmatch(r"([0-9.]+)([A-Za-z]+)", text.strip()).groups() + factors = { + "B": 1, + "KiB": 1024, + "MiB": 1024**2, + "GiB": 1024**3, + "kB": 1000, + "MB": 1000**2, + "GB": 1000**3, + } + return float(value) * factors[unit] + + +def resource_summary(run): + cpu, ram, db_cpu, lb_cpu = [], [], [], [] + by_id = {c["id"][:12]: c["service"] for c in run["actual_containers"]} + for sample in run["resource_samples"]: + api_cpu = api_ram = 0 + for row in sample["containers"]: + role = by_id.get(row["ID"][:12]) + percent = float(row["CPUPerc"].rstrip("%")) + if role == "api": + api_cpu += percent + api_ram += memory_bytes(row["MemUsage"].split("/")[0].strip()) + elif role == "postgres": + db_cpu.append(percent) + elif role == "lb": + lb_cpu.append(percent) + cpu.append(api_cpu) + ram.append(api_ram / 1024**2) + return { + "mean_api_cpu_percent_sum": statistics.mean(cpu) if cpu else None, + "max_api_memory_mib_sum": max(ram, default=0), + "mean_db_cpu_percent": statistics.mean(db_cpu) if db_cpu else None, + "mean_lb_cpu_percent": statistics.mean(lb_cpu) if lb_cpu else None, + } + + +def main(): + source = Path(sys.argv[1]) + data = json.loads(source.read_text()) + groups = defaultdict(list) + for run in data["runs"]: + assert run["scheduled"] == run["attempted"] + run["dropped"] + assert run["attempted"] == run["successful"] + sum(run["errors"].values()) + run["resources"] = resource_summary(run) + groups[run["configuration"], run["offered_rate"]].append(run) + rows = [] + for (name, rate), runs in groups.items(): + row = { + "configuration": name, + "offered_rate": rate, + "repeats": len(runs), + "median_successful_rps": statistics.median(r["successful_rps"] for r in runs), + "median_p95_ms": statistics.median(r["latency_success_ms"]["p95"] for r in runs), + "total_successful": sum(r["successful"] for r in runs), + "total_errors": sum(sum(r["errors"].values()) for r in runs), + "total_dropped": sum(r["dropped"] for r in runs), + "total_scheduler_dropped": sum(r["dropped_scheduler"] for r in runs), + "max_driver_cpu_fraction": max(r["driver_cpu_fraction_one_core"] for r in runs), + "total_scheduled": sum(r["scheduled"] for r in runs), + "median_db_cpu_percent": statistics.median( + r["resources"]["mean_db_cpu_percent"] for r in runs + ), + "median_api_cpu_percent_sum": statistics.median( + r["resources"]["mean_api_cpu_percent_sum"] for r in runs + ), + "max_api_memory_mib_sum": max(r["resources"]["max_api_memory_mib_sum"] for r in runs), + } + rows.append(row) + dest = source.with_name(source.stem + "-summary.json") + dest.write_text(json.dumps(rows, indent=2) + "\n") + text = [ + "# Scaling results", + "", + "CPU%: 100% means one logical CPU. Memory is summed Docker MemUsage, not heap RSS.", + "", + "|Configuration|Offered/s|Success/s median|p95 ms median|Errors total|Dropped total|DB CPU% median|API CPU% sum median|API peak MiB sum|", + "|---|---:|---:|---:|---:|---:|---:|---:|---:|", + ] + for row in rows: + text.append( + "|{configuration}|{offered_rate}|{median_successful_rps:.2f}|{median_p95_ms:.2f}|{total_errors}|{total_dropped}|{median_db_cpu_percent:.2f}|{median_api_cpu_percent_sum:.2f}|{max_api_memory_mib_sum:.2f}|".format( + **row + ) + ) + source.with_name(source.stem + "-summary.md").write_text("\n".join(text) + "\n") + import matplotlib + + matplotlib.use("Agg") + import matplotlib.pyplot as plt + + fig, axes = plt.subplots(1, 3, figsize=(15, 4), constrained_layout=True) + for ax, series in zip(axes[:2], ["fixed", "growth"], strict=True): + for name in [f"{series}-{n}" for n in [1, 2, 4]]: + points = sorted( + [r for r in rows if r["configuration"] == name], key=lambda r: r["offered_rate"] + ) + ax.plot( + [p["offered_rate"] for p in points], + [p["median_successful_rps"] for p in points], + "o-", + label=name, + ) + ax.set( + title=series + " API budgets", + xlabel="Offered requests/s", + ylabel="Successful requests/s", + ) + ax.grid(alpha=0.3) + ax.legend() + for name in ["growth-4", "db-improved"]: + points = sorted( + [r for r in rows if r["configuration"] == name], key=lambda r: r["offered_rate"] + ) + axes[2].plot( + [p["offered_rate"] for p in points], + [p["median_successful_rps"] for p in points], + "o-", + label=name, + ) + axes[2].set( + title="Controlled PostgreSQL CPU change", + xlabel="Offered requests/s", + ylabel="Successful requests/s", + ) + axes[2].grid(alpha=0.3) + axes[2].legend() + fig.savefig(source.with_name(source.stem + ".svg")) + fig.savefig(source.with_name(source.stem + ".png"), dpi=130) + plt.close(fig) + fig, axes = plt.subplots(1, 3, figsize=(15, 4), constrained_layout=True) + for name in ["growth-4", "db-improved"]: + points = sorted([r for r in rows if r["configuration"] == name], key=lambda r: r["offered_rate"]) + xs = [p["offered_rate"] for p in points] + axes[0].plot(xs, [p["median_db_cpu_percent"] for p in points], "o-", label=name) + axes[1].plot(xs, [p["max_driver_cpu_fraction"] * 100 for p in points], "o-", label=name) + axes[2].plot(xs, [p["total_dropped"] / p["total_scheduled"] * 100 for p in points], "o-", label=name) + axes[0].axhline(25, linestyle="--", color="gray", label="baseline quota25%") + axes[0].axhline(50, linestyle=":", color="gray", label="improved quota50%") + axes[0].set(title="PostgreSQL CPU", ylabel="CPU% (100%=one core)") + axes[1].set(title="Driver process CPU, maximum repeat", ylabel="CPU% (100%=one core)") + axes[2].set(title="Dropped scheduling slots", ylabel="Dropped / scheduled %") + for ax in axes: + ax.set_xlabel("Offered requests/s") + ax.grid(alpha=.3) + ax.legend() + fig.savefig(source.with_name(source.stem + "-resources.svg")) + fig.savefig(source.with_name(source.stem + "-resources.png"), dpi=130) + plt.close(fig) + print("\n".join(text)) + + +if __name__ == "__main__": + main() diff --git a/research/load.py b/research/load.py new file mode 100644 index 00000000..09069f62 --- /dev/null +++ b/research/load.py @@ -0,0 +1,132 @@ +"""Open-loop HTTP message writes; count attempts, successes, errors and drops separately.""" + +import asyncio +import json +import math +import time +import uuid +from collections import Counter + +import aiohttp + + +async def run_load(base, actor, chat_id, *, rate, duration, concurrency=128): + latencies, errors, instances = [], Counter(), Counter() + pending = set() + dropped = 0 + dropped_lag = dropped_concurrency = 0 + lag = [] + total_slots = int(rate * duration) + async with aiohttp.ClientSession( + base_url=base, + connector=aiohttp.TCPConnector(limit=concurrency), + timeout=aiohttp.ClientTimeout(total=6), + trust_env=False, + ) as client: + started = time.perf_counter() + cpu_started = time.process_time() + + async def request(index): + start = time.perf_counter() + try: + async with client.post( + f"/api/v1/chats/{chat_id}/messages", + headers={ + "Authorization": "Bearer " + actor["token"], + "Idempotency-Key": f"study-{uuid.uuid4().hex}", + }, + json={"text": f"synthetic-{index}"}, + ) as response: + await response.read() + if response.status == 201: + latencies.append(time.perf_counter() - start) + instances[response.headers.get("X-Instance-Id", "missing")] += 1 + else: + errors[str(response.status)] += 1 + except (aiohttp.ClientError, TimeoutError) as exc: + errors[type(exc).__name__] += 1 + + for index in range(total_slots): + scheduled = started + index / rate + await asyncio.sleep(max(0, scheduled - time.perf_counter())) + delay = time.perf_counter() - scheduled + lag.append(delay) + if delay > 0.25: + dropped += 1 + dropped_lag += 1 + continue + if len(pending) >= concurrency: + dropped += 1 + dropped_concurrency += 1 + continue + task = asyncio.create_task(request(index)) + pending.add(task) + task.add_done_callback(pending.discard) + await asyncio.gather(*pending) + elapsed = time.perf_counter() - started + latencies.sort() + + def percentile(p): + return ( + round(1000 * latencies[max(0, math.ceil(p * len(latencies)) - 1)], 3) + if latencies + else None + ) + + return { + "profile": "open-loop unique POST messages, no automatic retries", + "offered_rate": rate, + "requested_duration_seconds": duration, + "elapsed_including_drain_seconds": round(elapsed, 4), + "scheduled": total_slots, + "attempted": len(latencies) + sum(errors.values()), + "successful": len(latencies), + "errors": dict(errors), + "dropped": dropped, + "dropped_scheduler": dropped_lag, + "dropped_concurrency": dropped_concurrency, + "driver_cpu_seconds": time.process_time() - cpu_started, + "driver_cpu_fraction_one_core": (time.process_time() - cpu_started) / elapsed, + "successful_rps": round(len(latencies) / elapsed, 3), + "attempted_rps": round((len(latencies) + sum(errors.values())) / elapsed, 3), + "latency_success_ms": { + "p50": percentile(0.5), + "p95": percentile(0.95), + "p99": percentile(0.99), + }, + "max_schedule_lag_ms": round(max(lag, default=0) * 1000, 3), + "instances": dict(instances), + "concurrency_cap": concurrency, + } + + +if __name__ == "__main__": + import argparse + import sys + from pathlib import Path + + sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests")) + from client import Client + + parser = argparse.ArgumentParser() + parser.add_argument("--rate", type=int, default=300) + parser.add_argument("--duration", type=float, default=8) + parser.add_argument("--output") + args = parser.parse_args() + c = Client("http://127.0.0.1:8083") + actor = c.user("research") + chat = c.call( + "POST", + "/api/v1/chats", + 201, + actor=actor, + body={"title": "study", "member_ids": [actor["id"]]}, + schema="Chat", + )["json"] + result = asyncio.run( + run_load(c.base, actor, chat["id"], rate=args.rate, duration=args.duration) + ) + text = json.dumps(result, indent=2) + if args.output: + Path(args.output).write_text(text + "\n") + print(text) diff --git a/research/reversal.py b/research/reversal.py new file mode 100644 index 00000000..4845710b --- /dev/null +++ b/research/reversal.py @@ -0,0 +1,40 @@ +"""Return PostgreSQL to the original quota to check time/warm-cache confounding.""" +import asyncio +import json +import subprocess +import threading +from pathlib import Path + +from load import run_load +from run import ROOT, Client, configure, sample_services + + +def main(): + profile = {"name": "db-reverted", "replicas": 4, "api_cpu": .5, + "api_memory": "256m", "pg_cpu": .25} + rows = [] + try: + actual = configure(profile) + c = Client("http://127.0.0.1:8083") + actor = c.user("reversal") + for repeat in range(3): + chat = c.call("POST", "/api/v1/chats", 201, actor=actor, + body={"title": "reversal", "member_ids": [actor["id"]]}, schema="Chat")["json"] + samples, stop = [], threading.Event() + thread = threading.Thread(target=sample_services, args=(stop, samples, actual)) + thread.start() + result = asyncio.run(run_load(c.base, actor, chat["id"], rate=900, duration=6)) + stop.set() + thread.join() + result.update(configuration="db-reverted", repeat=repeat + 1, + actual_containers=actual, resource_samples=samples) + rows.append(result) + print(json.dumps({k: result[k] for k in ["repeat", "successful_rps", "dropped", "errors"]}), flush=True) + finally: + subprocess.run(["docker", "compose", "up", "-d", "--scale", "api=2", "--wait"], cwd=ROOT, check=True, + stdout=subprocess.DEVNULL) + Path(ROOT / "evidence/scaling-reversal.json").write_text(json.dumps({"runs": rows}, indent=2) + "\n") + + +if __name__ == "__main__": + main() diff --git a/research/run.py b/research/run.py new file mode 100644 index 00000000..b79850f2 --- /dev/null +++ b/research/run.py @@ -0,0 +1,225 @@ +"""Reproducible scaling matrix with actual quotas and service resource samples.""" + +import argparse +import asyncio +import hashlib +import json +import os +import platform +import subprocess +import sys +import threading +import time +from datetime import UTC, datetime +from pathlib import Path + +from load import run_load + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) +from client import Client # noqa: E402 + + +def command(args, *, env=None): + return subprocess.check_output(args, cwd=ROOT, env=env, text=True) + + +def inventory(): + ids = command(["docker", "compose", "ps", "-q"]).split() + result = [] + for cid in ids: + raw = json.loads(command(["docker", "inspect", cid]))[0] + result.append( + { + "id": cid, + "service": raw["Config"]["Labels"]["com.docker.compose.service"], + "image_id": raw["Image"], + "image": raw["Config"]["Image"], + "nano_cpus": raw["HostConfig"]["NanoCpus"], + "memory_bytes": raw["HostConfig"]["Memory"], + "started_at": raw["State"]["StartedAt"], + } + ) + return result + + +def sample_services(stop, samples, containers): + while not stop.is_set(): + raw = command( + [ + "docker", + "stats", + "--no-stream", + "--format", + "{{json .}}", + *[c["id"] for c in containers], + ] + ) + rows = [json.loads(line) for line in raw.splitlines() if line.strip()] + samples.append({"monotonic": time.monotonic(), "containers": rows}) + stop.wait(0.5) + + +def configure(profile): + env = { + **os.environ, + "API_REPLICAS": str(profile["replicas"]), + "API_CPUS": str(profile["api_cpu"]), + "API_MEMORY": profile["api_memory"], + "PG_CPUS": str(profile["pg_cpu"]), + "PG_MEMORY": "768m", + } + subprocess.run( + ["docker", "compose", "up", "-d", "--scale", "api=" + str(profile["replicas"]), "--wait"], + cwd=ROOT, + env=env, + check=True, + stdout=subprocess.DEVNULL, + ) + subprocess.run( + [sys.executable, "scripts/wait_replicas.py", str(profile["replicas"])], cwd=ROOT, check=True + ) + actual = inventory() + apis = [c for c in actual if c["service"] == "api"] + assert len(apis) == profile["replicas"] + assert all(c["nano_cpus"] == int(profile["api_cpu"] * 1e9) for c in apis) + assert all(c["memory_bytes"] == int(profile["api_memory"][:-1]) * 1024**2 for c in apis) + db = next(c for c in actual if c["service"] == "postgres") + assert db["nano_cpus"] == int(profile["pg_cpu"] * 1e9) + return actual + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--duration", type=float, default=6) + parser.add_argument("--rates", default="100,300,600") + parser.add_argument("--repeats", type=int, default=3) + parser.add_argument("--output", default="evidence/scaling.json") + args = parser.parse_args() + profiles = [] + for replicas in [1, 2, 4]: + profiles.append( + { + "name": f"fixed-{replicas}", + "series": "fixed", + "replicas": replicas, + "api_cpu": 1 / replicas, + "api_memory": f"{1024 // replicas}m", + "pg_cpu": 0.25, + } + ) + for replicas in [1, 2, 4]: + profiles.append( + { + "name": f"growth-{replicas}", + "series": "growth", + "replicas": replicas, + "api_cpu": 0.5, + "api_memory": "256m", + "pg_cpu": 0.25, + } + ) + profiles.append( + { + "name": "db-improved", + "series": "improvement", + "replicas": 4, + "api_cpu": 0.5, + "api_memory": "256m", + "pg_cpu": 0.5, + } + ) + source_manifest = { + str(p.relative_to(ROOT)): hashlib.sha256(p.read_bytes()).hexdigest() + for folder in ["src", "migrations"] + for p in sorted((ROOT / folder).rglob("*")) + if p.is_file() and "__pycache__" not in p.parts + } + report = { + "source_manifest": source_manifest, + "source_revision": command(["git", "rev-parse", "HEAD"]).strip(), + "started_at": datetime.now(UTC).isoformat(), + "host": platform.platform(), + "docker": json.loads(command(["docker", "info", "--format", "{{json .}}"])), + "profiles": profiles, + "runs": [], + "notes": [ + "PostgreSQL intentionally constrained to 0.25CPU to expose its resource boundary.", + "Open-loop scheduler drops if concurrency cap128 or lag>250ms; no hidden backlog.", + "Only successes enter latency percentiles; wall time includes draining requests.", + ], + } + # Keep only non-sensitive engine inventory fields. + report["docker"] = { + k: report["docker"].get(k) + for k in ["ServerVersion", "NCPU", "MemTotal", "Architecture", "OperatingSystem"] + } + dest = ROOT / args.output + dest.parent.mkdir(parents=True, exist_ok=True) + try: + c = Client("http://127.0.0.1:8083") + actor = c.user("study") + for profile in profiles: + actual = configure(profile) + for repeat in range(args.repeats): + rates = [int(x) for x in args.rates.split(",")] + if repeat % 2: + rates.reverse() + for rate in rates: + chat = c.call( + "POST", + "/api/v1/chats", + 201, + actor=actor, + body={"title": "synthetic-study", "member_ids": [actor["id"]]}, + schema="Chat", + )["json"] + samples, stop = [], threading.Event() + thread = threading.Thread( + target=sample_services, args=(stop, samples, actual), daemon=True + ) + thread.start() + result = asyncio.run( + run_load(c.base, actor, chat["id"], rate=rate, duration=args.duration) + ) + stop.set() + thread.join() + result.update( + { + "configuration": profile["name"], + "repeat": repeat + 1, + "actual_containers": actual, + "resource_samples": samples, + } + ) + report["runs"].append(result) + dest.write_text(json.dumps(report, indent=2) + "\n") + print( + json.dumps( + { + k: result[k] + for k in [ + "configuration", + "repeat", + "offered_rate", + "successful_rps", + "errors", + "dropped", + ] + } + ), + flush=True, + ) + finally: + subprocess.run( + ["docker", "compose", "up", "-d", "--scale", "api=2", "--wait"], + cwd=ROOT, + check=True, + stdout=subprocess.DEVNULL, + ) + report["ended_at"] = datetime.now(UTC).isoformat() + dest.write_text(json.dumps(report, indent=2) + "\n") + + +if __name__ == "__main__": + main() diff --git a/scripts/container_snapshot.py b/scripts/container_snapshot.py index 3c84fd55..8eb8a0fb 100644 --- a/scripts/container_snapshot.py +++ b/scripts/container_snapshot.py @@ -1,4 +1,5 @@ """Record non-secret container identity/lifecycle fields for restart evidence.""" + import json import subprocess import sys @@ -8,7 +9,14 @@ ids = subprocess.check_output(["docker", "compose", "ps", "-q"], text=True).spli rows = [] for cid in ids: raw = json.loads(subprocess.check_output(["docker", "inspect", cid], text=True))[0] - rows.append({"id": cid, "service": raw["Config"]["Labels"]["com.docker.compose.service"], - "image_id": raw["Image"], "started_at": raw["State"]["StartedAt"], - "cpu_quota": raw["HostConfig"]["NanoCpus"], "memory": raw["HostConfig"]["Memory"]}) + rows.append( + { + "id": cid, + "service": raw["Config"]["Labels"]["com.docker.compose.service"], + "image_id": raw["Image"], + "started_at": raw["State"]["StartedAt"], + "cpu_quota": raw["HostConfig"]["NanoCpus"], + "memory": raw["HostConfig"]["Memory"], + } + ) Path(sys.argv[1]).write_text(json.dumps(rows, indent=2) + "\n") diff --git a/scripts/stop_one.py b/scripts/stop_one.py index 8daf4e0c..82375d7b 100644 --- a/scripts/stop_one.py +++ b/scripts/stop_one.py @@ -1,4 +1,5 @@ """Map a process alias to its real container, then leave exactly it stopped.""" + import json import os import subprocess @@ -7,12 +8,22 @@ wanted = os.environ["TARGET_INSTANCE_ID"] ids = subprocess.check_output(["docker", "compose", "ps", "-q", "api"], text=True).split() for cid in ids: result = subprocess.run( - ["docker", "exec", cid, "python", "-c", - "import urllib.request; r=urllib.request.urlopen('http://127.0.0.1:8080/health/live'); print(r.headers['X-Instance-Id'])"], - text=True, capture_output=True, check=False, + [ + "docker", + "exec", + cid, + "python", + "-c", + "import urllib.request; r=urllib.request.urlopen('http://127.0.0.1:8080/health/live'); print(r.headers['X-Instance-Id'])", + ], + text=True, + capture_output=True, + check=False, ) if result.returncode == 0 and result.stdout.strip() == wanted: - subprocess.run(["docker", "stop", "--time", "8", cid], check=True, stdout=subprocess.DEVNULL) + subprocess.run( + ["docker", "stop", "--time", "8", cid], check=True, stdout=subprocess.DEVNULL + ) print(json.dumps({"stopped_container": cid, "instance_id": wanted})) break else: diff --git a/scripts/verify_lb_unavailable.py b/scripts/verify_lb_unavailable.py new file mode 100644 index 00000000..3f02b819 --- /dev/null +++ b/scripts/verify_lb_unavailable.py @@ -0,0 +1,46 @@ +"""Check the LB's own safe JSON error when every API is stopped, then recover.""" +import json +import subprocess +import sys +import time +import urllib.error +import urllib.request +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) +from client import Client + + +def main(): + c = Client("http://127.0.0.1:8083") + actor = c.user("lbdown") + subprocess.run(["docker", "compose", "stop", "api"], cwd=ROOT, check=True) + try: + time.sleep(4) + request = urllib.request.Request(c.base + "/api/v1/users/me", + headers={"Authorization": "Bearer " + actor["token"]}) + try: + response = urllib.request.urlopen(request, timeout=3) + except urllib.error.HTTPError as exc: + response = exc + with response: + body = json.loads(response.read()) + result = {"status": response.code, "body": body, + "request_id": response.headers.get("X-Request-Id"), + "instance_id": response.headers.get("X-Instance-Id")} + assert result["status"] == 503 + assert body["error"]["code"] == "unavailable" + assert result["request_id"] and body["error"]["request_id"] == result["request_id"] + assert result["instance_id"] is None + finally: + subprocess.run(["docker", "compose", "start", "api"], cwd=ROOT, check=True) + subprocess.run([sys.executable, "scripts/wait_replicas.py", "2"], cwd=ROOT, check=True) + c.call("GET", "/api/v1/users/me", actor=actor, schema="User") + result["recovered_existing_session"] = True + (ROOT / "evidence/lb-no-ready-api.json").write_text(json.dumps(result, indent=2) + "\n") + print(json.dumps(result, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/scripts/verify_readiness.py b/scripts/verify_readiness.py index 7920ec46..ed1b088f 100644 --- a/scripts/verify_readiness.py +++ b/scripts/verify_readiness.py @@ -1,4 +1,5 @@ """A live process with lost DB network must be excluded by the LB.""" + import json import subprocess import sys @@ -38,9 +39,14 @@ print(json.dumps({'status':r.code,'alias':r.headers['X-Instance-Id']}))""" alias = response["headers"]["X-Instance-Id"] assert alias != initial["alias"] observations.append(alias) - result = {"target": target, "failed_instance": initial["alias"], "direct_readiness": 503, - "seconds_until_verification": time.monotonic() - started, - "lb_successful_requests": len(observations), "lb_instances": sorted(set(observations))} + result = { + "target": target, + "failed_instance": initial["alias"], + "direct_readiness": 503, + "seconds_until_verification": time.monotonic() - started, + "lb_successful_requests": len(observations), + "lb_instances": sorted(set(observations)), + } finally: cmd("docker", "network", "connect", "--alias", "api", backend, target) subprocess.run([sys.executable, "scripts/wait_replicas.py", "2"], cwd=ROOT, check=True) diff --git a/scripts/verify_replicas.py b/scripts/verify_replicas.py index ecb84282..45acf1bd 100644 --- a/scripts/verify_replicas.py +++ b/scripts/verify_replicas.py @@ -1,4 +1,5 @@ """Stop each real API process under traffic; retain confirmed writes and source aliases.""" + import json import os import subprocess @@ -19,10 +20,17 @@ def compose(*args): def aliases(): result = {} for cid in compose("ps", "-q", "api").split(): - alias = subprocess.check_output([ - "docker", "exec", cid, "python", "-c", - "import urllib.request; print(urllib.request.urlopen('http://127.0.0.1:8080/health/live').headers['X-Instance-Id'])", - ], text=True).strip() + alias = subprocess.check_output( + [ + "docker", + "exec", + cid, + "python", + "-c", + "import urllib.request; print(urllib.request.urlopen('http://127.0.0.1:8080/health/live').headers['X-Instance-Id'])", + ], + text=True, + ).strip() result[cid] = alias return result @@ -43,8 +51,13 @@ def main(): while not stop.is_set(): try: response = c.message(actor, chat, "failover-proof") - successful.append({"at": time.monotonic(), "id": response["json"]["id"], - "instance": response["headers"]["X-Instance-Id"]}) + successful.append( + { + "at": time.monotonic(), + "id": response["json"]["id"], + "instance": response["headers"]["X-Instance-Id"], + } + ) except Failure: errors.append(time.monotonic()) @@ -53,8 +66,12 @@ def main(): thread.start() time.sleep(1) stopped_at = time.monotonic() - subprocess.run(["scripts/stop-one.sh"], cwd=ROOT, - env={**os.environ, "TARGET_INSTANCE_ID": target_alias}, check=True) + subprocess.run( + ["scripts/stop-one.sh"], + cwd=ROOT, + env={**os.environ, "TARGET_INSTANCE_ID": target_alias}, + check=True, + ) time.sleep(4) stop.set() thread.join() @@ -62,14 +79,22 @@ def main(): after = [x for x in successful if x["at"] > stopped_at] assert after and all(x["instance"] != target_alias for x in after[-5:]) assert min(x["at"] for x in after) - stopped_at <= 10 - state = json.loads(subprocess.check_output(["docker", "inspect", target_container], text=True))[0]["State"] + state = json.loads( + subprocess.check_output(["docker", "inspect", target_container], text=True) + )[0]["State"] assert not state["Running"] - runs.append({"target_container": target_container, "target_alias": target_alias, - "successful_writes": len(successful), "failed_attempts": len(errors), - "successful_rps": len(successful) / elapsed, - "recovery_seconds": min(x["at"] for x in after) - stopped_at, - "observed_after": sorted({x["instance"] for x in after[-5:]}), - "target_running_after_hook": state["Running"]}) + runs.append( + { + "target_container": target_container, + "target_alias": target_alias, + "successful_writes": len(successful), + "failed_attempts": len(errors), + "successful_rps": len(successful) / elapsed, + "recovery_seconds": min(x["at"] for x in after) - stopped_at, + "observed_after": sorted({x["instance"] for x in after[-5:]}), + "target_running_after_hook": state["Running"], + } + ) subprocess.run(["docker", "start", target_container], check=True, stdout=subprocess.DEVNULL) subprocess.run([sys.executable, "scripts/wait_replicas.py", "2"], cwd=ROOT, check=True) # Verify every acknowledged write, without assuming failed requests did not commit. diff --git a/scripts/verify_rolling.py b/scripts/verify_rolling.py index f7e0679b..6db530bf 100644 --- a/scripts/verify_rolling.py +++ b/scripts/verify_rolling.py @@ -1,4 +1,5 @@ """Sequential real image replacement under message traffic.""" + import json import os import subprocess @@ -13,7 +14,9 @@ from client import Client, Failure def snapshots(): - ids = subprocess.check_output(["docker", "compose", "ps", "-q", "api"], cwd=ROOT, text=True).split() + ids = subprocess.check_output( + ["docker", "compose", "ps", "-q", "api"], cwd=ROOT, text=True + ).split() rows = [] for cid in ids: raw = json.loads(subprocess.check_output(["docker", "inspect", cid], text=True))[0] @@ -22,28 +25,43 @@ def snapshots(): def main(): - subprocess.run(["docker", "build", "-t", "mtusi-vasilev:lab3-rolling", "-"], - input="FROM mtusi-vasilev:lab3\nLABEL org.mtusi.rolling-proof=revision-2\n", text=True, check=True) + subprocess.run( + ["docker", "build", "-t", "mtusi-vasilev:lab3-rolling", "-"], + input="FROM mtusi-vasilev:lab3\nLABEL org.mtusi.rolling-proof=revision-2\n", + text=True, + check=True, + ) before = snapshots() c = Client("http://127.0.0.1:8083") actor, _, _, chat = c.bootstrap() stop = threading.Event() successes, errors = [], [] + def traffic(): while not stop.is_set(): try: response = c.message(actor, chat, "rolling-proof") - successes.append({"id": response["json"]["id"], "at": time.monotonic(), - "instance": response["headers"]["X-Instance-Id"]}) + successes.append( + { + "id": response["json"]["id"], + "at": time.monotonic(), + "instance": response["headers"]["X-Instance-Id"], + } + ) except Failure: errors.append(time.monotonic()) + started = time.monotonic() thread = threading.Thread(target=traffic) thread.start() try: time.sleep(1) - subprocess.run(["scripts/rolling-update.sh"], cwd=ROOT, - env={**os.environ, "API_IMAGE": "mtusi-vasilev:lab3-rolling"}, check=True) + subprocess.run( + ["scripts/rolling-update.sh"], + cwd=ROOT, + env={**os.environ, "API_IMAGE": "mtusi-vasilev:lab3-rolling"}, + check=True, + ) time.sleep(2) finally: stop.set() @@ -64,13 +82,18 @@ def main(): break assert {x["id"] for x in successes} <= {x["id"] for x in items} times = [started, *[x["at"] for x in successes], started + elapsed] - result = {"before": before, "after": after, "successful_writes": len(successes), - "failed_attempts": len(errors), "elapsed_seconds": elapsed, - "successful_rps": len(successes) / elapsed, - "observed_instances": sorted({x["instance"] for x in successes}), - "largest_success_gap_seconds": max(b-a for a,b in zip(times,times[1:])), - "all_confirmed_present": True, - "note": "Target image differs by revision label; same API/schema. This verifies sequential replacement, not arbitrary schema compatibility."} + result = { + "before": before, + "after": after, + "successful_writes": len(successes), + "failed_attempts": len(errors), + "elapsed_seconds": elapsed, + "successful_rps": len(successes) / elapsed, + "observed_instances": sorted({x["instance"] for x in successes}), + "largest_success_gap_seconds": max(b - a for a, b in zip(times, times[1:])), + "all_confirmed_present": True, + "note": "Target image differs by revision label; same API/schema. This verifies sequential replacement, not arbitrary schema compatibility.", + } (ROOT / "evidence/rolling-update.json").write_text(json.dumps(result, indent=2) + "\n") print(json.dumps(result, indent=2)) diff --git a/scripts/verify_teacher_faults.py b/scripts/verify_teacher_faults.py new file mode 100644 index 00000000..c1a16e24 --- /dev/null +++ b/scripts/verify_teacher_faults.py @@ -0,0 +1,103 @@ +import argparse +import concurrent.futures +import importlib.util +import json +import subprocess +import time +from pathlib import Path + +parser=argparse.ArgumentParser() +parser.add_argument('--lab',type=int,default=3) +parser.add_argument('--repo',type=Path) +parser.add_argument('--base-url') +parser.add_argument('--output',type=Path) +args=parser.parse_args() +repo=(args.repo or Path(__file__).resolve().parents[1]).resolve() +spec=importlib.util.spec_from_file_location('pub',repo/'tests/client.py') +m=importlib.util.module_from_spec(spec);spec.loader.exec_module(m) +c=m.Client(args.base_url or f'http://127.0.0.1:{8080+args.lab}',timeout=10) +rows=[] +def compose(*args): + return subprocess.check_output(['docker','compose',*args],cwd=repo,text=True).strip() +def sql(query): + return subprocess.check_output(['docker','exec',pg,'psql','-U','messenger','-d','messenger','-At','-c',query],text=True).strip() +def direct(cid,path,token=None): + code='''import json,sys,time,urllib.request,urllib.error +p=json.load(sys.stdin);start=time.monotonic() +r=urllib.request.Request('http://127.0.0.1:8080'+p['path'],headers={'Authorization':'Bearer '+p['token']} if p.get('token') else {}) +try: response=urllib.request.urlopen(r,timeout=9) +except urllib.error.HTTPError as e: response=e +with response: + body=response.read();result={'status':response.code,'elapsed_s':time.monotonic()-start,'request_id':response.headers.get('X-Request-Id'),'instance_id':response.headers.get('X-Instance-Id'),'body':json.loads(body)} +print(json.dumps(result))''' + out=subprocess.check_output(['docker','exec','-i',cid,'python','-c',code],input=json.dumps({'path':path,'token':token}),text=True,timeout=15) + return json.loads(out) +def check(label,fn): + start=time.monotonic() + try: detail=fn(); row={'case':label,'status':'PASS','detail':detail} + except Exception as e: row={'case':label,'status':'FAIL','error':str(e)[:500]} + row['elapsed_s']=time.monotonic()-start; rows.append(row);print(row,flush=True) +pg=compose('ps','-q','postgres');apis=compose('ps','-q','api').split() +alice,bob,eve,chat=c.bootstrap() +path='/api/v1/chats/'+chat['id']+'/messages' +original=c.message(alice,chat,'fault replay',key='root-fault-replay')['json'] +def acl_replay(): + sql(f"SET session_replication_role=replica; DELETE FROM members WHERE chat_id='{chat['id']}' AND user_id='{alice['id']}';") + try: + for text in ('fault replay','different'): + c.call('POST',path,404,actor=alice,body={'text':text},headers={'Idempotency-Key':'root-fault-replay'}) + finally: sql(f"INSERT INTO members VALUES ('{chat['id']}','{alice['id']}',0);") + return {'same_body':404,'changed_body':404} +def schema_ready(): + sql('ALTER TABLE message_requests RENAME TO message_requests_root_probe;') + try: + values=[direct(cid,'/health/ready') for cid in apis] + assert all(x['status']==503 for x in values),values + return values + finally: sql('ALTER TABLE message_requests_root_probe RENAME TO message_requests;') +def paused_pg(): + # Warm both pools before freezing the real server. + for cid in apis: assert direct(cid,'/api/v1/users/me',alice['token'])['status']==200 + subprocess.run(['docker','pause',pg],check=True,capture_output=True) + try: + with concurrent.futures.ThreadPoolExecutor(max_workers=2) as ex: + values=list(ex.map(lambda item:direct(apis[0],item,alice['token']),('/health/ready','/api/v1/users/me'))) + assert all(x['status']==503 and x['elapsed_s']<8 for x in values),values + assert all(x['request_id']==x['body']['error']['request_id'] and x['instance_id'] for x in values) + finally: subprocess.run(['docker','unpause',pg],check=True,capture_output=True) + deadline=time.monotonic()+25 + while time.monotonic()=4: + fixture=(a.repo/'tests/fixtures/sample.png').read_bytes() + upload='/api/v1/chats/'+chat['id']+'/attachments' + def upl(raw=fixture,mime='image/png',name='sample.png',expected=None): + return c.call('POST',upload+'?filename='+urllib.parse.quote(name,safe=''),expected or (201 if a.lab==4 else 202),actor=alice,raw=raw,headers={'Content-Type':mime},schema='Attachment' if expected is None else None) + for label,raw,mime in ( + ('header only',fixture[:33],'image/png'),('bad IDAT',tiny_png(bad_idat=True),'image/png'), + ('invalid filter',tiny_png(filter_byte=5),'image/png'), + ('empty JPEG scan',bytes.fromhex('ffd8ffc0000b080001000101011100ffda0008010100003f00ffd9'),'image/jpeg'), + ('MIME mismatch',fixture,'image/jpeg')): + case('image rejects '+label,lambda raw=raw,mime=mime:upl(raw=raw,mime=mime,expected=415)) + jpeg_code="from PIL import Image; from io import BytesIO; import random,sys; im=Image.frombytes('RGB',(800,600),random.Random(42).randbytes(800*600*3)); b=BytesIO(); im.save(b,format='JPEG',quality=95); sys.stdout.buffer.write(b.getvalue())" + jpeg=subprocess.check_output([str(a.repo.absolute()/'.venv/bin/python'),'-c',jpeg_code]) + case('valid real JPEG accepted',lambda:upl(raw=jpeg,mime='image/jpeg',name='real.jpg')) + case('half JPEG entropy with EOI rejected',lambda:upl(raw=jpeg[:len(jpeg)//2]+b'\xff\xd9',mime='image/jpeg',name='half.jpg',expected=415)) + sos=jpeg.index(b'\xff\xda') + bad_sos=bytearray(jpeg);bad_sos[sos+5]=250 + case('JPEG SOS unknown component rejected',lambda:upl(raw=bytes(bad_sos),mime='image/jpeg',name='sos.jpg',expected=415)) + palette=(b'\x89PNG\r\n\x1a\n'+png_chunk(b'IHDR',struct.pack('!IIBBBBB',1,1,8,3,0,0,0))+png_chunk(b'PLTE',bytes(771))+png_chunk(b'IDAT',zlib.compress(b'\0\0'))+png_chunk(b'IEND',b'')) + case('PNG invalid palette257 rejected',lambda:upl(raw=palette,expected=415)) + for name in ('../x.png','a\\b.png','a\0b.png','a\x7fb.png','a\x85b.png',' '): + case('filename '+repr(name),lambda name=name:upl(name=name,expected=400)) + case('filename missing',lambda:c.call('POST',upload,400,actor=alice,raw=fixture,headers={'Content-Type':'image/png'})) + case('pixel bomb413',lambda:upl(raw=tiny_png(width=20000,height=10000),expected=413)) + case('too many bytes413',lambda:upl(raw=fixture+b'x'*(10485761-len(fixture)),expected=413)) + attachments=[] + for _ in range(2): + att=upl()['json'] + if a.lab==5: att=c.wait_ready(alice,att) + attachments.append(att) + def attachment_checks(): + ids=[x['id'] for x in reversed(attachments)] + key=uuid.uuid4().hex + sent=msg({'text':'','attachment_ids':ids},key)['json'] + equal(sent['attachment_ids'],ids) + equal(msg({'text':'','attachment_ids':ids},key)['json'],sent) + msg({'text':'','attachment_ids':list(reversed(ids))},key,status=409) + rows=c.call('GET',path+'?limit=100',actor=bob,schema='MessagePage')['json']['items'] + equal(next(x for x in rows if x['id']==sent['id']),sent) + for att in attachments: + route='/api/v1/attachments/'+att['id'] + for suffix in ('','/content'): c.call('GET',route+suffix,404,actor=eve) + content=c.call('GET',route+'/content',actor=bob)['bytes'] + equal(hashlib.sha256(content).hexdigest(),att['sha256']) + msg({'text':'unknown','attachment_ids':[str(uuid.uuid4())]},status=404) + case('attachment order ACL original checksum',attachment_checks) + if a.lab==4: + case('ready missing thumbnail404',lambda:c.call('GET','/api/v1/attachments/'+attachments[0]['id']+'/content?variant=thumbnail',404,actor=alice)) + # Valid PNG padded by a legal ancillary chunk, exactly 10 MiB. + def exact_limit(): + base=tiny_png() + content=base[:-12]+png_chunk(b'tEXt',b'padding\0'+b'x'*(10485760-len(base)-12-8))+base[-12:] + equal(len(content),10485760) + att=upl(raw=content)['json'] + equal(att['size_bytes'],10485760) + case('exact10MiB allowed through LB',exact_limit) + report={'lab':a.lab,'base_url':a.base_url,'tests':results,'passed':sum(x['status']=='PASS' for x in results),'failed':sum(x['status']=='FAIL' for x in results)} + a.output.parent.mkdir(parents=True,exist_ok=True) + a.output.write_text(json.dumps(report,ensure_ascii=False,indent=2)+'\n') + print('TOTAL',report['passed'],'PASS',report['failed'],'FAIL',flush=True) + return int(report['failed']>0) + +if __name__=='__main__': raise SystemExit(main()) diff --git a/student-tests/test_api.py b/student-tests/test_api.py index 6802a43b..36d10084 100644 --- a/student-tests/test_api.py +++ b/student-tests/test_api.py @@ -52,7 +52,14 @@ def test_acl_and_unknown_chat(scenario): for cid in [chat["id"], str(uuid.uuid4())]: for suffix in ["", "/messages"]: c.call("GET", f"/api/v1/chats/{cid}{suffix}", 404, actor=eve) - c.call("POST", f"/api/v1/chats/{cid}/messages", 404, actor=eve, body={"text": "x"}, headers={"Idempotency-Key": str(uuid.uuid4())}) + c.call( + "POST", + f"/api/v1/chats/{cid}/messages", + 404, + actor=eve, + body={"text": "x"}, + headers={"Idempotency-Key": str(uuid.uuid4())}, + ) c.call("GET", "/api/v1/chats/not-a-uuid", 400, actor=alice) diff --git a/student-tests/test_lab3.py b/student-tests/test_lab3.py index b3d02276..e89967b7 100644 --- a/student-tests/test_lab3.py +++ b/student-tests/test_lab3.py @@ -21,7 +21,11 @@ def test_concurrent_idempotency_and_semantic_empty_attachments(shared): def post(i): return Client(os.environ["BASE_URL"]).call( - "POST", path, 201, schema="Message", actor=alice, + "POST", + path, + 201, + schema="Message", + actor=alice, body={"text": "same", **({"attachment_ids": []} if i % 2 else {})}, headers={"Idempotency-Key": key}, ) @@ -31,29 +35,49 @@ def test_concurrent_idempotency_and_semantic_empty_attachments(shared): assert len({r["json"]["id"] for r in results}) == 1 assert len({r["headers"]["X-Instance-Id"] for r in results}) >= 2 assert all(r["json"] == results[0]["json"] for r in results) - c.call("POST", path, 409, actor=alice, body={"text": "different"}, - headers={"Idempotency-Key": key}) + c.call( + "POST", path, 409, actor=alice, body={"text": "different"}, headers={"Idempotency-Key": key} + ) def test_key_scope_and_acl(shared): c, alice, bob, eve, chat = shared path = f"/api/v1/chats/{chat['id']}/messages" key = uuid.uuid4().hex - first = c.call("POST", path, 201, schema="Message", actor=alice, body={"text": "a"}, - headers={"Idempotency-Key": key})["json"] - other = c.call("POST", path, 201, schema="Message", actor=bob, body={"text": "b"}, - headers={"Idempotency-Key": key})["json"] + first = c.call( + "POST", + path, + 201, + schema="Message", + actor=alice, + body={"text": "a"}, + headers={"Idempotency-Key": key}, + )["json"] + other = c.call( + "POST", + path, + 201, + schema="Message", + actor=bob, + body={"text": "b"}, + headers={"Idempotency-Key": key}, + )["json"] assert first["id"] != other["id"] for _ in range(2): - c.call("POST", path, 404, actor=eve, body={"text": "a"}, - headers={"Idempotency-Key": key}) + c.call("POST", path, 404, actor=eve, body={"text": "a"}, headers={"Idempotency-Key": key}) @pytest.mark.parametrize("key", [None, "", "x" * 129, "bad key", "bad/key", "é"]) def test_invalid_idempotency_key(shared, key): c, alice, _, _, chat = shared - c.call("POST", f"/api/v1/chats/{chat['id']}/messages", 400, actor=alice, - body={"text": "x"}, headers={} if key is None else {"Idempotency-Key": key}) + c.call( + "POST", + f"/api/v1/chats/{chat['id']}/messages", + 400, + actor=alice, + body={"text": "x"}, + headers={} if key is None else {"Idempotency-Key": key}, + ) def test_lossless_nul_message_replay_and_history(shared): @@ -61,10 +85,24 @@ def test_lossless_nul_message_replay_and_history(shared): key = uuid.uuid4().hex path = f"/api/v1/chats/{chat['id']}/messages" body = {"text": "abc\u0000def"} - first = c.call("POST", path, 201, schema="Message", actor=alice, body=body, - headers={"Idempotency-Key": key})["json"] - repeat = c.call("POST", path, 201, schema="Message", actor=alice, body=body, - headers={"Idempotency-Key": key})["json"] + first = c.call( + "POST", + path, + 201, + schema="Message", + actor=alice, + body=body, + headers={"Idempotency-Key": key}, + )["json"] + repeat = c.call( + "POST", + path, + 201, + schema="Message", + actor=alice, + body=body, + headers={"Idempotency-Key": key}, + )["json"] assert first == repeat assert first["text"] == body["text"] history = c.call("GET", path, 200, schema="MessagePage", actor=alice)["json"]["items"] @@ -83,8 +121,9 @@ def test_empty_cursor_and_bad_utf8(shared): c, alice, _, _, chat = shared for path in ["/api/v1/chats", f"/api/v1/chats/{chat['id']}/messages"]: c.call("GET", path + "?cursor=", 400, actor=alice) - response = c.call("POST", "/api/v1/users", 400, raw=b"\xff", - headers={"Content-Type": "application/json"}) + response = c.call( + "POST", "/api/v1/users", 400, raw=b"\xff", headers={"Content-Type": "application/json"} + ) assert response["json"]["error"]["code"] == "invalid_request" assert response["headers"]["X-Instance-Id"] c.call("GET", "/api/v1/users/me", 401, headers={"Authorization": "Bearer é"}) @@ -97,5 +136,10 @@ def test_login_body_is_rejected(shared): (registration["username"] + ":" + registration["password"]).encode() ).decode() for body in [b"{}", b"{bad", b"x"]: - c.call("POST", "/api/v1/auth/sessions", 400, raw=body, - headers={"Authorization": "Basic " + basic}) + c.call( + "POST", + "/api/v1/auth/sessions", + 400, + raw=body, + headers={"Authorization": "Basic " + basic}, + ) diff --git a/uv.lock b/uv.lock index 00cd36c1..0c05d70a 100644 --- a/uv.lock +++ b/uv.lock @@ -2,6 +2,62 @@ version = 1 revision = 3 requires-python = "==3.12.*" +[[package]] +name = "aiohappyeyeballs" +version = "2.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ce/f4/eec0465c2f67b2664688d0240b3212d5196fd89e741df67ddb81f8d35658/aiohappyeyeballs-2.7.1.tar.gz", hash = "sha256:065665c041c42a5938ed220bdcd7230f22527fbec085e1853d2402c8a3615d9d", size = 24757, upload-time = "2026-07-01T17:11:55.501Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/43/1947f06babed6b3f1d7f38b0c767f52df66bfb2bc10b468c4a7de9eceff2/aiohappyeyeballs-2.7.1-py3-none-any.whl", hash = "sha256:9243213661e29250eb41368e5daa826fc017156c3b8a11440826b2e3ed376472", size = 15038, upload-time = "2026-07-01T17:11:54.055Z" }, +] + +[[package]] +name = "aiohttp" +version = "3.13.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/42/32cf8e7704ceb4481406eb87161349abb46a57fee3f008ba9cb610968646/aiohttp-3.13.3.tar.gz", hash = "sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88", size = 7844556, upload-time = "2026-01-03T17:33:05.204Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/be/4fc11f202955a69e0db803a12a062b8379c970c7c84f4882b6da17337cc1/aiohttp-3.13.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b903a4dfee7d347e2d87697d0713be59e0b87925be030c9178c5faa58ea58d5c", size = 739732, upload-time = "2026-01-03T17:30:14.23Z" }, + { url = "https://files.pythonhosted.org/packages/97/2c/621d5b851f94fa0bb7430d6089b3aa970a9d9b75196bc93bb624b0db237a/aiohttp-3.13.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a45530014d7a1e09f4a55f4f43097ba0fd155089372e105e4bff4ca76cb1b168", size = 494293, upload-time = "2026-01-03T17:30:15.96Z" }, + { url = "https://files.pythonhosted.org/packages/5d/43/4be01406b78e1be8320bb8316dc9c42dbab553d281c40364e0f862d5661c/aiohttp-3.13.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:27234ef6d85c914f9efeb77ff616dbf4ad2380be0cda40b4db086ffc7ddd1b7d", size = 493533, upload-time = "2026-01-03T17:30:17.431Z" }, + { url = "https://files.pythonhosted.org/packages/8d/a8/5a35dc56a06a2c90d4742cbf35294396907027f80eea696637945a106f25/aiohttp-3.13.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d32764c6c9aafb7fb55366a224756387cd50bfa720f32b88e0e6fa45b27dcf29", size = 1737839, upload-time = "2026-01-03T17:30:19.422Z" }, + { url = "https://files.pythonhosted.org/packages/bf/62/4b9eeb331da56530bf2e198a297e5303e1c1ebdceeb00fe9b568a65c5a0c/aiohttp-3.13.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b1a6102b4d3ebc07dad44fbf07b45bb600300f15b552ddf1851b5390202ea2e3", size = 1703932, upload-time = "2026-01-03T17:30:21.756Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f6/af16887b5d419e6a367095994c0b1332d154f647e7dc2bd50e61876e8e3d/aiohttp-3.13.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c014c7ea7fb775dd015b2d3137378b7be0249a448a1612268b5a90c2d81de04d", size = 1771906, upload-time = "2026-01-03T17:30:23.932Z" }, + { url = "https://files.pythonhosted.org/packages/ce/83/397c634b1bcc24292fa1e0c7822800f9f6569e32934bdeef09dae7992dfb/aiohttp-3.13.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2b8d8ddba8f95ba17582226f80e2de99c7a7948e66490ef8d947e272a93e9463", size = 1871020, upload-time = "2026-01-03T17:30:26Z" }, + { url = "https://files.pythonhosted.org/packages/86/f6/a62cbbf13f0ac80a70f71b1672feba90fdb21fd7abd8dbf25c0105fb6fa3/aiohttp-3.13.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ae8dd55c8e6c4257eae3a20fd2c8f41edaea5992ed67156642493b8daf3cecc", size = 1755181, upload-time = "2026-01-03T17:30:27.554Z" }, + { url = "https://files.pythonhosted.org/packages/0a/87/20a35ad487efdd3fba93d5843efdfaa62d2f1479eaafa7453398a44faf13/aiohttp-3.13.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01ad2529d4b5035578f5081606a465f3b814c542882804e2e8cda61adf5c71bf", size = 1561794, upload-time = "2026-01-03T17:30:29.254Z" }, + { url = "https://files.pythonhosted.org/packages/de/95/8fd69a66682012f6716e1bc09ef8a1a2a91922c5725cb904689f112309c4/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bb4f7475e359992b580559e008c598091c45b5088f28614e855e42d39c2f1033", size = 1697900, upload-time = "2026-01-03T17:30:31.033Z" }, + { url = "https://files.pythonhosted.org/packages/e5/66/7b94b3b5ba70e955ff597672dad1691333080e37f50280178967aff68657/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c19b90316ad3b24c69cd78d5c9b4f3aa4497643685901185b65166293d36a00f", size = 1728239, upload-time = "2026-01-03T17:30:32.703Z" }, + { url = "https://files.pythonhosted.org/packages/47/71/6f72f77f9f7d74719692ab65a2a0252584bf8d5f301e2ecb4c0da734530a/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:96d604498a7c782cb15a51c406acaea70d8c027ee6b90c569baa6e7b93073679", size = 1740527, upload-time = "2026-01-03T17:30:34.695Z" }, + { url = "https://files.pythonhosted.org/packages/fa/b4/75ec16cbbd5c01bdaf4a05b19e103e78d7ce1ef7c80867eb0ace42ff4488/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:084911a532763e9d3dd95adf78a78f4096cd5f58cdc18e6fdbc1b58417a45423", size = 1554489, upload-time = "2026-01-03T17:30:36.864Z" }, + { url = "https://files.pythonhosted.org/packages/52/8f/bc518c0eea29f8406dcf7ed1f96c9b48e3bc3995a96159b3fc11f9e08321/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7a4a94eb787e606d0a09404b9c38c113d3b099d508021faa615d70a0131907ce", size = 1767852, upload-time = "2026-01-03T17:30:39.433Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f2/a07a75173124f31f11ea6f863dc44e6f09afe2bca45dd4e64979490deab1/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:87797e645d9d8e222e04160ee32aa06bc5c163e8499f24db719e7852ec23093a", size = 1722379, upload-time = "2026-01-03T17:30:41.081Z" }, + { url = "https://files.pythonhosted.org/packages/3c/4a/1a3fee7c21350cac78e5c5cef711bac1b94feca07399f3d406972e2d8fcd/aiohttp-3.13.3-cp312-cp312-win32.whl", hash = "sha256:b04be762396457bef43f3597c991e192ee7da460a4953d7e647ee4b1c28e7046", size = 428253, upload-time = "2026-01-03T17:30:42.644Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b7/76175c7cb4eb73d91ad63c34e29fc4f77c9386bba4a65b53ba8e05ee3c39/aiohttp-3.13.3-cp312-cp312-win_amd64.whl", hash = "sha256:e3531d63d3bdfa7e3ac5e9b27b2dd7ec9df3206a98e0b3445fa906f233264c57", size = 455407, upload-time = "2026-01-03T17:30:44.195Z" }, +] + +[[package]] +name = "aiosignal" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "frozenlist" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" }, +] + [[package]] name = "annotated-doc" version = "0.0.5" @@ -125,6 +181,37 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, ] +[[package]] +name = "contourpy" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/5a/a55177dd22553a277388e8a1b3220e92de91bacb28356cdc73caa240121d/contourpy-1.4.0.tar.gz", hash = "sha256:20156f5a1ac4f8ce02656e39a61e82164a3d359796dc8026f75b062783d500e1", size = 13323726, upload-time = "2026-09-11T19:05:05.808Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/97/ba/01bde9753bdbba04a6da9d2bff3881f021bc708f654655e95fae26d3b3a3/contourpy-1.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:186ba929df36d61b6127da2e89cd1357e4cb79aca647381ab1a6feb0b152877b", size = 297302, upload-time = "2026-09-11T19:02:45.103Z" }, + { url = "https://files.pythonhosted.org/packages/dd/f5/c5bf67522d49a2222f3154fe46879451d26f0e35ece41770758a64ea78cb/contourpy-1.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c76f3a5318164db7d9401132fc1b5364b784c613c93fa506e3b5e6d1bf353ec8", size = 284921, upload-time = "2026-09-11T19:02:48.049Z" }, + { url = "https://files.pythonhosted.org/packages/0f/cc/cb989599eec12fda312e127eb8e04a8b21a7a6c94bf7ff1bc68273334a42/contourpy-1.4.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:43c3ccbb32c6294b183dcc8e8c46dacf5ecef809497e3d48a5be298eef185ad0", size = 356332, upload-time = "2026-09-11T19:02:51.408Z" }, + { url = "https://files.pythonhosted.org/packages/47/fb/6f620d7602507817b0b4c21dd790ed68688f1f4ae9c29aacf21f08db5cf1/contourpy-1.4.0-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:86d05cec773c9507a3950122e0e40ce77c23c75ceeb2fc189514e71893cbb34b", size = 405878, upload-time = "2026-09-11T19:02:54.093Z" }, + { url = "https://files.pythonhosted.org/packages/32/4e/693c6d6bdece679f0953775eef3a1b66d56be55478d936e7deb1f3004422/contourpy-1.4.0-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2deb580178ca19437a84bd77e4bc2cd91a8ccad212413a83c273900868b5978c", size = 408296, upload-time = "2026-09-11T19:02:56.528Z" }, + { url = "https://files.pythonhosted.org/packages/78/f9/b6831508960d559581c448532ba4df312217072975486dbf2b24fcc5b76f/contourpy-1.4.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:875f42444c9cf48d56f724f2637e60d0f73b3b12c9041e1484580a233edf9591", size = 383243, upload-time = "2026-09-11T19:02:58.638Z" }, + { url = "https://files.pythonhosted.org/packages/f2/21/52903825a0ae7bb625e8bd30a09816d4c3c5d6174a469c10a616166cf780/contourpy-1.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f863c6100bf926cf47d13f3cd75f9bb8ebd98aaab230eeb4468b91f98f39a6b3", size = 1357306, upload-time = "2026-09-11T19:03:01.036Z" }, + { url = "https://files.pythonhosted.org/packages/d8/79/d68b1ce8539e4071518fed9523f558398f34dcd078b8927b109c72dad2ef/contourpy-1.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3863ef2e2b13fe93f8c0ebb08ee400cb07153b8b0e91c5acb26e4537f283634f", size = 1427243, upload-time = "2026-09-11T19:03:03.866Z" }, + { url = "https://files.pythonhosted.org/packages/ac/f0/b75a10e9d0616b97a30de277b6dfe83f1879880854c7330337309530eb48/contourpy-1.4.0-cp312-cp312-win32.whl", hash = "sha256:5450f091ac1be0be3ad3a2a3b3f23b5e443e78c670ced4fd347d626f92a28fd2", size = 347345, upload-time = "2026-09-11T19:03:06.192Z" }, + { url = "https://files.pythonhosted.org/packages/50/a9/dab08786bb4d77ef9a046b3c1be923be4e73c5d07d91f5a54e8ea9b09e41/contourpy-1.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:6e697d94e69f499ff6bebb899cae97a58d5d14f0e1fe9568b43a0248d2f9af8c", size = 234083, upload-time = "2026-09-11T19:03:08.122Z" }, + { url = "https://files.pythonhosted.org/packages/47/b9/3ba509755a970dbde5948e7142ac21f266be72f38017cc4087a05fdceee1/contourpy-1.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:0c7a4c2716a4e98342221954416a836cca77c996c14ddbf22b5f01d5d93ca09c", size = 559521, upload-time = "2026-09-11T19:03:10.047Z" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + [[package]] name = "fastapi" version = "0.162.0" @@ -142,6 +229,49 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b4/4f/3f2c25c9b43970b5e9a08beb5e04776247edea684ddc0930f4f02f0bb6cb/fastapi-0.162.0-py3-none-any.whl", hash = "sha256:3785963de305dd09912426cb81f2d230fce98ab3521cdfe97265c8d14983128c", size = 148912, upload-time = "2026-10-23T18:47:31.734Z" }, ] +[[package]] +name = "fonttools" +version = "4.68.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0c/b5/672312ae80ce8b8eb9779c56052a24c8f36652aa7293a1a420553bcf03e5/fonttools-4.68.0.tar.gz", hash = "sha256:73294e233070f71e2b3653b6bd8564af676d57f26d075761fb06d1ab2e4a7a5d", size = 3848583, upload-time = "2026-10-27T16:30:26.451Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/15/63/f332b2099599b4911786a6f6fd69552fdd5ae6a45cfaffb0c881092f36c8/fonttools-4.68.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f265c85432c398d86f26add143423924a4747879b2dce001a3ffe0a5fed30638", size = 3143556, upload-time = "2026-10-27T16:28:21.812Z" }, + { url = "https://files.pythonhosted.org/packages/c8/97/68816bb56843e06631ff11517e4fb35fc62d76aec6e29f11df095e7f33c5/fonttools-4.68.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d225096687fc3bac0ebe3357e95b2dd8b0a49d191f016db0771d537ccdd6f47e", size = 2633689, upload-time = "2026-10-27T16:28:23.54Z" }, + { url = "https://files.pythonhosted.org/packages/21/94/b125c7a6d154d17f4f699150ef3abebd9d8ad0f7eddce9dad649a9e5c1d8/fonttools-4.68.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b41e71b2657c9843b2327b4e3c116db1757dc8cd05d978cd47cb5061272d4997", size = 5462605, upload-time = "2026-10-27T16:28:25.774Z" }, + { url = "https://files.pythonhosted.org/packages/7f/58/fe13db71e3f5a020c6875f349806e84f7550f3f24cb3cdbabdd693968b1d/fonttools-4.68.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3edce69ecdefa73ab1041901ca22eefed6ebb93a77bc77e889d940479f25bf7d", size = 5443448, upload-time = "2026-10-27T16:28:27.898Z" }, + { url = "https://files.pythonhosted.org/packages/f1/7f/48236f8c626007670586dd6b0d61ed80323a6b17ead763c881d717525cea/fonttools-4.68.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8d5674de2b614575f0751671727056af042ac1d61beacb59a298d74282fa492", size = 5399992, upload-time = "2026-10-27T16:28:29.99Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0d/09e9a433430e277e454eace1c4d02c3691a33d5257bd234702a427a9d090/fonttools-4.68.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7ab8097e7e191784974c5608eb95fb31e1243fe3054cb66778ac82558e9b36f8", size = 5563739, upload-time = "2026-10-27T16:28:32.691Z" }, + { url = "https://files.pythonhosted.org/packages/ac/54/6708f4c6742de2d5bf4280d8bde22fb8aef5120328bdc19ca34a9d2e8e8b/fonttools-4.68.0-cp312-cp312-win32.whl", hash = "sha256:1695cd2e1f9768fe3f14d369ce6ef1b3e8561069cc9e47059571985d1ea42614", size = 2481614, upload-time = "2026-10-27T16:28:35.122Z" }, + { url = "https://files.pythonhosted.org/packages/1c/3e/ef786310a3774ae7aacaa288ca6d1e1dfd03c24214137478e4b630b76af0/fonttools-4.68.0-cp312-cp312-win_amd64.whl", hash = "sha256:fedc183bdbc3fdbfbdca26e0e04566d089cbb404712509a4e824608e9304cc77", size = 2533508, upload-time = "2026-10-27T16:28:37.085Z" }, + { url = "https://files.pythonhosted.org/packages/06/11/2cc4272ddd485c448c0363be9beb0a24d3f429f1cc8c5aafa716c508e899/fonttools-4.68.0-cp312-cp312-win_arm64.whl", hash = "sha256:95628bbc5ea81d5761268f4c4f1ba709af510b970f363498ac801c0c1fd7a4a8", size = 2502049, upload-time = "2026-10-27T16:28:39.355Z" }, + { url = "https://files.pythonhosted.org/packages/35/74/4ea331ecc65ba05a58b1e4e8ccd604c8a15565f876dfbf93fc2a2ea2e22b/fonttools-4.68.0-py3-none-any.whl", hash = "sha256:d76f8fdcb6936f5e1045a0c9dd721a4bf11112e60d1e243bfa1d39f06a8b3104", size = 1248357, upload-time = "2026-10-27T16:30:24.389Z" }, +] + +[[package]] +name = "frozenlist" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" }, + { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" }, + { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" }, + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" }, + { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" }, + { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" }, + { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" }, + { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" }, + { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" }, + { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" }, + { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" }, + { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" }, + { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" }, +] + [[package]] name = "h11" version = "0.16.0" @@ -239,6 +369,32 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, ] +[[package]] +name = "kiwisolver" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/07/bd78e6a8fae171ea041ef5bba3ed21a003522fa088834b069b1909981f30/kiwisolver-1.5.1.tar.gz", hash = "sha256:f1303ef2eec81262a4b708c3e858afe58d7c75ad91c1c05266eda7673369859a", size = 104395, upload-time = "2026-08-28T10:28:27.153Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/9b/65b302742389c6f96f2956bef5decf26011309feb2fc5d79613af18adea4/kiwisolver-1.5.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:63fb7294b768f444eb4b068965f2662f28c2fd4161e23bd60fcf3ff27b74c046", size = 123876, upload-time = "2026-08-28T10:25:27.44Z" }, + { url = "https://files.pythonhosted.org/packages/71/74/c21f339956f6f691b2ed7e31d5f3ae767304df6c460192739fc830853051/kiwisolver-1.5.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0ebdef3eae5336568147c39a55be6a2036ffde53faa9ca2d978989ae7c2da12c", size = 66487, upload-time = "2026-08-28T10:25:28.728Z" }, + { url = "https://files.pythonhosted.org/packages/84/e5/bdb34e21523e01dceda064d63713f3bdec91388af24fba1eca7ea5e85864/kiwisolver-1.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1798e83840c3f627246104c4d8a9639c60fa068adf9ce92b61791781fa8a68c1", size = 64660, upload-time = "2026-08-28T10:25:30.071Z" }, + { url = "https://files.pythonhosted.org/packages/fc/f4/dadfec469313c7f428efa7e84b4aba9732f813c13ea7131a24b7b008ef57/kiwisolver-1.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:34633ecf50d16187ab8e5528b7a2530f2feb4e23f300db4672538b51cfc5cd38", size = 1477929, upload-time = "2026-08-28T10:25:31.495Z" }, + { url = "https://files.pythonhosted.org/packages/6f/35/09c58daac34e6f6ea5c6dee0094b422118e5a7c265586008a95fd135ac5f/kiwisolver-1.5.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d27c2123977cb9269c30a49ba45f03a4323017ef693e19db4ec9dbe1299a3002", size = 1278499, upload-time = "2026-08-28T10:25:33.375Z" }, + { url = "https://files.pythonhosted.org/packages/19/32/739765e24fbad29d13f83e546ea4abc215a78cea9d677ca09025b027724d/kiwisolver-1.5.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6a797a1cefc8b9c93170db580337e1fe3d011ad18b1299943231279406342048", size = 1296677, upload-time = "2026-08-28T10:25:35.059Z" }, + { url = "https://files.pythonhosted.org/packages/df/32/03304d1010e2cc45e5b3b52cef7e43fed3a2a5cd6c87a89b4a88e1d85b5d/kiwisolver-1.5.1-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2551cf9917af48ee7c4b29cc82320489508cf96fd26a51f6fc124de661cd44c7", size = 1346037, upload-time = "2026-08-28T10:25:36.705Z" }, + { url = "https://files.pythonhosted.org/packages/3e/57/4c49377bfd274450dd72ecaa13eaac32ea804a03363e4d1db0c5aa999ceb/kiwisolver-1.5.1-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:38f6e0deb4d0a4615efe0c4efc5990b06ae450ab50a0b321c0b078b6d238c083", size = 988248, upload-time = "2026-08-28T10:25:38.299Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c3/38df144a08b6c5d75ca4504e5cc3141bb3bfef64c04f4ef48204f42711b6/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bfd1de989b3330420e29de39352f5c049905c9e3ee67233a50d550e3d652c148", size = 2228722, upload-time = "2026-08-28T10:25:40.038Z" }, + { url = "https://files.pythonhosted.org/packages/e7/11/3221838a89cd64d9b386353e000cd8a296069a20fbe3584507fdfd5bebae/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1209042a623ddfda5497e4066c7b77651dde8e1d3a9dd97599dc7e97f3b9b78c", size = 2325216, upload-time = "2026-08-28T10:25:41.699Z" }, + { url = "https://files.pythonhosted.org/packages/83/d4/075c219230697bb5db910d37262b9bacf880f92b4811a02ab81ed073a253/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:26e8268480be5061d509e29669d59103c067a26377a56491630ece11762e3858", size = 1977689, upload-time = "2026-08-28T10:25:43.559Z" }, + { url = "https://files.pythonhosted.org/packages/bb/08/1d219c3c2dd960983d0d4da623d916e9de6385df2b0bab3d1af0e9b8fccc/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:d79308fa689fac89cbcfbd4dbfc80b5f95c54c5a7fd4d194be221f9d33d026e6", size = 2491443, upload-time = "2026-08-28T10:25:45.242Z" }, + { url = "https://files.pythonhosted.org/packages/ba/d3/024208ec1079d273f1047468d1bdffbf38bb75b7b268090fd3a0301b9d9a/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b03af77d77e50edba2030fd5f7c352ff209314b09030a3cba7c14edf9a09a444", size = 2295200, upload-time = "2026-08-28T10:25:46.984Z" }, + { url = "https://files.pythonhosted.org/packages/6e/7c/7b210498f9f92e1cd7855f260fa69ef056881087b199ee20c208f0e4189a/kiwisolver-1.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:06a6917674de9e0fe3f66f5430787f59a9f2ddb64af9b714eaec547e29ef5c19", size = 70748, upload-time = "2026-08-28T10:25:48.444Z" }, + { url = "https://files.pythonhosted.org/packages/94/61/ef0daa157c8bb23672f7423e0d14c39db1dc6ef8ed47e6bc54c9c1bef3bf/kiwisolver-1.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:ad8b9671348d7c8716715652ae11f85ed0eb99e265a2df2ca490577d69860b2c", size = 68324, upload-time = "2026-08-28T10:25:49.81Z" }, + { url = "https://files.pythonhosted.org/packages/a9/c4/1407df7512a5b36cc79840e01710dc575733c461b13ab866cae77eaf87f3/kiwisolver-1.5.1-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:482676e5bd48d70ac99d9fc78863469845421e01184fa83f1f9366dc49f7e974", size = 134002, upload-time = "2026-08-28T10:28:08.881Z" }, + { url = "https://files.pythonhosted.org/packages/16/45/c37a21ad5c0ab581a93c55ad544721aaa1f0ae94edb29c6a678a23d013e6/kiwisolver-1.5.1-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:072bdb15a3c19a5b5dbc8f8fb1f4e1884bf4f3507eeb4cc6334401274d37a5c0", size = 194292, upload-time = "2026-08-28T10:28:11.06Z" }, + { url = "https://files.pythonhosted.org/packages/a6/c1/69f00d627949580e43d57af0aa465df46868d7c29801c137a55374101294/kiwisolver-1.5.1-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:a5a00665d1a0e26763a7338d7e911d4598fbc1d50dd0d6b7919b7dc6c5d6569f", size = 73362, upload-time = "2026-08-28T10:28:12.449Z" }, +] + [[package]] name = "lazy-object-proxy" version = "1.13.0" @@ -256,6 +412,32 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/21/21/d70d4ca285bb6ed3629ac432ea0910b8f923e50580888e37990b31f3fac9/lazy_object_proxy-1.13.0-cp312-cp312-win_arm64.whl", hash = "sha256:da66d53e0c350e6e6876f2dc060b240dc06cc159ca7f279d59fe4ed48aec2ece", size = 24467, upload-time = "2026-10-17T16:37:44.82Z" }, ] +[[package]] +name = "matplotlib" +version = "3.10.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/76/d3c6e3a13fe484ebe7718d14e269c9569c4eb0020a968a327acb3b9a8fe6/matplotlib-3.10.8.tar.gz", hash = "sha256:2299372c19d56bcd35cf05a2738308758d32b9eaed2371898d8f5bd33f084aa3", size = 34806269, upload-time = "2025-12-10T22:56:51.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/67/f997cdcbb514012eb0d10cd2b4b332667997fb5ebe26b8d41d04962fa0e6/matplotlib-3.10.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:64fcc24778ca0404ce0cb7b6b77ae1f4c7231cdd60e6778f999ee05cbd581b9a", size = 8260453, upload-time = "2025-12-10T22:55:30.709Z" }, + { url = "https://files.pythonhosted.org/packages/7e/65/07d5f5c7f7c994f12c768708bd2e17a4f01a2b0f44a1c9eccad872433e2e/matplotlib-3.10.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b9a5ca4ac220a0cdd1ba6bcba3608547117d30468fefce49bb26f55c1a3d5c58", size = 8148321, upload-time = "2025-12-10T22:55:33.265Z" }, + { url = "https://files.pythonhosted.org/packages/3e/f3/c5195b1ae57ef85339fd7285dfb603b22c8b4e79114bae5f4f0fcf688677/matplotlib-3.10.8-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3ab4aabc72de4ff77b3ec33a6d78a68227bf1123465887f9905ba79184a1cc04", size = 8716944, upload-time = "2025-12-10T22:55:34.922Z" }, + { url = "https://files.pythonhosted.org/packages/00/f9/7638f5cc82ec8a7aa005de48622eecc3ed7c9854b96ba15bd76b7fd27574/matplotlib-3.10.8-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:24d50994d8c5816ddc35411e50a86ab05f575e2530c02752e02538122613371f", size = 9550099, upload-time = "2025-12-10T22:55:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/57/61/78cd5920d35b29fd2a0fe894de8adf672ff52939d2e9b43cb83cd5ce1bc7/matplotlib-3.10.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:99eefd13c0dc3b3c1b4d561c1169e65fe47aab7b8158754d7c084088e2329466", size = 9613040, upload-time = "2025-12-10T22:55:38.715Z" }, + { url = "https://files.pythonhosted.org/packages/30/4e/c10f171b6e2f44d9e3a2b96efa38b1677439d79c99357600a62cc1e9594e/matplotlib-3.10.8-cp312-cp312-win_amd64.whl", hash = "sha256:dd80ecb295460a5d9d260df63c43f4afbdd832d725a531f008dad1664f458adf", size = 8142717, upload-time = "2025-12-10T22:55:41.103Z" }, + { url = "https://files.pythonhosted.org/packages/f1/76/934db220026b5fef85f45d51a738b91dea7d70207581063cd9bd8fafcf74/matplotlib-3.10.8-cp312-cp312-win_arm64.whl", hash = "sha256:3c624e43ed56313651bc18a47f838b60d7b8032ed348911c54906b130b20071b", size = 8012751, upload-time = "2025-12-10T22:55:42.684Z" }, +] + [[package]] name = "mtusi-messenger" version = "1.0.0" @@ -270,8 +452,10 @@ dependencies = [ [package.dev-dependencies] dev = [ + { name = "aiohttp" }, { name = "httpx" }, { name = "jsonschema" }, + { name = "matplotlib" }, { name = "openapi-spec-validator" }, { name = "pytest" }, { name = "ruff" }, @@ -288,13 +472,63 @@ requires-dist = [ [package.metadata.requires-dev] dev = [ + { name = "aiohttp", specifier = "==3.13.3" }, { name = "httpx" }, { name = "jsonschema" }, + { name = "matplotlib", specifier = "==3.10.8" }, { name = "openapi-spec-validator" }, { name = "pytest" }, { name = "ruff" }, ] +[[package]] +name = "multidict" +version = "6.9.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/99/1d4d69c3512d0ddbfa3a1b69cfd9a151012ab2eb4eabbb096201b1f0b7d8/multidict-6.9.1.tar.gz", hash = "sha256:0f06e60fa190aa7abd0914c2a766736fdc8e9f34878c4346338534b73d1b20e2", size = 182404, upload-time = "2026-09-21T17:59:05.362Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/0d/4b5afb6d3e545c9af0cdfe2db8f6f4c6664568c23d863d888674e447e6a4/multidict-6.9.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:29138fef49828542e859828107e42e50d0e587c513b7eb4b2d92bade2b0860fe", size = 98360, upload-time = "2026-09-21T17:55:11.508Z" }, + { url = "https://files.pythonhosted.org/packages/89/ab/1b9ca66251899981b21138b87da9d5a9c2c81af12b1ea7d19466972f7fe2/multidict-6.9.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:19e31815d41cefc365489e591d105d2baceb2f65aa75d29471fbdbda8651e006", size = 59979, upload-time = "2026-09-21T17:55:12.866Z" }, + { url = "https://files.pythonhosted.org/packages/36/eb/6ae44062466c26c8469ef43f2481a6a48d8cea0587b2d54514ec92e2adfd/multidict-6.9.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6ed30be8918e18c8bed0a2e8b70639ecf02feb61ed00ca2e41cfcb2a50fa3f42", size = 57736, upload-time = "2026-09-21T17:55:14.223Z" }, + { url = "https://files.pythonhosted.org/packages/b9/5c/a67817593019257a4ac8b0d1b4c426030e637c047b0692ef405439ecea7a/multidict-6.9.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:637f4ae36264bd7b8d9a60193acddc1d735ad52e8ed53a19931ea6d921fea8e5", size = 333097, upload-time = "2026-09-21T17:55:15.591Z" }, + { url = "https://files.pythonhosted.org/packages/90/bf/599ae2e6222822d88a247a8a7ae82fe6fd25d5700757b79603d5edafe6a0/multidict-6.9.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:35fc236507fb1b3138f0af5ecd5f94ed752d4d6d826248eae425f86204013eea", size = 334196, upload-time = "2026-09-21T17:55:17.015Z" }, + { url = "https://files.pythonhosted.org/packages/15/10/d8aac5acacbe7f5c117866c776ec26d5f15a868759b6f37ad8e7ed3b5b02/multidict-6.9.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e58952f04772f59f11c6e007471449809a30165188669bca8fdb19dde40a8f24", size = 317465, upload-time = "2026-09-21T17:55:18.412Z" }, + { url = "https://files.pythonhosted.org/packages/19/0a/714f796f7293a8b1c5c3f465a26996231d5450c54e85d64ef1258c091134/multidict-6.9.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d35a4f1c63f07fbb8c8f9946dea98b21eddf6c57421585f71d91864be3ba2a24", size = 345914, upload-time = "2026-09-21T17:55:20.306Z" }, + { url = "https://files.pythonhosted.org/packages/da/b1/e37fbf769c567be277bcf32df6234035a4384677fcc1bd852752be3d6b93/multidict-6.9.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b5f8771aaaed7f80e84a4e471d2f29ab6721e4595075e54d03ae1ed951b2000a", size = 351163, upload-time = "2026-09-21T17:55:22.21Z" }, + { url = "https://files.pythonhosted.org/packages/ed/5b/db08419c1e1f7c9d60cfd2787b2b517d7ae4ebbda8281b48a33eb5141467/multidict-6.9.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:976fd7689d69ec78d67d31d38d396d8adb562f7e8368279f76aed4aa451fa06d", size = 336881, upload-time = "2026-09-21T17:55:23.699Z" }, + { url = "https://files.pythonhosted.org/packages/9b/07/cc9bc8a62651d2d53ab93ee4993b3a71b7cb78eb8ebfc9c757a5b6698617/multidict-6.9.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:95052e8777a86bae87c0bd0b5ab22d809e3d1d02bf69e3e66ddda5ba75a05805", size = 303405, upload-time = "2026-09-21T17:55:25.305Z" }, + { url = "https://files.pythonhosted.org/packages/b6/0c/8e912afafa70e944dbb8bec4b66ca6e008511395278c0d3dd0e89567536a/multidict-6.9.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1a8adfcaf96f587ab138476eaddef95f29b8a2a8a9afbfea8d2fd62180995d02", size = 324265, upload-time = "2026-09-21T17:55:26.989Z" }, + { url = "https://files.pythonhosted.org/packages/66/6a/62c2af80fb085e6234805017af857b8e913dfac7a55e9c1349c27768c58a/multidict-6.9.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1a53de2772cfb74559df2eb4456ec4eeb908435ec55a84b69370d9d745d62aa8", size = 322085, upload-time = "2026-09-21T17:55:28.732Z" }, + { url = "https://files.pythonhosted.org/packages/f8/6b/35bf801b336fd960811207203ffdcdc24acc3558b3e7ff2e1c914b141e70/multidict-6.9.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f2ce963299d42fa3f22a90adc0fdf174792ffef5ff4c7ffb68260548fb05580", size = 338107, upload-time = "2026-09-21T17:55:30.303Z" }, + { url = "https://files.pythonhosted.org/packages/80/41/495ef65bf5bba29d142d81b3fe1b8154b919bed70e96491b1e93c3c26f0f/multidict-6.9.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5b30ddf7234e611ca877575b62840e6af5977f92f1f9d532eedbb05a44ff8004", size = 339631, upload-time = "2026-09-21T17:55:32.012Z" }, + { url = "https://files.pythonhosted.org/packages/19/bd/057fdff5f4e04dcd40a960e38f77d19d3c4b67dd243ffa5f43718edb29fc/multidict-6.9.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:63ada7ee2e9345695f9e9bc4c65d72222253f07b1ac94fd0e37555cc6f3c7f60", size = 302080, upload-time = "2026-09-21T17:55:33.817Z" }, + { url = "https://files.pythonhosted.org/packages/3f/de/9ace933ee8dad808632523726f42255b09600087219e3d4ead7369820910/multidict-6.9.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3c95601ed98fad3f6e2f8fe809c3b526b0fab31ef525e00a155e227f3d17f58a", size = 341107, upload-time = "2026-09-21T17:55:35.471Z" }, + { url = "https://files.pythonhosted.org/packages/d8/ac/7c1204406097bfc5c283d4a3287d61166807d189917567df4c1318484fc4/multidict-6.9.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c148e8b596000dd3e4bfe206e70f3e666be18d72032e0012555f2373c52e35d6", size = 333482, upload-time = "2026-09-21T17:55:37.002Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c0/a70c32ea3299ebe00f44533740cb46905717c51faf29bbd3ce8bb5886d9d/multidict-6.9.1-cp312-cp312-win32.whl", hash = "sha256:f9dad513626a33670f17cddc6078e30e311f444c957e8dbfc5b2b4603c8b4edb", size = 52548, upload-time = "2026-09-21T17:55:38.529Z" }, + { url = "https://files.pythonhosted.org/packages/d7/2e/8c9c2591df01e5692ad1bf92febb082a17b1c6c3a19aa8b7ff49988fd989/multidict-6.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:a16a1dc8529f9e734a41c3b856f3eae7ebacdc061dde3f8a844e0c7889c97203", size = 59622, upload-time = "2026-09-21T17:55:39.86Z" }, + { url = "https://files.pythonhosted.org/packages/d0/95/59f4472ec512bc180fd207899594c7803ece96262ff9aaa3a4b6d7da6940/multidict-6.9.1-cp312-cp312-win_arm64.whl", hash = "sha256:361f7206cf341ba94fb015688f5c8b480f8e63bd58a4c14a48aeca7851a241cc", size = 54930, upload-time = "2026-09-21T17:55:41.155Z" }, + { url = "https://files.pythonhosted.org/packages/be/59/e26cb779be4c591d1a910f59d29aca9fba4de70349840a833beba2652371/multidict-6.9.1-py3-none-any.whl", hash = "sha256:7bf6478188f4e47bf5686e8a33da4ae28bf43b1b2528d9ee144d28492bfac60b", size = 19176, upload-time = "2026-09-21T17:59:03.501Z" }, +] + +[[package]] +name = "numpy" +version = "2.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/95/b0/c7453d0b6e2073c3264468b106ee1563750cecc910965e67357e3698c83e/numpy-2.5.4.tar.gz", hash = "sha256:9a94cf751c9ad8ebaa835bcd3d40dacf8534ad086b88c38029b65123c7999d2a", size = 20866315, upload-time = "2026-10-10T20:05:31.422Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d0/97/ba2074e92b7befea137e77ea8471e768bbd87c339b7e8c9f5a931949f977/numpy-2.5.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c6342f54c67093cae5c0227eb0eb772fdb79f2a2c37a6eb278b9909ee06aa356", size = 17001609, upload-time = "2026-10-10T20:02:40.843Z" }, + { url = "https://files.pythonhosted.org/packages/ff/a9/bac826765e971d8e16e2064e9ac7525fd69b40ac17c905033a7f5442023f/numpy-2.5.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b11e8fda06a7d69f15ebf542660b74466c2e51094800c1fb794f47ad4faeef17", size = 12015718, upload-time = "2026-10-10T20:02:43.45Z" }, + { url = "https://files.pythonhosted.org/packages/31/2f/5ea3570fcb8ccd0882bea99436a513b2c85dad8f774a2057849130a8fb99/numpy-2.5.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9cb18a327b49c5c337f972b03682f6a49855525faaf3c0d3e9c96cd0fd8880a8", size = 5451717, upload-time = "2026-10-10T20:02:46.169Z" }, + { url = "https://files.pythonhosted.org/packages/34/f2/b4fc1bafca03868220b5eaf729d2f21ebd7d7b151c0f9e144fe212bbca35/numpy-2.5.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:aec3fc4b32ff82421274f5d205c559c51c840c8df66a78efd7f3612dd005a26a", size = 6789926, upload-time = "2026-10-10T20:02:48.139Z" }, + { url = "https://files.pythonhosted.org/packages/dc/96/8319e2457ae4333c62c815c7006b869a4f60985c1e01024c2f8c6c040fe5/numpy-2.5.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fe4d21ab149f15e4e6043dfb0de87e6e5f34ac176cde83060e9802981fca2ac2", size = 15695312, upload-time = "2026-10-10T20:02:50.115Z" }, + { url = "https://files.pythonhosted.org/packages/43/a3/c799c62e19c337e6d3770b08e475887fb30ce8477d3c09efca6b2f0228a6/numpy-2.5.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fbde6962867ee75b48b0ee29b2b9372ec5d617799dbaf38e82dc0596f2f7738a", size = 16727283, upload-time = "2026-10-10T20:02:53.186Z" }, + { url = "https://files.pythonhosted.org/packages/39/6b/3604e53fb00314d0dc1b94ec9125a1484f649c0a17480b1f0f0c7a9d6250/numpy-2.5.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:381a7a3d2e65e64c0ec302795ab9dc12bb1e73f150904699c153716177eebdaf", size = 17047890, upload-time = "2026-10-10T20:02:56.038Z" }, + { url = "https://files.pythonhosted.org/packages/4a/7a/e8b58a5289a0d464c52885de47c35a935cdd70c03a4c3ab94a5126416dd0/numpy-2.5.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b89d0aaae2fe498c648f4c4795c084db535af5bd98ef942b2a3681fb74ce8645", size = 18485839, upload-time = "2026-10-10T20:02:59.018Z" }, + { url = "https://files.pythonhosted.org/packages/6f/c9/47094f597015009f310b8c900def59065ef1ff5a6fe7b51fc65ec58ec2c6/numpy-2.5.4-cp312-cp312-win32.whl", hash = "sha256:9968ab7e49b93ac6e1c3b2239732183152c9150f16308d30b66a372cffe3483c", size = 6138936, upload-time = "2026-10-10T20:03:01.626Z" }, + { url = "https://files.pythonhosted.org/packages/12/33/fefe62073dc8acfd0f2b9ed7c003af2f50aa61555e113e6db02b8f79f145/numpy-2.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:a7b1b6353e36a7e50de2973a38d705c88ee93adcf120673cee7f45a4a3fa223a", size = 12573091, upload-time = "2026-10-10T20:03:04.349Z" }, + { url = "https://files.pythonhosted.org/packages/1a/07/161270b0c2eec56e4c905f6d6d22e1b836887b2cb189d3f5820aa588e9dd/numpy-2.5.4-cp312-cp312-win_arm64.whl", hash = "sha256:aa1cce2ff3f8d953de38b76bf44602caeb69f101430208f64a10067f7cb4b1d3", size = 10521630, upload-time = "2026-10-10T20:03:06.767Z" }, +] + [[package]] name = "openapi-schema-validator" version = "0.9.0" @@ -359,6 +593,28 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a2/e8/6d75ffd9784bce2e93d1ae4415649427e39a53bb172d4672b2b59c6f0a7b/pathable-0.6.0-py3-none-any.whl", hash = "sha256:82c4ca6c98c502ad12e0d4e9779b6210afee93c38990988c8c5d1b49bdcdf566", size = 18983, upload-time = "2026-05-19T18:15:10.728Z" }, ] +[[package]] +name = "pillow" +version = "13.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ce/a4/9cc30690a394a8305e8be4c9036aa16d0dfddadd09079860b582f562496d/pillow-13.0.0.tar.gz", hash = "sha256:cdcd1ba258178f7356d74170c9a81ba4eab6a5d55748bc402a5a2a6fe6be3510", size = 47058631, upload-time = "2026-10-16T22:18:09.718Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7a/b8/58d79332229482eb0d27c82973850808c19d37e5bdc14443d3417bd373f5/pillow-13.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:67c8d44ad89fa7eb88de5d6ef6199b1e03dd24974f85a67639fc8badb801fe79", size = 5568643, upload-time = "2026-10-16T22:15:44.474Z" }, + { url = "https://files.pythonhosted.org/packages/39/4b/f2ed53d83aa44ac19599ac0a54897f867fafb95f406980d1e24083f8cbe3/pillow-13.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc481f742ccda20e9ed760b8f978dff50f2a4e9bc253ac167fb0a05b0783ef52", size = 4852329, upload-time = "2026-10-16T22:15:46.284Z" }, + { url = "https://files.pythonhosted.org/packages/3b/bb/9e30e8ed18c20800ee327a12107d5249ad8dc444867b3adfcc21654e3c71/pillow-13.0.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8bf295fe459343bc6093c8e5e0df60bfa189e0fcb775a22e2c2488fdeccc6c0d", size = 6519309, upload-time = "2026-10-16T22:15:48.14Z" }, + { url = "https://files.pythonhosted.org/packages/e6/99/fdf65cc539e266ab93546c261bdf98411fe165c6e4e13f9dbf597097192b/pillow-13.0.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42d63be3af4f9b951b199b0a9d23365d37ab14687e6d77b74940432c8515c4ca", size = 7144542, upload-time = "2026-10-16T22:15:50.093Z" }, + { url = "https://files.pythonhosted.org/packages/26/9b/f38b7c4d8f599537e2d1a6d546cec9beef7536ff8f5c49a3f9c78179d8ac/pillow-13.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4bd024d567eca931b668978d672dba914d4b8e2628e2c3073a2ad178de8a2620", size = 6618042, upload-time = "2026-10-16T22:15:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/a8/7c/45ee28531f89ee4582967d8a17f7a26d71ca64cd902b93c269590cd60a00/pillow-13.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:23edf4ec4b6f4f240e8df6e4985e9ee2ced86474632433e55fb1e2548744bf40", size = 7228137, upload-time = "2026-10-16T22:15:54.009Z" }, + { url = "https://files.pythonhosted.org/packages/01/bc/9c2a969cb1b70201d04fa17fd5aedf02a732870b8da86bceaaa30b0ca385/pillow-13.0.0-cp312-cp312-win32.whl", hash = "sha256:02464da86f561f410e13b061ec37c3068a9cb557a095494157742d07b3c24a27", size = 6515423, upload-time = "2026-10-16T22:15:56.25Z" }, + { url = "https://files.pythonhosted.org/packages/ff/cd/73a79ecdc822076002eb24b5e1e4a530b0bb5310fcb6d239abbec877110b/pillow-13.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:ff3fe9eb621fbb9db4c4be33ab946f6bac5f98ab50ca8d3260503653656c961b", size = 7272166, upload-time = "2026-10-16T22:15:58.597Z" }, + { url = "https://files.pythonhosted.org/packages/4a/a3/be5a1236efd085b3984e4305da8f179ae9dab80c991d2ad78f2bd5c4c843/pillow-13.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:c3bc8ee0271387e0b1e3ad0ff893645990a656e79bf9c42f4f734a3642b11d51", size = 2698943, upload-time = "2026-10-16T22:16:00.637Z" }, + { url = "https://files.pythonhosted.org/packages/60/da/f6d644e631c5b370c5d0b899f3ccadd2780aab070b29a110527cf4e1fd2c/pillow-13.0.0-pp312-pypy312_pp80-macosx_10_15_x86_64.whl", hash = "sha256:8619685cad8efc4c38c66d3b36aad854523297c43d748b3b6f0cc03c90ba3463", size = 5523188, upload-time = "2026-10-16T22:17:59.334Z" }, + { url = "https://files.pythonhosted.org/packages/e4/b0/2594f202d743a35d4fe80682bfd96f277e5ca7aecb27cf64ef5bfc1d000b/pillow-13.0.0-pp312-pypy312_pp80-macosx_11_0_arm64.whl", hash = "sha256:7e91e97a929232cdb828889ee6ad0e48d7f40f4ec38818f4e4a8968b2b1af22e", size = 4806808, upload-time = "2026-10-16T22:18:01.188Z" }, + { url = "https://files.pythonhosted.org/packages/8e/ed/d504165ef79af6fafe25c76726cf30f544cc236002f7ed054f1d51adc4ff/pillow-13.0.0-pp312-pypy312_pp80-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93ff9c9c3663ce23aaa5d0b6b6abac55359e2a0c06c7e30f3771829af816be63", size = 5464358, upload-time = "2026-10-16T22:18:02.779Z" }, + { url = "https://files.pythonhosted.org/packages/7b/fe/a10aba5503ca13e9e009b8bd0a1a4ce5584bdce246245fd6f3a83701369c/pillow-13.0.0-pp312-pypy312_pp80-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e65dd6e75de67b2362a4fa3e16aa627595f65054dc4ec73d64680c84d592fa61", size = 6043514, upload-time = "2026-10-16T22:18:04.538Z" }, + { url = "https://files.pythonhosted.org/packages/c0/37/66b12dc476041fe523bca29c9d58fbf1ea92a4eaf73acfb9e993948f1191/pillow-13.0.0-pp312-pypy312_pp80-win_amd64.whl", hash = "sha256:567f20f1c75897d7663830da6ea8af719e03d712b1d9ee7f813319f9ece42e5a", size = 7366030, upload-time = "2026-10-16T22:18:06.638Z" }, +] + [[package]] name = "pluggy" version = "1.7.0" @@ -368,6 +624,32 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/40/9e/2b38731e0fc536806f16490e1a12d7f0dc2a1235aa8cc07bcc75416a7daa/pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec", size = 27082, upload-time = "2026-10-15T09:50:56.808Z" }, ] +[[package]] +name = "propcache" +version = "0.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b3/9a/9fbf4e4ec0c2d7f1c32519fff782ef467859b8faa9fbc5331a96f6395d43/propcache-0.5.4.tar.gz", hash = "sha256:ff6b113f50bc066a698db5d944d2c6dc7507168dd3341e255a8892fd0715a558", size = 61545, upload-time = "2026-09-16T00:17:14.386Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/cd/348d58f142aebc4873345c6b31087629182ca6e0f2b3caeaa528cf882eba/propcache-0.5.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b28f41fa3b8c6900457f858ec5b03998f3a6d535fbc1bb2edec5961ea05ec429", size = 87285, upload-time = "2026-09-16T00:14:29.362Z" }, + { url = "https://files.pythonhosted.org/packages/df/f4/f3ffaee281b276da854ac1d7a6a506d26cbc62ea2e623756f1d0a4a1ba1a/propcache-0.5.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:dcbf346a318a5e30063f547630b02bb787ce2f45b6368d5da143660b6a3835d8", size = 50984, upload-time = "2026-09-16T00:14:30.473Z" }, + { url = "https://files.pythonhosted.org/packages/25/88/1d7df7201750b37765ef2b23bc1c526c028dadde80afa0f57a118fc01182/propcache-0.5.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:87a3caecf8095e48dc72f84bfa42e23a848cf410cc9cc13031fba4869b706a21", size = 52460, upload-time = "2026-09-16T00:14:31.692Z" }, + { url = "https://files.pythonhosted.org/packages/83/4f/48865bd02a16ee5236bc46166b2946f37b93e07b0eae355dac0be0b216ca/propcache-0.5.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:60a64cbccaa11b7760ce705a14ada17ba459e7ca9f23ba587eb013821032d7ef", size = 251768, upload-time = "2026-09-16T00:14:32.908Z" }, + { url = "https://files.pythonhosted.org/packages/b0/19/3742a5eed62317b03b4002ee865dc9fd720308bdd0da1f29a5786c630311/propcache-0.5.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a74bfa37147cc08fb29df10bd9c16f40fa7f860cd3a6d2fff853323a94f6e17f", size = 257723, upload-time = "2026-09-16T00:14:34.267Z" }, + { url = "https://files.pythonhosted.org/packages/cb/d5/ee6350fb0be9122bb6c67082a876d34b90d980d100c106af4b81023e04f4/propcache-0.5.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a4d7a54719b67338a305dca2ce6aafe366817df94ddfd4b5514374356f5ca546", size = 265597, upload-time = "2026-09-16T00:14:35.56Z" }, + { url = "https://files.pythonhosted.org/packages/85/9f/83a07b6ec0e043c050cfdd35fb0cf1b7897b91d554d6eea293740309afe7/propcache-0.5.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2814ecd8e818f487bee4b0f921bc4d1c176cc5fc71ac0f072d0fa67eda4ac14b", size = 250424, upload-time = "2026-09-16T00:14:36.894Z" }, + { url = "https://files.pythonhosted.org/packages/33/2c/a763a8251f50fba042af0fb1f02bfec4b31381e40aff760db2be7b2e1f84/propcache-0.5.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6af4693716bfb03f1752ef1b30faa593db2c01d5272e9b8564a1549452a979ab", size = 216748, upload-time = "2026-09-16T00:14:38.369Z" }, + { url = "https://files.pythonhosted.org/packages/6a/e2/4d11bea8fd6a777149c6c20645f873952eab5de3a2497aa11648ec9ab6ab/propcache-0.5.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4fbc1a15dc8cd1689508758d626b372b1f09d28d9577667feaf9e6bfcd8efcbc", size = 246533, upload-time = "2026-09-16T00:14:39.82Z" }, + { url = "https://files.pythonhosted.org/packages/9f/36/6683597de4907e70c717e3588c541202c66086a72ff3db58be49de66e72c/propcache-0.5.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:cdee8205a44d0be91bbac4c41b95d86641b72dfc7aef1279400e4fda3f26a937", size = 238173, upload-time = "2026-09-16T00:14:41.259Z" }, + { url = "https://files.pythonhosted.org/packages/85/84/cb08d79f1762daafeb2b030c470cd0c725c97b8ad67412457c6f35c53e9d/propcache-0.5.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9a2a8a50a93dee0268a860a07fa3b4bd968f8ce4dbd794957da772f395368526", size = 251128, upload-time = "2026-09-16T00:14:42.652Z" }, + { url = "https://files.pythonhosted.org/packages/c2/0d/41b848036db6621370c1f2e5471a7da8149c730f8552a5257567721f4576/propcache-0.5.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7ffafcbfc7b549ab940047e505c831eabac5e67de53e1bc174adbc5285c55944", size = 214821, upload-time = "2026-09-16T00:14:44.112Z" }, + { url = "https://files.pythonhosted.org/packages/f1/b7/adfae4bf9c63bccf12e2d9690a175c6579047a6eec3b5a6a5f51428c15e2/propcache-0.5.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:d1f5a500bfcbb2c0ab85e98a0dcd70f5899d34efe365a0187700369a79603031", size = 254793, upload-time = "2026-09-16T00:14:45.429Z" }, + { url = "https://files.pythonhosted.org/packages/51/6f/eeca9647245d5f92e87d53e5f14335bb42fce1a7e6842c8045b364eded8b/propcache-0.5.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8a235f73d6e020855dc29dff012d920c02ee0feab8d73a24185a7569f4be1161", size = 247134, upload-time = "2026-09-16T00:14:46.976Z" }, + { url = "https://files.pythonhosted.org/packages/5d/a9/424e38838793d37160b4379c702f61c74c598fc6cd17204adbe3c554f7a8/propcache-0.5.4-cp312-cp312-win32.whl", hash = "sha256:b3083bfe87f95c756e610bd8025f26cbd1cd4aaa03a422f2d65efb7a97cd53d8", size = 43073, upload-time = "2026-09-16T00:14:48.338Z" }, + { url = "https://files.pythonhosted.org/packages/58/7b/6e8ef26f6d510a7916064fec68d55fcbfbdf7eb01e377480d66a122152d8/propcache-0.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:98914de2c4d7f0f9f4a8c6ea4bf05841f4175796941e3ef7d47eb718f22311fb", size = 46190, upload-time = "2026-09-16T00:14:49.99Z" }, + { url = "https://files.pythonhosted.org/packages/08/b9/72028c5b56ced97f456de6aefa79435ca64d7f77af78ea8cf3c76fc5195f/propcache-0.5.4-cp312-cp312-win_arm64.whl", hash = "sha256:8876b39961e33d912afe3c1bee18ee564fdad0206f873cc15d522756b7f50737", size = 43075, upload-time = "2026-09-16T00:14:51.155Z" }, + { url = "https://files.pythonhosted.org/packages/f5/cd/785c64ed382f3f04201870267b02783f63b4678c2acfddc177a3ebcc2727/propcache-0.5.4-py3-none-any.whl", hash = "sha256:62c60aec739ed00124573cce1178138fd690c7676352d67a37328c1cf51d7468", size = 16338, upload-time = "2026-09-16T00:17:13.106Z" }, +] + [[package]] name = "psycopg" version = "3.3.6" @@ -497,6 +779,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, ] +[[package]] +name = "pyparsing" +version = "3.3.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/11/b213bebff182584360cb8d17c72c1677fec5c5c228de439e63bcf8ab1c8f/pyparsing-3.3.3.tar.gz", hash = "sha256:928ae7e20211f3b6f3915a72f06a0cfd29ab9d24279dd6346b6b1a7146397d36", size = 1050487, upload-time = "2026-09-20T20:59:05.609Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/bb/d215ee7c73b61497b28a5503f9f53523f294fcc936762b7caf90e0c1c2b5/pyparsing-3.3.3-py3-none-any.whl", hash = "sha256:ece8c00a69cf01b45d0b1dedabb469c90d8caf996d4fda40f147627a122849a4", size = 126420, upload-time = "2026-09-20T20:59:04.025Z" }, +] + [[package]] name = "pytest" version = "9.2.0" @@ -513,6 +804,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/51/39/1f5d8c8877a0fa327db959c19341d4be61660de1ab6b7391f9eb805bcd67/pytest-9.2.0-py3-none-any.whl", hash = "sha256:07acdcf88ec174f907dc01af70bf52d49b014bbab03faeeade31c96b18c2e588", size = 411776, upload-time = "2026-10-27T21:30:19.131Z" }, ] +[[package]] +name = "python-dateutil" +version = "4.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/39/b3927f3616f6223832f9b760e4208e8a7c7e1dea2b4d9ad7d32a5d214c3a/python_dateutil-4.0.0.tar.gz", hash = "sha256:d7295ff14fdc0f92f662100bfb6c551d160ca090f2939f1ec5b9794265c03f06", size = 250419, upload-time = "2026-11-01T07:02:42.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2f/a9/52b89563d154433d79b51ed1eb4842bf7334cb2696891a7fe135618853d7/python_dateutil-4.0.0-py3-none-any.whl", hash = "sha256:a5e246f79eb80475e691bf93862cead98decd8a498cf53ba0516fcdc0f50dc1c", size = 92853, upload-time = "2026-11-01T07:02:40.797Z" }, +] + [[package]] name = "python-dotenv" version = "1.2.4" @@ -699,3 +1002,34 @@ sdist = { url = "https://files.pythonhosted.org/packages/da/34/30e9280707135d2cf wheels = [ { url = "https://files.pythonhosted.org/packages/38/0c/b54a4fdd7f90a3af8b02ebc9ce6712c2c208b7926a2f7bad95c33ebbe943/uvicorn-0.54.0-py3-none-any.whl", hash = "sha256:505bdb0f318731d45f1f712071fc781a8981f6847a31c902c9f5e652d4f67faf", size = 87427, upload-time = "2026-09-25T06:52:35.829Z" }, ] + +[[package]] +name = "yarl" +version = "1.25.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/75/16/e8be8e2fb175bbf41a0680381a319f1199fae256588241a2ac8677eafb49/yarl-1.25.1.tar.gz", hash = "sha256:03dd38de09bc213e9a8b29761eec33ee1d5318dac0e49d8af36e4d27830e23a7", size = 246245, upload-time = "2026-09-15T19:35:02.264Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/75/b3/cd32ac66ae622b854c2df0ac52106dda220d361b65a64fde7d5b3684aa3f/yarl-1.25.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:94d7aa6debf92a1dd14cb5280b083a764169a13cfb23a452111160274ed989f4", size = 144798, upload-time = "2026-09-15T19:31:01.821Z" }, + { url = "https://files.pythonhosted.org/packages/61/fb/a2c52a8007c2051ba74662afb112ecf3d00346af4c25e33df9d80fd14fb8/yarl-1.25.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:83d4a37e4b95da4d8bda930d6d35b75b4cdadbacbb4980cae290ea3100b5d51d", size = 104583, upload-time = "2026-09-15T19:31:04.05Z" }, + { url = "https://files.pythonhosted.org/packages/be/dd/ee38aec8e09fdf957e50d4085453fbe202f56c6c3b4cf07b81cdb4f09ee9/yarl-1.25.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e029648f9c951db30e98a7d7ec90835db88ec4b32820efe2a9bdc2287e032eb6", size = 104325, upload-time = "2026-09-15T19:31:06.338Z" }, + { url = "https://files.pythonhosted.org/packages/1e/b3/058dbfb1857b484c9cf9cc135659f50b85ce66e03c99e44dc2f7b6161f55/yarl-1.25.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d781294bb815ecb5ea57ff6bbf8038e0a31a95fdf3e1788f66e0dc100d64b58", size = 115358, upload-time = "2026-09-15T19:31:08.593Z" }, + { url = "https://files.pythonhosted.org/packages/db/39/29693446cf0cf6b15a0e2f75a5d40f93c56819b05b0622196f45e95b5cc0/yarl-1.25.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e12c538e00e7c1b286a07061046b90e8124e6a9793efae2c70db6a4aad07faad", size = 107658, upload-time = "2026-09-15T19:31:10.802Z" }, + { url = "https://files.pythonhosted.org/packages/86/b3/3c4dd7e1af43b931fba95e0a722737f2ea94a6d199c802585282831d7abd/yarl-1.25.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e4de3ac4adbad3d0bc7c6f4360a7dbff5de2f15e3b723be3198074e17fd9c40", size = 122660, upload-time = "2026-09-15T19:31:12.84Z" }, + { url = "https://files.pythonhosted.org/packages/bd/b5/1b60dbc3cfc9c5712b15148c206748f2bc93953ffdbe25ea75b63dfc89c9/yarl-1.25.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:419f392a1da624877975709e3864dfe833af6cc7671b39318086d456e288380c", size = 126506, upload-time = "2026-09-15T19:31:15.088Z" }, + { url = "https://files.pythonhosted.org/packages/bc/7b/ca212cbe170ac8b96e45317ecbcf9c3c3ecf0cdec98d5b088a9c4088929b/yarl-1.25.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6f117789d22dce188e5754e8bc65b7e6ebf8cb73963b9fa761f672a5883769d", size = 117050, upload-time = "2026-09-15T19:31:17.241Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c3/72b4938cdbe619ad71ac156182faef4908846b84dc3ca4dbb4c4e6f84014/yarl-1.25.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80e47012e730da131c9f059c80936783f9659aae22dc31c03c0595590d11ed54", size = 114174, upload-time = "2026-09-15T19:31:19.294Z" }, + { url = "https://files.pythonhosted.org/packages/e8/43/268717870f9ba0cc9701a95181587f6dc8c5f387aab4aeecc83158f38a79/yarl-1.25.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e80f557716fd765439577131e526b8942ffc2c07bdbc5e39fa62f660ba1e963f", size = 114944, upload-time = "2026-09-15T19:31:21.414Z" }, + { url = "https://files.pythonhosted.org/packages/da/84/baa5bf504d51fe062c4bcaf62936da97fffb43285978d0b39984824231fd/yarl-1.25.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f61964f235a43738bfac50da46fc4254943a7eea3051aeb0b6fc7c992c29fadc", size = 108263, upload-time = "2026-09-15T19:31:23.388Z" }, + { url = "https://files.pythonhosted.org/packages/a4/28/779a2ed9e0152a601a27039bed9aead3f0b79797a67e2c44bfa444622dd8/yarl-1.25.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e546fe1d4a93ebc2910f0d768baff19faa09843ab3f2036a67ed6e69fae4419d", size = 122184, upload-time = "2026-09-15T19:31:25.343Z" }, + { url = "https://files.pythonhosted.org/packages/f8/1f/118e9e5b8f07694d63fd3222e801d7782270003f1a222aa798df3f8d5933/yarl-1.25.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cce0727fd5ac04d372fa9bbfde9febc2bcf209aadfcf0468e45dec72719895d1", size = 114001, upload-time = "2026-09-15T19:31:27.465Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ae/a4cf1cf372313734b17996d4007f9f73596e7a178b9485802e5494ecf484/yarl-1.25.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af4ea5b37403ef4e30f3927eaed540db942bde01d8d3ff083527c0704d1c9c68", size = 120565, upload-time = "2026-09-15T19:31:29.47Z" }, + { url = "https://files.pythonhosted.org/packages/05/79/ad94f93ca731bc9e44d321833ab96b82a4f9f5f63cf773f81a4aeea5ecc1/yarl-1.25.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:68782fdb4027b8d1eee25ec35e9a6db05e863b899eb0310b3a33b6c3fef55707", size = 117060, upload-time = "2026-09-15T19:31:31.367Z" }, + { url = "https://files.pythonhosted.org/packages/bb/cc/51a7b4abf4ac593b8e7eb3794b28e5a35ae26eed8bc04787628d215af82f/yarl-1.25.1-cp312-cp312-win_amd64.whl", hash = "sha256:7d575b54cb3863ef9bc290ea4b009999d55dc237326131e4853cf33e888fee03", size = 102593, upload-time = "2026-09-15T19:31:33.329Z" }, + { url = "https://files.pythonhosted.org/packages/9d/21/0941a6b93a58b59a1ec75e5333bf06929b671309c43c0cd201c172d9c39f/yarl-1.25.1-cp312-cp312-win_arm64.whl", hash = "sha256:bc3ac7bf569f6b64dad04dd7808c7872dae8a97df657856eac05e9b7e3614a85", size = 97697, upload-time = "2026-09-15T19:31:35.855Z" }, + { url = "https://files.pythonhosted.org/packages/54/22/318c7980066769c6bcd9221ed2248294f5698811da099013098c670565ed/yarl-1.25.1-py3-none-any.whl", hash = "sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3", size = 63617, upload-time = "2026-09-15T19:34:59.616Z" }, +] -- 2.54.0 From d7d1bbaff8d6953445a7fd036fd698b6d1a43b0d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=92=D0=B0=D1=81=D0=B8=D0=BB=D1=8C=D0=B5=D0=B2=20=D0=9D?= =?UTF-8?q?=D0=B8=D0=BA=D0=B8=D1=82=D0=B0?= Date: Fri, 6 Nov 2026 18:21:47 +0300 Subject: [PATCH 3/4] Reject noncanonical cursor dates and noninteger cursor versions --- REPORT.md | 6 ++--- evidence/cursor-format-unit.txt | 2 ++ evidence/tests-final.txt | 6 ++--- src/messenger/domain.py | 13 ++++++++-- student-tests/test_cursor_format.py | 39 +++++++++++++++++++++++++++++ student-tests/test_lab3.py | 36 ++++++++++++++++++++++++++ 6 files changed, 94 insertions(+), 8 deletions(-) create mode 100644 evidence/cursor-format-unit.txt create mode 100644 student-tests/test_cursor_format.py diff --git a/REPORT.md b/REPORT.md index 21698d52..69a830ad 100644 --- a/REPORT.md +++ b/REPORT.md @@ -64,7 +64,7 @@ ConnecttimeoutLB1s, server8s, client10s, queuetimeout2s, transparent retries0. U ## Проверки уровней3–4 - [Публичный контракт и схема](evidence/contract-validation.txt):PASS. -- [Собственные тесты](evidence/tests-final.txt):77PASS, включая20конкурентных повторов через≥2API, bodyconflict, scopes, NUL, Unicode, malformedUTF8, Basicbody, cursor и заголовки. +- [Собственные тесты](evidence/tests-final.txt):98PASS, включая11unit-регрессий форматаcursor,10HTTP-регрессийcursorнаобоихмаршрутах,20конкурентных повторов через≥2API, bodyconflict, scopes, NUL, Unicode, malformedUTF8, Basicbody, cursor и заголовки. - [Независимые HTTP-регрессии](evidence/independent-http.json):61PASS. - [Независимые отказы](evidence/independent-faults.json):4PASS — ACLдоreplay, исчезновение обязательной таблицы, pausedPG с503примерно3.08s и восстановлением, logout под блокировкой с последующим отзывом. - [LB без готовых API](evidence/lb-no-ready-api.json):503JSON, новыйX-Request-Idсовпадаетсerror.request_id, фиктивногоX-Instance-Idнет; прежняя сессия работает после восстановления. @@ -91,7 +91,7 @@ uv run --locked python scripts/verify_teacher_http.py --lab 3 --repo . --base-ur uv run --locked python scripts/verify_teacher_faults.py --output evidence/teacher-faults-repeat.json ``` -Проверки отказов запускаются последовательно, не одновременно с нагрузочным исследованием. restart-hook сохраняет безопасные snapshots StartedAt/ID до и после, чтобы доказать перезапуск API,LB,PGиValkey. Все shellhooks executable100755. +Проверки отказов запускаются последовательно, не одновременно с нагрузочным исследованием. restart-hook сохраняет безопасные snapshots StartedAt/ID до и после, чтобы доказать перезапуск API,LB,PGиValkey. Все shellhooks executable100755. Cursorпринимает только собственный каноническийформатYYYY-MM-DDTHH:MM:SS(.1..6digits)?Z, с календарной проверкой и целойверсией1; PythonISO-расширения не доходят доSQL. Rolling-target отличается revision-label, функциональный код и схема одинаковы. Этот опыт доказывает поочерёдную замену образа и процессов под трафиком, но не совместимость произвольного нового кода/схемы. Первоначальная миграция003с textнаbytea требует maintenancewindow со старой ЛР2; ограничения не скрываются. @@ -134,7 +134,7 @@ Rolling-target отличается revision-label, функциональный [Ресурсные графики](evidence/scaling-final-resources.svg) показывают CPUБД, CPUгенератора и droppedslots. Калибровочныеpilotфайлы сохранены отдельно и в63основных прогона не входят; обратный контроль —ещё3отдельныхпрогона. -Runtimeисследования соответствует commit029bf9b, sourceSHA256записаны в JSON. Форматирование runnerбез изменения поведения отражено в [manifest](evidence/research-runner-manifest.json). После измерений добавлен только JSON503для случая отсутствия готовых backend; прежняя конфигурация сохранена в [haproxy-benchmark.cfg](evidence/haproxy-benchmark.cfg). Это изменение пути отказа не является измеренным улучшениемthroughput. +Runtimeисследования соответствует commit029bf9b, sourceSHA256записаны в JSON. Форматирование runnerбез изменения поведения отражено в [manifest](evidence/research-runner-manifest.json). После измерений добавлены JSON503для случая отсутствия готовых backend и строгая валидация некорректногоcursor (ISOweek/basic/не-T,True/1.0вместоцелойверсии). Измеренный профиль отправки сообщений cursorне использует; прежняя конфигурация сохранена в [haproxy-benchmark.cfg](evidence/haproxy-benchmark.cfg). Это изменение пути отказа не является измеренным улучшениемthroughput. После опыта штатные2API и PostgreSQL1CPUвосстановлены. Копии результатов не содержат токенов и секретов. diff --git a/evidence/cursor-format-unit.txt b/evidence/cursor-format-unit.txt new file mode 100644 index 00000000..cc256eb6 --- /dev/null +++ b/evidence/cursor-format-unit.txt @@ -0,0 +1,2 @@ +........... [100%] +11 passed in 0.01s diff --git a/evidence/tests-final.txt b/evidence/tests-final.txt index d3f6ea76..a19c0fd7 100644 --- a/evidence/tests-final.txt +++ b/evidence/tests-final.txt @@ -1,4 +1,4 @@ BASE_URL=http://127.0.0.1:8083 uv run --locked pytest -q -........................................................................ [ 93%] -..... [100%] -77 passed in 26.61s +........................................................................ [ 73%] +.......................... [100%] +98 passed in 31.45s diff --git a/src/messenger/domain.py b/src/messenger/domain.py index 1415db7e..7d1a462a 100644 --- a/src/messenger/domain.py +++ b/src/messenger/domain.py @@ -30,10 +30,19 @@ def boundary(scope: str, cursor: str | None) -> tuple[str, str] | None: if not cursor or len(cursor) > 1024 or not re.fullmatch(r"[A-Za-z0-9_-]+", cursor): raise ValueError data = json.loads(base64.urlsafe_b64decode(cursor + "=" * (-len(cursor) % 4))) - if not isinstance(data, list) or len(data) != 4 or data[:2] != [1, scope]: + if ( + not isinstance(data, list) + or len(data) != 4 + or type(data[0]) is not int + or data[0] != 1 + or data[1] != scope + ): raise ValueError date, uid = data[2:] - if not isinstance(date, str) or not date.endswith("Z"): + if not isinstance(date, str) or not re.fullmatch( + r"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]{1,6})?Z", + date, + ): raise ValueError datetime.fromisoformat(date.replace("Z", "+00:00")) if not isinstance(uid, str) or str(UUID(uid)) != uid: diff --git a/student-tests/test_cursor_format.py b/student-tests/test_cursor_format.py new file mode 100644 index 00000000..ceb15c54 --- /dev/null +++ b/student-tests/test_cursor_format.py @@ -0,0 +1,39 @@ +import base64 +import json +from uuid import uuid4 + +import pytest + +from messenger.domain import Failure, boundary + + +@pytest.mark.parametrize( + "version,date", + [ + (True, "2026-01-01T00:00:00Z"), + (1.0, "2026-01-01T00:00:00Z"), + (1, "2026-W01-1T00:00:00Z"), + (1, "20260101T000000Z"), + (1, "2026-01-01 00:00:00Z"), + (1, "2026-01-01X00:00:00Z"), + (1, "2026-02-30T00:00:00Z"), + (1, "2026-01-01T00:00:00.1234567Z"), + ], +) +def test_boundary_rejects_python_iso_extensions(version, date): + payload = [version, "scope", date, str(uuid4())] + cursor = base64.urlsafe_b64encode(json.dumps(payload).encode()).decode().rstrip("=") + with pytest.raises(Failure) as error: + boundary("scope", cursor) + assert error.value.status == 400 + + +@pytest.mark.parametrize( + "date", ["2026-01-01T00:00:00Z", "2026-01-01T00:00:00.1Z", "2026-01-01T00:00:00.123456Z"] +) +def test_boundary_preserves_generated_format(date): + uid = str(uuid4()) + cursor = ( + base64.urlsafe_b64encode(json.dumps([1, "scope", date, uid]).encode()).decode().rstrip("=") + ) + assert boundary("scope", cursor) == (date, uid) diff --git a/student-tests/test_lab3.py b/student-tests/test_lab3.py index e89967b7..aa5b738a 100644 --- a/student-tests/test_lab3.py +++ b/student-tests/test_lab3.py @@ -143,3 +143,39 @@ def test_login_body_is_rejected(shared): raw=body, headers={"Authorization": "Basic " + basic}, ) + + +@pytest.mark.parametrize( + "date", + [ + "2026-W01-1T00:00:00Z", + "20260101T000000Z", + "2026-01-01 00:00:00Z", + "2026-01-01X00:00:00Z", + "2026-01-01T00:00:00+00:00", + "2026-02-30T00:00:00Z", + "2026-01-01T24:00:00Z", + "2026-01-01T00:00:00.1234567Z", + ], +) +def test_cursor_rejects_noncanonical_dates_over_http(shared, date): + c, alice, _, _, chat = shared + for path, scope in [ + ("/api/v1/chats", "chats:" + alice["id"]), + (f"/api/v1/chats/{chat['id']}/messages", "messages:" + chat["id"]), + ]: + payload = [1, scope, date, str(uuid.uuid4())] + cursor = base64.urlsafe_b64encode(json.dumps(payload).encode()).decode().rstrip("=") + c.call("GET", path + "?cursor=" + cursor, 400, actor=alice) + + +@pytest.mark.parametrize("version", [True, 1.0]) +def test_cursor_rejects_noninteger_version_over_http(shared, version): + c, alice, _, _, chat = shared + for path, scope in [ + ("/api/v1/chats", "chats:" + alice["id"]), + (f"/api/v1/chats/{chat['id']}/messages", "messages:" + chat["id"]), + ]: + payload = [version, scope, "2026-01-01T00:00:00Z", str(uuid.uuid4())] + cursor = base64.urlsafe_b64encode(json.dumps(payload).encode()).decode().rstrip("=") + c.call("GET", path + "?cursor=" + cursor, 400, actor=alice) -- 2.54.0 From d235255cf3ad87e1f11a69b5aa9e4824db90c4b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=92=D0=B0=D1=81=D0=B8=D0=BB=D1=8C=D0=B5=D0=B2=20=D0=9D?= =?UTF-8?q?=D0=B8=D0=BA=D0=B8=D1=82=D0=B0?= Date: Fri, 6 Nov 2026 18:57:16 +0300 Subject: [PATCH 4/4] Enforce UTF-8 JSON encoding before any business write --- REPORT.md | 5 +- evidence/json-encoding-runtime.json | 22 +++++ evidence/json-encoding.txt | 2 + evidence/tests-final.txt | 6 +- research/README.md | 4 + src/messenger/app.py | 19 ++++ student-tests/test_json_encoding.py | 140 ++++++++++++++++++++++++++++ 7 files changed, 193 insertions(+), 5 deletions(-) create mode 100644 evidence/json-encoding-runtime.json create mode 100644 evidence/json-encoding.txt create mode 100644 student-tests/test_json_encoding.py diff --git a/REPORT.md b/REPORT.md index 69a830ad..14915eeb 100644 --- a/REPORT.md +++ b/REPORT.md @@ -64,7 +64,8 @@ ConnecttimeoutLB1s, server8s, client10s, queuetimeout2s, transparent retries0. U ## Проверки уровней3–4 - [Публичный контракт и схема](evidence/contract-validation.txt):PASS. -- [Собственные тесты](evidence/tests-final.txt):98PASS, включая11unit-регрессий форматаcursor,10HTTP-регрессийcursorнаобоихмаршрутах,20конкурентных повторов через≥2API, bodyconflict, scopes, NUL, Unicode, malformedUTF8, Basicbody, cursor и заголовки. +- [Собственные тесты](evidence/tests-final.txt):124PASS, включая26HTTP-проверокJSONкодировкибезпобочныхзаписей,11unit-регрессий форматаcursor,10HTTP-регрессийcursorнаобоихмаршрутах,20конкурентных повторов через≥2API, bodyconflict, scopes, NUL, Unicode, malformedUTF8, Basicbody, cursor и заголовки. +- [JSONUTF-8](evidence/json-encoding.txt):8вариантовUTF-16/32/BOM/LE/BEна3маршрутахотклонены400беззаписи; validUTF-8иUTF-8BOM,UnicodeиescapedNULприняты. - [Независимые HTTP-регрессии](evidence/independent-http.json):61PASS. - [Независимые отказы](evidence/independent-faults.json):4PASS — ACLдоreplay, исчезновение обязательной таблицы, pausedPG с503примерно3.08s и восстановлением, logout под блокировкой с последующим отзывом. - [LB без готовых API](evidence/lb-no-ready-api.json):503JSON, новыйX-Request-Idсовпадаетсerror.request_id, фиктивногоX-Instance-Idнет; прежняя сессия работает после восстановления. @@ -134,7 +135,7 @@ Rolling-target отличается revision-label, функциональный [Ресурсные графики](evidence/scaling-final-resources.svg) показывают CPUБД, CPUгенератора и droppedslots. Калибровочныеpilotфайлы сохранены отдельно и в63основных прогона не входят; обратный контроль —ещё3отдельныхпрогона. -Runtimeисследования соответствует commit029bf9b, sourceSHA256записаны в JSON. Форматирование runnerбез изменения поведения отражено в [manifest](evidence/research-runner-manifest.json). После измерений добавлены JSON503для случая отсутствия готовых backend и строгая валидация некорректногоcursor (ISOweek/basic/не-T,True/1.0вместоцелойверсии). Измеренный профиль отправки сообщений cursorне использует; прежняя конфигурация сохранена в [haproxy-benchmark.cfg](evidence/haproxy-benchmark.cfg). Это изменение пути отказа не является измеренным улучшениемthroughput. +Runtimeисследования соответствует commit029bf9b, sourceSHA256записаны в JSON. Форматирование runnerбез изменения поведения отражено в [manifest](evidence/research-runner-manifest.json). После измерений добавлены JSON503для случая отсутствия готовых backend и строгая валидация некорректногоcursor (ISOweek/basic/не-T,True/1.0вместоцелойверсии). Измеренный профиль отправки сообщений cursorне использует; прежняя конфигурация сохранена в [haproxy-benchmark.cfg](evidence/haproxy-benchmark.cfg). После повторного review также добавлен строгий UTF-8 encodingguard на обычном POSTпути users/chats/messages: UTF-16/32 и literalNULотклоняются до записи, escapedJSON\u0000 и UTF-8/BOM сохраняются. Binaryattachments этим guardне затрагиваются. Числа исследования относятся к зафиксированному snapshot029bf9bдо этого guard; его накладные расходы в исходной матрице не измерялись. Последующие исправления корректности не заявляются как измеренное улучшениеthroughput, rawданные не переписывались. После опыта штатные2API и PostgreSQL1CPUвосстановлены. Копии результатов не содержат токенов и секретов. diff --git a/evidence/json-encoding-runtime.json b/evidence/json-encoding-runtime.json new file mode 100644 index 00000000..a58c72ff --- /dev/null +++ b/evidence/json-encoding-runtime.json @@ -0,0 +1,22 @@ +{ + "pass": true, + "api_count": 2, + "containers": [ + "492e68cf4865e27c8d2a945ee2abd55b5f06b646070b2e2a97a22fd5327139da", + "d4670b5fd787a9b298fe6b56504a6b9f669961d6d25f638c16e43b4dc7c5cfe3" + ], + "source_manifest": { + "src/messenger/__init__.py": "9a72a49106367ca514cc6147d0e727e62c4d33fefd61572d209a5c9494551a2c", + "src/messenger/__main__.py": "ba9a59ad44ee8884cd65cf88d5ea15cbd7051b10f7c729043ddd44ca2f34defe", + "src/messenger/app.py": "77c8defefc6316b2bf1f91f6129e3959a2ac0e3b9d45ff8978f051e9e942f1c8", + "src/messenger/config.py": "e4d4aaf674ede8b5abdc361f77c7793ee94d8d7856030c28834eb7c95291b193", + "src/messenger/domain.py": "7bf6f177ab5bdeea09b303dc886160335d348f64f47912b9bba45355db378bef", + "src/messenger/migrate.py": "eb5cad7ac6abe38dd40b2db307d298b297abe9543b3928c36bab8ef06283664e", + "src/messenger/models.py": "0ca8f9a3a43833ebf0c0b14e05d77c3e1ab48394d15c6b6d678689d40b4cd416", + "src/messenger/postgres.py": "449ac90643222e5e1437df2f33ed3584dc9ccb7579c10beae4e8d710a4aae052", + "migrations/001_initial.sql": "5d88cd12ef9fda008832dc0b886fa0cf5d886738fe9b77180cdc65adac50dfd9", + "migrations/002_idempotency.sql": "82b41be828ad55ec5c1d991775528e7fe6766c362fa58a2c4f46690459b2c00d", + "migrations/003_unicode_storage.sql": "7282a55da4aa081f7d3d99692e11eeb7a49feab9c9f829a09d3d72dc74009643" + }, + "note": "Actual runtime sources match the UTF8-guard working tree before final source commit; full124 and encoding26 HTTP tests passed." +} diff --git a/evidence/json-encoding.txt b/evidence/json-encoding.txt new file mode 100644 index 00000000..3f1d2962 --- /dev/null +++ b/evidence/json-encoding.txt @@ -0,0 +1,2 @@ +.......................... [100%] +26 passed in 2.12s diff --git a/evidence/tests-final.txt b/evidence/tests-final.txt index a19c0fd7..3d75ab00 100644 --- a/evidence/tests-final.txt +++ b/evidence/tests-final.txt @@ -1,4 +1,4 @@ BASE_URL=http://127.0.0.1:8083 uv run --locked pytest -q -........................................................................ [ 73%] -.......................... [100%] -98 passed in 31.45s +........................................................................ [ 58%] +.................................................... [100%] +124 passed in 24.37s diff --git a/research/README.md b/research/README.md index ee1285bb..d02ed51b 100644 --- a/research/README.md +++ b/research/README.md @@ -46,3 +46,7 @@ HTTPxpilot при300offered/s показал schedulerlag312ms и633drops. Он ## Дополнительный обратный контроль После основной матрицы `uv run --locked python research/reversal.py` возвращает PostgreSQL0.25CPUпри техже4API, выполняет3×6sна900offered/s и восстанавливает штатный стенд. Результат отдельно в evidence/scaling-reversal.json, в63основных прогона он не включается. После основного опыта CPUконтроль далмедиану465.411RPSпротив881.06при0.5CPU, что снижает риск объяснить выигрыш только поздним прогревом. + +## Snapshot и последующие исправления + +Сохранённая матрица измерена на runtime029bf9b; его SHA256manifest присутствует в rawJSON. После измерений добавлены формат LB503, строгая валидация malformedcursor и UTF-8guard JSONPOST. Последний guard выполняется и на нормальном пути POST, поэтому опубликованные значения относятся именно к recorded snapshot, а не к замеру финального runtime после guard. Его отдельная накладная стоимость не измерялась; запуск runner на текущем HEAD даст новые измерения. Исходные JSON и графики исторического опыта не переписывались. diff --git a/src/messenger/app.py b/src/messenger/app.py index 7f1a820f..bb514b9a 100644 --- a/src/messenger/app.py +++ b/src/messenger/app.py @@ -60,6 +60,23 @@ def error(request, status, message, headers=None): ) +async def invalid_json_encoding(request: Request): + path = request.url.path + if request.method != "POST" or not ( + path in {"/api/v1/users", "/api/v1/chats"} + or re.fullmatch(r"/api/v1/chats/[^/]+/messages", path) + ): + return False + raw = await request.body() + try: + raw.decode("utf-8") + except UnicodeDecodeError: + return True + # Literal NUL is invalid JSON; it also prevents json.loads(bytes) from + # autodetecting BOM-less UTF-16/32. Escaped JSON \u0000 remains valid. + return b"\x00" in raw + + @app.middleware("http") async def request_log(request: Request, call_next): request.state.request_id = str(uuid4()) @@ -67,6 +84,8 @@ async def request_log(request: Request, call_next): try: if request.method == "POST" and request.url.path == "/api/v1/auth/sessions" and await request.body(): response = error(request, 400, "Вход не принимает тело запроса") + elif await invalid_json_encoding(request): + response = error(request, 400, "JSON должен быть закодирован в UTF-8") else: response = await call_next(request) except Exception: diff --git a/student-tests/test_json_encoding.py b/student-tests/test_json_encoding.py new file mode 100644 index 00000000..b614d873 --- /dev/null +++ b/student-tests/test_json_encoding.py @@ -0,0 +1,140 @@ +import base64 +import codecs +import json +import os +import uuid + +import pytest +from client import Client + +ENCODINGS = [ + "utf-16", + "utf-16-le", + "utf-16-be", + "utf-16-be-bom", + "utf-32", + "utf-32-le", + "utf-32-be", + "utf-32-be-bom", +] + + +def encoded(body, encoding): + text = json.dumps(body, ensure_ascii=False) + if encoding == "utf-16-be-bom": + return codecs.BOM_UTF16_BE + text.encode("utf-16-be") + if encoding == "utf-32-be-bom": + return codecs.BOM_UTF32_BE + text.encode("utf-32-be") + return text.encode(encoding) + + +@pytest.fixture(scope="module") +def encoding_scenario(): + c = Client(os.environ["BASE_URL"]) + return c, *c.bootstrap() + + +@pytest.mark.parametrize("encoding", ENCODINGS) +def test_non_utf8_registration_has_no_write(encoding_scenario, encoding): + c, *_ = encoding_scenario + body = { + "username": "enc_" + uuid.uuid4().hex[:14], + "display_name": "Никита\u0000имя", + "password": "Пароль:тестовый-12345", + } + c.call( + "POST", + "/api/v1/users", + 400, + raw=encoded(body, encoding), + headers={"Content-Type": "application/json"}, + ) + # UNIQUE username proves the rejected request did not insert a user. + created = c.call("POST", "/api/v1/users", 201, body=body, schema="User")["json"] + assert created["display_name"] == body["display_name"] + + +@pytest.mark.parametrize("encoding", ENCODINGS) +def test_non_utf8_chat_has_no_write(encoding_scenario, encoding): + c, alice, *_ = encoding_scenario + before = c.call("GET", "/api/v1/chats?limit=100", actor=alice, schema="ChatPage")["json"] + body = {"title": "Чат\u0000" + uuid.uuid4().hex, "member_ids": [alice["id"]]} + c.call( + "POST", + "/api/v1/chats", + 400, + actor=alice, + raw=encoded(body, encoding), + headers={"Content-Type": "application/json"}, + ) + after = c.call("GET", "/api/v1/chats?limit=100", actor=alice, schema="ChatPage")["json"] + assert before == after + assert ( + c.call("POST", "/api/v1/chats", 201, actor=alice, body=body, schema="Chat")["json"]["title"] + == body["title"] + ) + + +@pytest.mark.parametrize("encoding", ENCODINGS) +def test_non_utf8_message_has_no_write(encoding_scenario, encoding): + c, alice, _, _, chat = encoding_scenario + path = f"/api/v1/chats/{chat['id']}/messages" + key = uuid.uuid4().hex + body = {"text": "Сообщение\u0000" + key} + c.call( + "POST", + path, + 400, + actor=alice, + raw=encoded(body, encoding), + headers={"Content-Type": "application/json", "Idempotency-Key": key}, + ) + history = c.call("GET", path + "?limit=100", actor=alice, schema="MessagePage")["json"]["items"] + assert all(item["text"] != body["text"] for item in history) + good = c.call( + "POST", + path, + 201, + actor=alice, + body=body, + headers={"Idempotency-Key": key}, + schema="Message", + )["json"] + repeat = c.call( + "POST", + path, + 201, + actor=alice, + body=body, + headers={"Idempotency-Key": key}, + schema="Message", + )["json"] + assert good == repeat and good["text"] == body["text"] + + +@pytest.mark.parametrize("encoding", ["utf-8", "utf-8-sig"]) +def test_valid_utf8_registration_and_login(encoding_scenario, encoding): + c, *_ = encoding_scenario + body = { + "username": "utf8_" + uuid.uuid4().hex[:14], + "display_name": "Юникод\u0000😀", + "password": "Пароль:тестовый-12345", + } + user = c.call( + "POST", + "/api/v1/users", + 201, + raw=encoded(body, encoding), + headers={"Content-Type": "application/json"}, + schema="User", + )["json"] + assert user["display_name"] == body["display_name"] + credential = base64.b64encode((body["username"] + ":" + body["password"]).encode()).decode() + session = c.call( + "POST", + "/api/v1/auth/sessions", + 201, + headers={"Authorization": "Basic " + credential}, + schema="Session", + )["json"] + assert session["user"] == user -- 2.54.0