perf(cache): add epoch strategy benchmarks and history query analysis

This commit is contained in:
2026-10-14 06:29:32 +03:00
parent 6cccda14d2
commit 68664073ff
13 changed files with 2262 additions and 0 deletions
+50
View File
@@ -0,0 +1,50 @@
import { createRequire } from 'node:module';
import { randomUUID } from 'node:crypto';
import { performance } from 'node:perf_hooks';
const require = createRequire(`${process.cwd()}/package.json`);
const { NestFactory } = require('@nestjs/core');
const { AppModule } = require(`${process.cwd()}/dist/app.module`);
const { PrismaService } = require(`${process.cwd()}/dist/prisma/prisma.service`);
const { UserService } = require(`${process.cwd()}/dist/User/user.service`);
const { PasswordService } = require(`${process.cwd()}/dist/Auth/password.service`);
const { createFastifyAdapter } = require(`${process.cwd()}/dist/common/http/fastify-adapter`);
process.env.CACHE_URL = '';
const app = await NestFactory.create(AppModule, createFastifyAdapter(), { logger: false, abortOnError: false });
await app.init();
require('nestjs-pino').PinoLogger.root.level = 'silent';
const server = app.getHttpAdapter().getInstance();
await server.ready();
const prisma = app.get(PrismaService);
const passwords = app.get(PasswordService);
const originalHash = passwords.hash.bind(passwords);
const spans = [];
passwords.hash = async (password) => {
const start = performance.now();
const value = await originalHash(password);
spans.push({ phase: 'kdf', ms: Math.round(performance.now() - start) });
return value;
};
app.get(UserService).prisma = prisma.$extends({ query: { user: { async create({ args, query }) {
const start = performance.now();
const value = await query(args);
spans.push({ phase: 'sql_user_create', ms: Math.round(performance.now() - start) });
return value;
} } } });
const ids = [];
try {
const health = await server.inject({ method: 'GET', url: '/health/ready' });
console.log(JSON.stringify({ phase: 'health', status: health.statusCode }));
for (let sample = 1; sample <= 3; sample++) {
spans.length = 0;
const start = performance.now();
const response = await server.inject({ method: 'POST', url: '/api/v1/users', payload: {
username: `warm_${randomUUID().replaceAll('-', '').slice(0, 20)}`,
display_name: 'Synthetic startup diagnostic', password: 'Synthetic-diagnostic-password-123',
} });
if (response.statusCode === 201) ids.push(response.json().id);
console.log(JSON.stringify({ sample, status: response.statusCode, total_ms: Math.round(performance.now() - start), spans }));
}
} finally {
await prisma.user.deleteMany({ where: { id: { in: ids } } });
await app.close();
}
+538
View File
@@ -0,0 +1,538 @@
import assert from 'node:assert/strict';
import { createHash, randomBytes, randomUUID } from 'node:crypto';
import { createRequire } from 'node:module';
import { readFile, writeFile } from 'node:fs/promises';
import { performance } from 'node:perf_hooks';
import { faultProxy } from './helpers/fault-proxy.mjs';
import { messageEpoch } from './helpers/message-epoch.mjs';
const require = createRequire(`${process.cwd()}/package.json`);
const pg = require('pg');
let counts = {};
const originalQuery = pg.Client.prototype.query;
pg.Client.prototype.query = function (query, ...args) {
const sql = typeof query === 'string' ? query : query.text;
const verb = sql.trim().split(/\s+/)[0].toUpperCase();
const table =
['messages', 'chat_members', 'sessions', 'users', 'chats'].find((name) =>
new RegExp(`\\b${name}\\b`).test(sql),
) ?? 'other';
const label = `${verb}:${table}`;
counts[label] = (counts[label] ?? 0) + 1;
return originalQuery.call(this, query, ...args);
};
const Redis = require('ioredis').default;
const { NestFactory } = require('@nestjs/core');
const { AppModule } = require(`${process.cwd()}/dist/app.module`);
const { PrismaService } = require(
`${process.cwd()}/dist/prisma/prisma.service`,
);
const { CacheService } = require(`${process.cwd()}/dist/cache/cache.service`);
const { createFastifyAdapter, exposeRequestIdHeader } = require(
`${process.cwd()}/dist/common/http/fastify-adapter`,
);
const stage = process.argv[2];
const compareRedis = process.argv.includes('--compare-redis');
const historyControl = !process.argv.includes('--skip-history-control');
function integerOption(name, fallback) {
const index = process.argv.indexOf(`--${name}`);
const value = index === -1 ? fallback : Number(process.argv[index + 1]);
assert.ok(Number.isSafeInteger(value) && value > 0, `Invalid --${name}`);
return value;
}
const concurrency = integerOption('concurrency', 16);
const duration = integerOption('duration-seconds', 10);
const warmup = integerOption('warmup-seconds', 3);
const repetitions = integerOption('repetitions', 3);
const seedMessages = integerOption('seed-messages', 10000);
const coldBurst = integerOption('cold-burst', 32);
const writesPerRepeat = integerOption('writes-per-repeat', 512);
assert.ok(['before', 'after'].includes(stage));
const prefix = `experiment:epochs:${randomUUID()}`;
const proxy = await faultProxy(process.env.CACHE_URL, 6379);
const observer = new Redis(process.env.CACHE_URL);
process.env.CACHE_PREFIX = prefix;
process.env.CACHE_URL = proxy.url;
const apps = [];
async function start() {
const app = await NestFactory.create(AppModule, createFastifyAdapter(), {
logger: false,
abortOnError: false,
});
apps.push(app);
exposeRequestIdHeader(app);
await app.listen(0, '127.0.0.1');
require('nestjs-pino').PinoLogger.root.level = 'silent';
return { app, url: await app.getUrl() };
}
const first = await start();
const prisma = first.app.get(PrismaService);
let userId;
const chatIds = [];
const report = {
stage,
recorded_at: new Date().toISOString(),
node: process.version,
methodology: {
requests:
'real loopback HTTP; instrumented API process in measured backend image',
sql: 'pg.Client.query calls; transaction control counted separately',
concurrency,
duration_seconds: duration,
warmup_seconds: warmup,
repetitions,
seed_messages: seedMessages,
cold_burst_requests: coldBurst,
writes_per_repeat: writesPerRepeat,
history_control: historyControl,
resources:
'process CPU/RSS includes HTTP generator and instrumentation; not container CPU',
limitations:
'closed loop, client and API share process/CPU; other Docker workloads share host resources; no capacity/SLA claim; fixtures bypass password KDF',
},
dist_sha256: {},
dependencies: {},
samples: [],
correctness: {},
};
for (const name of [
'@nestjs/core',
'@prisma/adapter-pg',
'pg',
'ioredis',
'fastify',
]) {
try {
report.dependencies[name] = require(`${name}/package.json`).version;
} catch {
report.dependencies[name] = 'package metadata not exported';
}
}
for (const name of [
'Chat/chat.service.js',
'cache/cache.service.js',
'Auth/auth.service.js',
'User/user.guard.js',
'Chat/chat.controller.js',
]) {
report.dist_sha256[name] = createHash('sha256')
.update(await readFile(`${process.cwd()}/dist/${name}`))
.digest('hex');
}
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
async function clearCache() {
let cursor = '0';
do {
const [next, keys] = await observer.scan(
cursor,
'MATCH',
`${prefix}:*`,
'COUNT',
100,
);
cursor = next;
if (keys.length) await observer.del(...keys);
} while (cursor !== '0');
}
let token;
async function request(method, path, body, target = first) {
const response = await fetch(`${target.url}${path}`, {
method,
headers: {
authorization: `Bearer ${token}`,
...(body ? { 'content-type': 'application/json' } : {}),
},
...(body ? { body: JSON.stringify(body) } : {}),
signal: AbortSignal.timeout(10000),
});
const json = await response.json();
assert.equal(
response.status,
method === 'POST' ? 201 : 200,
`HTTP ${response.status}`,
);
return json;
}
async function newChat() {
const chat = await prisma.chat.create({
data: {
title: 'Synthetic epoch benchmark',
members: { create: { userId, position: 0 } },
},
});
chatIds.push(chat.id);
return chat.id;
}
async function measure(
workload,
repeat,
operation,
{
duration: secondsToRun = duration,
total,
concurrency: clients = concurrency,
} = {},
) {
counts = {};
const cpu = process.cpuUsage();
let peakRss = process.memoryUsage().rss;
const timer = setInterval(() => {
peakRss = Math.max(peakRss, process.memoryUsage().rss);
}, 100);
const latencies = [];
let errors = 0,
index = 0;
const start = performance.now();
await Promise.all(
Array.from({ length: clients }, async () => {
while (
total === undefined
? performance.now() - start < secondsToRun * 1000
: index < total
) {
const item = index++;
const began = performance.now();
try {
await operation(item);
latencies.push(performance.now() - began);
} catch {
errors++;
}
}
}),
);
const seconds = (performance.now() - start) / 1000;
clearInterval(timer);
peakRss = Math.max(peakRss, process.memoryUsage().rss);
const used = process.cpuUsage(cpu);
latencies.sort((a, b) => a - b);
const percentile = (p) =>
latencies.length
? +latencies[Math.ceil(p * latencies.length) - 1].toFixed(3)
: null;
const sql = Object.entries(counts)
.filter(([key]) => !/^(BEGIN|COMMIT|ROLLBACK|SET):/.test(key))
.reduce((sum, [, n]) => sum + n, 0);
const sample = {
workload,
repeat,
concurrency: clients,
elapsed_seconds: +seconds.toFixed(3),
successes: latencies.length,
errors,
error_ratio: errors / (latencies.length + errors),
successful_rps: +(latencies.length / seconds).toFixed(3),
latency_ms: {
mean: latencies.length
? +(
latencies.reduce((sum, value) => sum + value, 0) / latencies.length
).toFixed(3)
: null,
p50: percentile(0.5),
p95: percentile(0.95),
p99: percentile(0.99),
},
sql_queries: sql,
sql_per_request: +(sql / (latencies.length + errors)).toFixed(4),
sql_calls: { ...counts },
process_cpu_percent_one_core: +(
(used.user + used.system) /
(seconds * 10000)
).toFixed(2),
peak_process_rss_mib: +(peakRss / 1048576).toFixed(2),
};
report.samples.push(sample);
console.log(JSON.stringify(sample));
assert.equal(errors, 0, 'load errors recorded in report');
}
try {
const user = await prisma.user.create({
data: {
username: `epoch_${randomUUID().replaceAll('-', '').slice(0, 20)}`,
displayName: 'Synthetic benchmark',
},
});
userId = user.id;
token = randomBytes(32).toString('base64url');
await prisma.session.create({
data: {
userId,
tokenHash: createHash('sha256').update(token).digest('hex'),
expiresAt: new Date(Date.now() + 3600000),
},
});
const readChat = await newChat();
for (let offset = 0; offset < seedMessages; offset += 1000) {
await prisma.message.createMany({
data: Array.from(
{ length: Math.min(1000, seedMessages - offset) },
(_, i) => ({
chatId: readChat,
senderId: userId,
text: `Synthetic message ${offset + i}`,
createdAt: new Date(1700000000000 + offset + i),
}),
),
});
}
await prisma.chatMessageEpoch.createMany({
data: Array.from({ length: 16 }, (_, bucket) => ({
chatId: readChat,
bucket,
epoch: BigInt(
Math.floor(seedMessages / 16) + (bucket < seedMessages % 16 ? 1 : 0),
),
})),
});
const path = `/api/v1/chats/${readChat}/messages?limit=50`;
if (compareRedis) {
const cacheUrl = process.env.CACHE_URL;
delete process.env.CACHE_URL;
let withoutRedis;
try {
withoutRedis = await start();
} finally {
process.env.CACHE_URL = cacheUrl;
}
assert.equal(withoutRedis.app.get(CacheService).redis, undefined);
report.methodology.comparison = {
modes: ['redis', 'no-redis'],
no_redis:
'API started without CACHE_URL; all application Redis caches disabled',
epochs: 'PostgreSQL epochs and atomic CTE writes retained in both modes',
order: 'redis first in repeats 1/3, no-redis first in repeat 2',
processes:
'both API instances and HTTP generator share one measured Node process',
};
report.correctness.read_after_write = {};
for (let repeat = 1; repeat <= repetitions; repeat++) {
const variants = [
{ name: 'redis', target: first },
{ name: 'no-redis', target: withoutRedis },
];
if (repeat % 2 === 0) variants.reverse();
for (const { name, target } of variants) {
await clearCache();
await measure(
`cold-history-burst:${name}`,
repeat,
() => request('GET', path, undefined, target),
{ total: coldBurst, concurrency: coldBurst },
);
const warmUntil = performance.now() + warmup * 1000;
while (performance.now() < warmUntil)
await request('GET', path, undefined, target);
await measure(`warm-history:${name}`, repeat, () =>
request('GET', path, undefined, target),
);
const writeChat = await newChat();
const writePath = `/api/v1/chats/${writeChat}/messages`;
assert.equal(
(await request('GET', writePath, undefined, target)).items.length,
0,
);
await measure(
`writes-single-chat:${name}`,
repeat,
(i) =>
request(
'POST',
writePath,
{ text: `Concurrent write ${i}` },
target,
),
{ total: writesPerRepeat },
);
assert.equal(
await prisma.message.count({ where: { chatId: writeChat } }),
writesPerRepeat,
);
assert.equal(
await messageEpoch(prisma, writeChat),
BigInt(writesPerRepeat),
);
const page = await request('GET', writePath, undefined, target);
assert.equal(page.items.length, 50);
assert.equal(new Set(page.items.map((message) => message.id)).size, 50);
report.correctness.read_after_write[`${name}:${repeat}`] = true;
}
}
} else {
const cache = first.app.get(CacheService);
const remember = cache.remember.bind(cache);
for (let repeat = 1; repeat <= repetitions; repeat++) {
await clearCache();
await request('GET', `/api/v1/chats/${readChat}`);
await measure('cold-history-burst', repeat, () => request('GET', path), {
total: coldBurst,
concurrency: coldBurst,
});
const warmUntil = performance.now() + warmup * 1000;
while (performance.now() < warmUntil) await request('GET', path);
await measure('warm-history', repeat, () => request('GET', path));
if (historyControl) {
cache.remember = (namespace, parameters, ttl, load) =>
namespace.startsWith('messages:')
? load()
: remember(namespace, parameters, ttl, load);
const directUntil = performance.now() + warmup * 1000;
while (performance.now() < directUntil) await request('GET', path);
await measure('history-cache-bypassed', repeat, () =>
request('GET', path),
);
cache.remember = remember;
}
const writeChat = await newChat();
await request('GET', `/api/v1/chats/${writeChat}`);
await measure(
'writes-single-chat',
repeat,
(i) =>
request('POST', `/api/v1/chats/${writeChat}/messages`, {
text: `Concurrent write ${i}`,
}),
{ total: writesPerRepeat },
);
assert.equal(
await prisma.message.count({ where: { chatId: writeChat } }),
writesPerRepeat,
);
}
const second = await start();
const faultChat = await newChat();
const faultPath = `/api/v1/chats/${faultChat}/messages`;
assert.equal(
(await request('GET', faultPath, undefined, second)).items.length,
0,
);
const keysBefore = await observer.keys(`${prefix}:messages:${faultChat}:*`);
assert.ok(keysBefore.length);
proxy.setMode('cut');
await sleep(100);
const written = await request('POST', faultPath, {
text: 'Committed while Redis is unavailable',
});
const during = await request('GET', faultPath, undefined, second);
proxy.setMode('online');
for (let i = 0; i < 60; i++) {
if (apps.every((app) => app.get(CacheService).redis?.status === 'ready'))
break;
await sleep(100);
}
assert.ok(
apps.every((app) => app.get(CacheService).redis?.status === 'ready'),
);
const recovered = await request('GET', faultPath, undefined, second);
report.correctness.redis_reconnect = {
old_keys_retained:
(await observer.exists(...keysBefore)) === keysBefore.length,
read_after_write_during_outage: during.items.some(
(x) => x.id === written.id,
),
read_after_write_after_reconnect_other_replica: recovered.items.some(
(x) => x.id === written.id,
),
};
await clearCache();
const cold = await request('GET', faultPath, undefined, second);
report.correctness.empty_cache_recovery = cold.items.some(
(x) => x.id === written.id,
);
const raceChat = await newChat();
const racePath = `/api/v1/chats/${raceChat}/messages`;
const service = first.app.get(
require(`${process.cwd()}/dist/Chat/chat.service`).ChatService,
);
const actualPrisma = service.prisma;
let release, began;
const started = new Promise((resolve) => {
began = resolve;
});
const held = new Promise((resolve) => {
release = resolve;
});
service.prisma = actualPrisma.$extends({
query: {
message: {
async findMany({ args, query }) {
const rows = await query(args);
if (args.where?.chatId === raceChat) {
began();
await held;
}
return rows;
},
},
},
});
const pending = request('GET', racePath);
let fresh;
try {
await Promise.race([
started,
sleep(10000).then(() => {
throw new Error('race load did not start');
}),
]);
proxy.setMode('cut');
await sleep(100);
fresh = await request(
'POST',
racePath,
{ text: 'New message after old SELECT' },
second,
);
proxy.setMode('online');
for (let i = 0; i < 60; i++) {
if (
apps.every((app) => app.get(CacheService).redis?.status === 'ready')
)
break;
await sleep(100);
}
assert.ok(
apps.every((app) => app.get(CacheService).redis?.status === 'ready'),
);
} finally {
release();
service.prisma = actualPrisma;
}
await pending;
report.correctness.delayed_old_fill = (
await request('GET', racePath, undefined, second)
).items.some((x) => x.id === fresh.id);
if (stage === 'after') {
assert.equal(
report.correctness.redis_reconnect
.read_after_write_after_reconnect_other_replica,
true,
);
assert.equal(report.correctness.delayed_old_fill, true);
assert.equal(report.correctness.empty_cache_recovery, true);
}
}
report.completed = true;
} finally {
proxy.setMode('online');
try {
await prisma.chat.deleteMany({ where: { id: { in: chatIds } } });
if (userId) await prisma.user.delete({ where: { id: userId } });
await clearCache();
report.cleanup = 'only experiment chats/user/cache prefix removed';
} finally {
for (const app of apps) await app.close();
observer.disconnect();
await proxy.close();
await writeFile(
process.argv[3] ?? `/tmp/cache-epochs-${stage}.json`,
JSON.stringify(report, null, 2) + '\n',
);
}
}
console.log(
JSON.stringify({
stage,
correctness: report.correctness,
completed: report.completed,
}),
);
+25
View File
@@ -0,0 +1,25 @@
$ErrorActionPreference = 'Stop'
$dockerInfo = docker info --format '{{json .}}' | ConvertFrom-Json
if ($LASTEXITCODE -ne 0) { throw 'docker info failed' }
$processor = Get-CimInstance Win32_Processor | Select-Object -First 1
$computer = Get-CimInstance Win32_ComputerSystem
$containers = docker inspect mtusi2026lab2-fork-backend-1 mtusi2026lab2-fork-postgres-1 mtusi2026lab2-fork-redis-1 | ConvertFrom-Json
if ($LASTEXITCODE -ne 0) { throw 'docker inspect failed' }
$metadata = [ordered]@{
recorded_at = [DateTime]::UtcNow.ToString('o')
host_cpu = $processor.Name
host_physical_cores = $processor.NumberOfCores
host_logical_processors = $processor.NumberOfLogicalProcessors
host_ram_bytes = $computer.TotalPhysicalMemory
docker_version = $dockerInfo.ServerVersion
docker_cpu_count = $dockerInfo.NCPU
docker_ram_bytes = $dockerInfo.MemTotal
docker_kernel = $dockerInfo.KernelVersion
containers = @($containers | ForEach-Object {
[ordered]@{ name = $_.Name; image = $_.Image; memory_limit_bytes = $_.HostConfig.Memory; nano_cpus_limit = $_.HostConfig.NanoCpus; cpu_quota = $_.HostConfig.CpuQuota }
})
before_image = 'sha256:075170aed76a42aa98b435cfb918d83879259b7e17177275d5274e328198e119'
before_image_local_tag = 'lab2-cache-epochs:before'
}
$metadataPath = Join-Path (Get-Location).Path 'evidence/cache-epochs-environment.json'
[System.IO.File]::WriteAllText($metadataPath, ($metadata | ConvertTo-Json -Depth 6) + [Environment]::NewLine, [System.Text.UTF8Encoding]::new($false))
@@ -0,0 +1,91 @@
import assert from 'node:assert/strict';
import { readFile, writeFile } from 'node:fs/promises';
const reports = await Promise.all(
['after', 'optimized'].map(async (name) =>
JSON.parse(await readFile(`evidence/cache-epochs-${name}.json`, 'utf8')),
),
);
assert.ok(reports.every((report) => report.completed));
assert.deepEqual(reports[0].methodology, reports[1].methodology);
const median = (values) =>
[...values].sort((a, b) => a - b)[Math.floor(values.length / 2)];
const labels = ['Отдельная транзакция', 'Один CTE'];
const lines = [
'# Оптимизация эпохи кэша в PostgreSQL',
'',
`Запуски UTC: ${reports.map((report) => report.recorded_at).join(' → ')}.`,
'',
'Сравнение сохранённого замера прежней реализации и нового замера после оптимизации. В обоих вариантах эпоха хранится в PostgreSQL; новый вариант объединяет проверку членства, UPDATE эпохи и INSERT сообщения одним запросом. При чтении истории убрано получение неиспользуемых метаданных чата.',
'',
'Медианы трёх повторов. Перцентили — медианы перцентилей повторов, без объединения выборок.',
'',
'| Сценарий | Вариант | RPS | p50, мс | p95, мс | p99, мс | SQL/HTTP | BEGIN/COMMIT на HTTP | CPU, % ядра | RSS, MiB | Ошибки |',
'| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |',
];
for (const workload of new Set(
reports[0].samples.map((sample) => sample.workload),
)) {
for (const [index, report] of reports.entries()) {
const samples = report.samples.filter(
(sample) => sample.workload === workload,
);
assert.equal(samples.length, 3);
const get = (select) => median(samples.map(select)).toFixed(3);
const controls = (sample) =>
Object.entries(sample.sql_calls)
.filter(([key]) => /^(BEGIN|COMMIT):/.test(key))
.reduce((total, [, count]) => total + count, 0) /
(sample.successes + sample.errors);
lines.push(
`| ${workload} | ${labels[index]} | ${get((sample) => sample.successful_rps)} | ${get((sample) => sample.latency_ms.p50)} | ${get((sample) => sample.latency_ms.p95)} | ${get((sample) => sample.latency_ms.p99)} | ${get((sample) => sample.sql_per_request)} | ${get(controls)} | ${get((sample) => sample.process_cpu_percent_one_core)} | ${get((sample) => sample.peak_process_rss_mib)} | ${samples.reduce((total, sample) => total + sample.errors, 0)} |`,
);
}
}
lines.push(
'',
'| Проверка | Отдельная транзакция | Один CTE |',
'| --- | --- | --- |',
);
for (const [label, select] of [
[
'Чтение после записи при отказе Redis',
(report) =>
report.correctness.redis_reconnect.read_after_write_during_outage,
],
[
'Чтение другой репликой после восстановления Redis',
(report) =>
report.correctness.redis_reconnect
.read_after_write_after_reconnect_other_replica,
],
[
'Старые ключи сохранились в Redis',
(report) => report.correctness.redis_reconnect.old_keys_retained,
],
[
'Восстановление с пустым кэшем',
(report) => report.correctness.empty_cache_recovery,
],
[
'Задержанная загрузка старой истории',
(report) => report.correctness.delayed_old_fill,
],
]) {
lines.push(
`| ${label} | ${reports.map((report) => (select(report) ? 'PASS' : 'FAIL')).join(' | ')} |`,
);
}
lines.push(
'',
'Методика: тот же `test/cache-benchmark.mjs`, 10 000 сообщений, limit=50, конкурентность 16, 3 с прогрева и 10 с чтения, 512 записей в новый чат, три повтора. Реальный HTTP по loopback в отдельных benchmark-контейнерах; общий PostgreSQL/Redis. Токены и пользователи создаются напрямую, хеширование паролей не измеряется. BEGIN/COMMIT исключены из SQL/HTTP; запрос WITH учитывается как один вызов pg.Client.query.',
'',
'CPU/RSS включают API, генератор HTTP и инструментацию. Docker-host разделяется с другими работающими сервисами. Старый и новый замеры сделаны в разное время; изменение фоновой нагрузки и состояния host ограничивает сравнение RPS/latency. Замеры не доказывают максимальную ёмкость или SLA. UPDATE общей строки эпохи по-прежнему сериализует записи одного чата.',
'',
'Сырые результаты: [до оптимизации](cache-epochs-after.json), [после оптимизации](cache-epochs-optimized.json). Хеши измеренных модулей сохранены в JSON. Исторические замеры до введения эпох остаются в `cache-epochs-summary.md`.',
);
await writeFile(
'evidence/cache-epochs-optimization-summary.md',
lines.join('\n') + '\n',
);
console.log(lines.join('\n'));
+73
View File
@@ -0,0 +1,73 @@
import assert from 'node:assert/strict';
import { readFile, writeFile } from 'node:fs/promises';
const before = JSON.parse(
await readFile('evidence/cache-epochs-before.json', 'utf8'),
);
const after = JSON.parse(
await readFile('evidence/cache-epochs-after.json', 'utf8'),
);
assert.ok(before.completed && after.completed);
assert.deepEqual(before.methodology, after.methodology);
const median = (values) =>
values.sort((a, b) => a - b)[Math.floor(values.length / 2)];
const lines = [
'# Эпохи кэша — сравнение 2026-10-13',
'',
'Медианы трёх повторов. p50/p95/p99 — медианы перцентилей отдельных повторов, не перцентили объединённой выборки.',
'',
'| Сценарий | Вариант | RPS | p50, мс | p95, мс | p99, мс | SQL/HTTP | CPU процесса, % ядра | Пиковый RSS, MiB | Ошибки |',
'| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |',
];
for (const workload of [...new Set(before.samples.map((x) => x.workload))]) {
for (const report of [before, after]) {
const samples = report.samples.filter((x) => x.workload === workload);
assert.equal(samples.length, 3);
const get = (fn) => median(samples.map(fn)).toFixed(3);
lines.push(
`| ${workload} | ${report.stage} | ${get((x) => x.successful_rps)} | ${get((x) => x.latency_ms.p50)} | ${get((x) => x.latency_ms.p95)} | ${get((x) => x.latency_ms.p99)} | ${get((x) => x.sql_per_request)} | ${get((x) => x.process_cpu_percent_one_core)} | ${get((x) => x.peak_process_rss_mib)} | ${samples.reduce((sum, x) => sum + x.errors, 0)} |`,
);
}
}
lines.push('', '| Проверка | До | После |', '| --- | --- | --- |');
for (const [label, select] of [
[
'Чтение после успешной записи при недоступном Redis',
(x) => x.correctness.redis_reconnect.read_after_write_during_outage,
],
[
'Чтение другой репликой после восстановления Redis со старыми ключами',
(x) =>
x.correctness.redis_reconnect
.read_after_write_after_reconnect_other_replica,
],
[
'Старые ключи действительно сохранились',
(x) => x.correctness.redis_reconnect.old_keys_retained,
],
['Восстановление с пустым кэшем', (x) => x.correctness.empty_cache_recovery],
[
'Задержанная загрузка старой истории не отравляет следующий GET',
(x) => x.correctness.delayed_old_fill,
],
])
lines.push(
`| ${label} | ${select(before) ? 'PASS' : 'FAIL'} | ${select(after) ? 'PASS' : 'FAIL'} |`,
);
lines.push(
'',
'Методика: `test/cache-benchmark.mjs`, сырой результат: `cache-epochs-before.json` и `cache-epochs-after.json`. Конфигурация: `cache-epochs-environment.json`.',
'',
'Реальный HTTP по loopback, 10 000 синтетических сообщений, первая страница limit=50. На повтор: холодная волна 32 запросов; прогрев 3 с; чтение с конкурентностью 16 в течение 10 с; прогрев 3 с и такой же контроль с отключённым кэшем истории; 512 записей в новый чат с конкурентностью 16. Три повтора. SQL считается на уровне pg.Client.query; BEGIN/COMMIT/ROLLBACK/SET вынесены в raw sql_calls и исключены из SQL/HTTP. Пароли не измеряются: пользователь и сессия создаются напрямую, токен остаётся в памяти.',
'',
'CPU/RSS относятся к процессу эксперимента, включающему API, генератор HTTP и инструментацию. Docker Desktop: 4 CPU, около 2.80 GiB RAM, отдельные лимиты сервисов не заданы. Замеры closed-loop, короткие и последовательные before → after; разброс и прогрев ограничивают выводы о latency/RPS. Это не тест максимальной ёмкости или SLA. Первый холодный повтор также включает прогрев runtime.',
'',
'Первичные короткие замеры (1 с прогрева, 5 с чтений, 128 записей) сохранены отдельно в cache-epochs-before-short.json и cache-epochs-after-short.json. Из-за большого разброса сделано одно повторное сравнение с увеличенным прогревом и нагрузкой; основные результаты получены в отдельных контейнерах benchmark из соответствующих образов. PostgreSQL/Redis и остальные контейнеры разделяют ресурсы Docker-host. Другие проекты на этом host не останавливались. Формулировки provenance в основных JSON уточнены после перехода от docker exec к отдельному контейнеру; численные измерения не менялись.',
'',
'До изменений использован фактически запущенный образ (локальный тег lab2-cache-epochs:before), после — пересобранный проект. Старый образ ещё использовал OR для курсорной пагинации; измеряемая первая страница не содержит курсора, поэтому этот путь в нагрузочном сравнении не выполняется. Хеши измеренных модулей записаны в JSON.',
'',
'Эпоха истории читается JOIN-ом вместе с проверкой членства; эпоха списка чатов — JOIN-ом с проверкой сессии. Для отдельного запроса дополнительного чтения эпохи нет. Однако raw JOIN проверки членства не использует прежний batching findUnique в Prisma: под конкуренцией суммарный SQL/HTTP может вырасти. Запись добавляет UPDATE чата и транзакционные команды; обновления одного чата сериализуются. Старые ключи недоступны новым читателям и удаляются по TTL.',
'',
'Корректность зависит от основного PostgreSQL и обновления эпох во всех путях изменения данных. Прямые SQL-изменения в обход приложения требуют увеличения соответствующей эпохи. После восстановления PostgreSQL из старого backup следует сменить CACHE_PREFIX или очистить кэш, чтобы исключить повторное использование эпох. Сохранность Docker-host и высокая доступность PostgreSQL не исследовались. Cache stampede не устраняется этим изменением.',
);
await writeFile('evidence/cache-epochs-summary.md', lines.join('\n') + '\n');
console.log(lines.slice(0, 14).join('\n'));
+117
View File
@@ -0,0 +1,117 @@
import assert from 'node:assert/strict';
import { readFile, writeFile } from 'node:fs/promises';
const resultPrefix = process.argv[2] ?? 'cache-strategy';
assert.match(resultPrefix, /^[a-z0-9-]+$/);
const reports = await Promise.all(
['full', 'no-redis-no-epochs'].map(async (name) =>
JSON.parse(await readFile(`evidence/${resultPrefix}-${name}.json`, 'utf8')),
),
);
const provenance = JSON.parse(
await readFile(`evidence/${resultPrefix}-experiment.json`, 'utf8'),
);
assert.ok(reports.every((report) => report.completed));
assert.deepEqual(reports[0].methodology, reports[1].methodology);
assert.equal(provenance.exit_code, 0);
assert.ok(provenance.sources_unchanged);
assert.ok(reports[1].correctness.epochs_unchanged);
assert.ok(reports[1].correctness.no_redis_client);
const median = (values) =>
[...values].sort((a, b) => a - b)[Math.floor(values.length / 2)];
const labels = ['Redis и эпохи', 'Без Redis и эпох'];
const aggregates = [];
const settings = reports[0].methodology;
const lines = [
'# Полная стратегия кэша и вариант без Redis и эпох',
'',
`Запуски UTC: ${reports.map((report) => report.recorded_at).join(' → ')}.`,
'',
'Сначала выполнен свежий прогон текущего образа с Redis, PostgreSQL-эпохами и записью сообщения через CTE. Затем шесть модулей приложения заменены временными версиями без поддержания эпох: убраны изменения счётчиков и чтения эпох в проверках сессии/членства. Объединённые проверки сессии, публичного профиля и доступа к истории сохранены. Сообщение вставляется одним INSERT ... SELECT с проверкой членства, без обновления счётчиков. Второй API запущен без CACHE_URL: все кэши приложения отключены. Исходники рабочего проекта и запущенный backend не изменены.',
'',
`Параметры обоих прогонов совпадают: ${settings.repetitions} повтора, конкурентность ${settings.concurrency}, ${settings.seed_messages} сообщений, limit=50, прогрев ${settings.warmup_seconds} с и чтение ${settings.duration_seconds} с, ${settings.writes_per_repeat} записей в новый чат. RPS = общее число успешных запросов / общее время повторов. Средняя задержка взвешена по числу успешных запросов. p95 — среднее отдельных p95, не перцентиль объединённой выборки. SQL/HTTP исключает команды транзакций.`,
'',
'| Сценарий | Вариант | Средний RPS | Средняя задержка, мс | Среднее p95, мс | SQL/HTTP | Медиана RPS | Ошибки |',
'| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |',
];
for (const [workload, label] of [
['cold-history-burst', 'Холодная волна истории'],
['warm-history', 'Прогретая история'],
['history-cache-bypassed', 'Контроль без кэша истории'],
['writes-single-chat', 'Запись в один чат'],
]) {
if (
reports.every(
(report) =>
!report.samples.some((sample) => sample.workload === workload),
)
)
continue;
for (const [index, report] of reports.entries()) {
const samples = report.samples.filter(
(sample) => sample.workload === workload,
);
assert.equal(samples.length, settings.repetitions);
const sum = (select) =>
samples.reduce((total, sample) => total + select(sample), 0);
const successes = sum((sample) => sample.successes);
const errors = sum((sample) => sample.errors);
const aggregate = {
workload,
variant: labels[index],
successes,
errors,
mean_rps: successes / sum((sample) => sample.elapsed_seconds),
mean_latency_ms:
sum((sample) => sample.latency_ms.mean * sample.successes) / successes,
mean_p95_ms: sum((sample) => sample.latency_ms.p95) / samples.length,
sql_per_request:
sum((sample) => sample.sql_queries) / (successes + errors),
median_rps: median(samples.map((sample) => sample.successful_rps)),
repeat_rps: samples.map((sample) => sample.successful_rps),
};
aggregates.push(aggregate);
lines.push(
`| ${label} | ${labels[index]} | ${aggregate.mean_rps.toFixed(3)} | ${aggregate.mean_latency_ms.toFixed(3)} | ${aggregate.mean_p95_ms.toFixed(3)} | ${aggregate.sql_per_request.toFixed(3)} | ${aggregate.median_rps.toFixed(3)} | ${errors} |`,
);
}
}
lines.push(
'',
`Учтено успешных HTTP-запросов: ${reports.map((report, index) => `${labels[index]} — ${report.samples.reduce((sum, sample) => sum + sample.successes, 0)}`).join('; ')}.`,
'',
...['warm-history', 'writes-single-chat'].map((workload) => {
const pair = aggregates.filter(
(aggregate) => aggregate.workload === workload,
);
return `${workload}: отношение среднего RPS полной стратегии к варианту без стратегии — ${(pair[0].mean_rps / pair[1].mean_rps).toFixed(3)}. RPS по повторам: ${pair.map((aggregate) => `${aggregate.variant}: ${aggregate.repeat_rps.join(' / ')}`).join('; ')}.`;
}),
'',
settings.history_control === false
? 'Дополнительный контроль с частично отключённым кэшем в этом прогоне пропущен. Сравниваются только полная стратегия и отсутствие Redis/поддержания эпох.'
: 'В контрольном сценарии у первого API отключён только кэш истории; кэш профиля продолжает работать. У второго API отключены все кэши. Поэтому этот контроль не измеряет отдельно чистую стоимость эпох.',
'',
`Проверки полной стратегии: чтение после записи при отказе Redis, чтение другой репликой после восстановления со старыми ключами, восстановление с пустым кэшем, задержанная загрузка старой истории. Проверки варианта без стратегии: приложение не создало Redis-клиент, эпохи синтетических пользователей/чатов остались равны 0 после всех записей, ${settings.writes_per_repeat} сообщений записаны в каждом новом чате, история читается после записи без повторяющихся ID.`,
'',
`Оба прогона используют один базовый образ; изменённые модули временной версии скомпилированы TypeScript без полной пересборки контейнера и подключены отдельными bind mounts. Хеши исходников и JS сохранены в [метаданных эксперимента](${resultPrefix}-experiment.json). Колонки эпох остаются в схеме; это исключает миграцию и позволяет сохранить рабочую БД. SQL-проверки профиля и членства во втором варианте не используют эпохи. Временные файлы удалены, хеши рабочих исходников проверены.`,
'',
'Ограничения: прогоны последовательные, Docker-host разделяется с другими сервисами; большой разброс ограничивает выводы о скорости. CPU/RSS процесса включают API, HTTP-генератор и инструментацию; CPU PostgreSQL отдельно не измерен. Синтетические сессии обходят KDF. Холодная волна означает пустой кэш приложения, а не холодный PostgreSQL. Отдельные цены Redis и эпох этим сравнением не разделяются: меняется вся стратегия. Данные рабочей БД и volumes сохранены, удалены только фикстуры эксперимента.',
'',
'Повторение:',
'',
'```powershell',
`docker compose -f compose.yaml -f test/compose.benchmark.yaml run --rm --no-deps --pull never benchmark node test/cache-benchmark.mjs after /results/${resultPrefix}-full.json --concurrency ${settings.concurrency} --duration-seconds ${settings.duration_seconds} --warmup-seconds ${settings.warmup_seconds} --repetitions ${settings.repetitions} --seed-messages ${settings.seed_messages} --cold-burst ${settings.cold_burst_requests} --writes-per-repeat ${settings.writes_per_repeat}${settings.history_control === false ? ' --skip-history-control' : ''}`,
`$env:EXPERIMENT_PREFIX='${resultPrefix}'`,
`node test/no-epochs-experiment.cjs --concurrency ${settings.concurrency} --duration-seconds ${settings.duration_seconds} --warmup-seconds ${settings.warmup_seconds} --repetitions ${settings.repetitions} --seed-messages ${settings.seed_messages} --cold-burst ${settings.cold_burst_requests} --writes-per-repeat ${settings.writes_per_repeat}${settings.history_control === false ? ' --skip-history-control' : ''}`,
`node test/cache-strategy-summary.mjs ${resultPrefix}`,
'```',
'',
`Сырые результаты: [полная стратегия](${resultPrefix}-full.json), [без Redis и эпох](${resultPrefix}-no-redis-no-epochs.json).`,
);
await writeFile(`evidence/${resultPrefix}-summary.md`, lines.join('\n') + '\n');
await writeFile(
`evidence/${resultPrefix}-averages.json`,
JSON.stringify(aggregates, null, 2) + '\n',
);
console.log(lines.slice(0, 18).join('\n'));
+12
View File
@@ -0,0 +1,12 @@
services:
benchmark:
image: ${BENCHMARK_IMAGE:-mtusi2026lab2-fork-backend}
working_dir: /app
environment:
NODE_ENV: production
DATABASE_URL: postgresql://${POSTGRES_USER:-app}:${POSTGRES_PASSWORD:-local_dev_password}@postgres:5432/${POSTGRES_DB:-chat}
CACHE_URL: redis://redis:6379/0
volumes:
- ./test:/app/test:ro
- ./evidence:/results
command: ['node', 'test/cache-benchmark.mjs', '${BENCHMARK_STAGE:-after}', '/results/cache-epochs-${BENCHMARK_STAGE:-after}.json']
+475
View File
@@ -0,0 +1,475 @@
import assert from 'node:assert/strict';
import { createHash, randomBytes, randomUUID } from 'node:crypto';
import { createRequire } from 'node:module';
import Module from 'node:module';
import { readFile, writeFile } from 'node:fs/promises';
import { performance } from 'node:perf_hooks';
import { faultProxy } from './helpers/fault-proxy.mjs';
const require = createRequire('/app/package.json');
const manifest = JSON.parse(await readFile('/variants/manifest.json', 'utf8'));
const pg = require('pg');
let counts = {};
const originalQuery = pg.Client.prototype.query;
pg.Client.prototype.query = function (query, ...args) {
const sql = typeof query === 'string' ? query : query.text;
const verb = sql.trim().split(/\s+/)[0].toUpperCase();
counts[verb] = (counts[verb] ?? 0) + 1;
return originalQuery.call(this, query, ...args);
};
const { NestFactory } = require('@nestjs/core');
const { AppModule } = require('/app/dist/app.module');
const { PrismaService } = require('/app/dist/prisma/prisma.service');
const { CacheService } = require('/app/dist/cache/cache.service');
const { ChatService } = require('/app/dist/Chat/chat.service');
const {
createFastifyAdapter,
exposeRequestIdHeader,
} = require('/app/dist/common/http/fastify-adapter');
const exportedClasses = {
'Auth/auth.service.ts': 'AuthService',
'User/user.service.ts': 'UserService',
'User/user.guard.ts': 'UserGuard',
'Chat/chat.service.ts': 'ChatService',
'Chat/chat.controller.ts': 'ChatController',
};
const originals = {};
const variants = {};
for (const [relative, name] of Object.entries(exportedClasses)) {
const filename = `/app/dist/${relative.replace(/\.ts$/, '.js')}`;
originals[name] = require(filename)[name];
}
for (const variant of manifest.variants) {
variants[variant.name] = {};
for (const [relative, name] of Object.entries(exportedClasses)) {
const filename = `/app/dist/${relative.replace(/\.ts$/, '.js')}`;
const source = await readFile(
`/variants/${variant.name}/${relative.replace(/\.ts$/, '.js')}`,
'utf8',
);
const loaded = new Module(filename);
loaded.filename = filename;
loaded.paths = Module._nodeModulePaths('/app');
loaded._compile(source, filename);
variants[variant.name][name] = loaded.exports[name];
}
}
function activate(name) {
for (const [className, replacement] of Object.entries(variants[name])) {
const target = originals[className].prototype;
for (const method of Object.getOwnPropertyNames(replacement.prototype)) {
if (method === 'constructor') continue;
const descriptor = Object.getOwnPropertyDescriptor(
replacement.prototype,
method,
);
const previous = target[method];
if (
typeof descriptor.value === 'function' &&
typeof previous === 'function'
) {
for (const key of Reflect.getMetadataKeys(previous))
Reflect.defineMetadata(
key,
Reflect.getMetadata(key, previous),
descriptor.value,
);
}
Object.defineProperty(target, method, descriptor);
}
}
}
const Redis = require('ioredis').default;
const prefix = `experiment:epoch-variants:${randomUUID()}`;
const proxy = await faultProxy(process.env.CACHE_URL, 6379);
const observer = new Redis(process.env.CACHE_URL);
process.env.CACHE_URL = proxy.url;
const apps = {};
const chatIds = [];
const userIds = [];
let prisma, token;
const report = {
recorded_at: new Date().toISOString(),
methodology: {
concurrency: 32,
duration_seconds: 60,
warmup_seconds: 10,
repetitions: 3,
seed_messages: 100000,
writes_per_repeat: 4096,
order: [
['baseline', 'profile-join', 'access-join', 'striped'],
['striped', 'access-join', 'profile-join', 'baseline'],
['profile-join', 'striped', 'baseline', 'access-join'],
],
requests:
'Real loopback HTTP; shared read fixtures, separate write chats and cache prefixes',
resources:
'Four idle/active API instances and HTTP generator share one Node process; only one workload active at a time',
sql: 'pg.Client.query; transaction-control commands excluded; no changes to database pool size',
},
variants: manifest.variants,
samples: [],
correctness: {},
completed: false,
};
const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
async function request(name, method, url, body, bearer = token) {
const response = await fetch(`${apps[name].url}${url}`, {
method,
headers: {
authorization: `Bearer ${bearer}`,
...(body ? { 'content-type': 'application/json' } : {}),
},
...(body ? { body: JSON.stringify(body) } : {}),
signal: AbortSignal.timeout(10000),
});
const json = await response.json();
return { status: response.status, json };
}
async function call(name, method, url, body) {
const result = await request(name, method, url, body);
assert.equal(result.status, method === 'POST' ? 201 : 200);
return result.json;
}
async function clearCache() {
let cursor = '0';
do {
const [next, keys] = await observer.scan(
cursor,
'MATCH',
`${prefix}:*`,
'COUNT',
100,
);
cursor = next;
if (keys.length) await observer.del(...keys);
} while (cursor !== '0');
}
async function newChat(userId) {
const chat = await prisma.chat.create({
data: {
title: 'Variant benchmark',
members: { create: { userId, position: 0 } },
},
});
chatIds.push(chat.id);
return chat.id;
}
async function epoch(name, chatId) {
if (name !== 'striped')
return (await prisma.chat.findUniqueOrThrow({ where: { id: chatId } }))
.messagesEpoch;
const [row] = await prisma.$queryRawUnsafe(
`SELECT COALESCE(SUM(epoch), 0)::bigint AS epoch FROM "${manifest.schema}".chat_message_epochs WHERE chat_id = $1::uuid`,
chatId,
);
return row.epoch;
}
async function measure(name, workload, repeat, operation, total) {
counts = {};
const latencies = [];
let errors = 0,
index = 0;
const cpu = process.cpuUsage();
const start = performance.now();
await Promise.all(
Array.from({ length: 32 }, async () => {
while (
total === undefined ? performance.now() - start < 60000 : index < total
) {
const item = index++;
const began = performance.now();
try {
await operation(item);
latencies.push(performance.now() - began);
} catch {
errors++;
}
}
}),
);
const seconds = (performance.now() - start) / 1000;
const used = process.cpuUsage(cpu);
latencies.sort((a, b) => a - b);
const calls = { ...counts };
const queries = Object.entries(calls)
.filter(([verb]) => !['BEGIN', 'COMMIT', 'ROLLBACK', 'SET'].includes(verb))
.reduce((sum, [, count]) => sum + count, 0);
const sample = {
variant: name,
workload,
repeat,
successes: latencies.length,
errors,
elapsed_seconds: +seconds.toFixed(3),
rps: +(latencies.length / seconds).toFixed(3),
mean_latency_ms: +(
latencies.reduce((sum, value) => sum + value, 0) / latencies.length
).toFixed(3),
p95_ms: +latencies[Math.ceil(latencies.length * 0.95) - 1]?.toFixed(3),
sql_queries: queries,
sql_per_request: +(queries / (latencies.length + errors)).toFixed(4),
sql_calls: calls,
cpu_percent_one_core: +(
(used.user + used.system) /
(seconds * 10000)
).toFixed(2),
rss_mib: +(process.memoryUsage().rss / 1048576).toFixed(2),
};
report.samples.push(sample);
console.log(JSON.stringify(sample));
assert.equal(errors, 0, 'HTTP workload errors');
}
async function reconnect() {
proxy.setMode('online');
for (let attempt = 0; attempt < 80; attempt++) {
if (
Object.values(apps).every(
({ app }) => app.get(CacheService).redis.status === 'ready',
)
)
return;
await pause(100);
}
assert.fail('Redis reconnect timeout');
}
async function correctness(name, userId, otherToken) {
activate(name);
await clearCache();
const replica = Object.keys(apps).find((candidate) => candidate !== name);
const chatId = await newChat(userId);
const url = `/api/v1/chats/${chatId}/messages`;
assert.equal(
(
await request(
name,
'GET',
url,
undefined,
randomBytes(32).toString('base64url'),
)
).status,
401,
);
assert.equal(
(await request(name, 'GET', url, undefined, otherToken)).status,
404,
);
assert.equal(
(await request(name, 'POST', url, { text: 'Forbidden' }, otherToken))
.status,
404,
);
assert.equal(
(await request(name, 'GET', '/api/v1/chats/invalid/messages')).status,
400,
);
assert.equal(
(
await request(
name,
'GET',
'/api/v1/chats/invalid/messages',
undefined,
randomBytes(32).toString('base64url'),
)
).status,
401,
);
assert.equal((await call(replica, 'GET', url)).items.length, 0);
const keys = await observer.keys(`${prefix}:${replica}:messages:${chatId}:*`);
assert.ok(keys.length);
proxy.setMode('cut');
await pause(100);
const posted = await call(name, 'POST', url, { text: 'During outage' });
assert.equal((await call(replica, 'GET', url)).items[0].id, posted.id);
await reconnect();
assert.equal(await observer.exists(...keys), keys.length);
assert.equal((await call(replica, 'GET', url)).items[0].id, posted.id);
const service = apps[name].app.get(ChatService);
const actual = service.prisma;
service.prisma = actual.$extends({
query: {
$queryRaw({ args, query }) {
const index = args.values.indexOf('Must roll back');
if (index !== -1) args.values[index] = 'x'.repeat(4001);
return query(args);
},
},
});
try {
assert.equal(
(await request(name, 'POST', url, { text: 'Must roll back' })).status,
500,
);
} finally {
service.prisma = actual;
}
assert.equal(await epoch(name, chatId), 1n);
assert.equal(await prisma.message.count({ where: { chatId } }), 1);
const raceChat = await newChat(userId);
const raceUrl = `/api/v1/chats/${raceChat}/messages`;
let began, release;
const started = new Promise((resolve) => {
began = resolve;
});
const held = new Promise((resolve) => {
release = resolve;
});
service.prisma = actual.$extends({
query: {
message: {
async findMany({ args, query }) {
const rows = await query(args);
if (args.where?.chatId === raceChat) {
began();
await held;
}
return rows;
},
},
},
});
const pending = call(name, 'GET', raceUrl);
try {
await Promise.race([
started,
pause(10000).then(() => {
throw new Error('Race load timeout');
}),
]);
const fresh = await call(replica, 'POST', raceUrl, {
text: 'After old SELECT',
});
release();
await pending;
assert.equal((await call(name, 'GET', raceUrl)).items[0].id, fresh.id);
} finally {
release();
service.prisma = actual;
}
await clearCache();
assert.equal((await call(name, 'GET', url)).items[0].id, posted.id);
report.correctness[name] = {
access_statuses: true,
redis_outage_and_retained_keys: true,
rollback: true,
delayed_old_fill: true,
empty_cache: true,
};
console.log(JSON.stringify({ correctness: name, result: 'PASS' }));
}
try {
for (const variant of manifest.variants) {
activate(variant.name);
process.env.CACHE_PREFIX = `${prefix}:${variant.name}`;
const app = await NestFactory.create(AppModule, createFastifyAdapter(), {
logger: false,
abortOnError: false,
});
apps[variant.name] = { app };
exposeRequestIdHeader(app);
await app.listen(0, '127.0.0.1');
require('nestjs-pino').PinoLogger.root.level = 'silent';
apps[variant.name].url = await app.getUrl();
}
prisma = apps.baseline.app.get(PrismaService);
const user = await prisma.user.create({
data: {
username: `variant_${randomUUID().replaceAll('-', '').slice(0, 20)}`,
displayName: 'Variant user',
},
});
userIds.push(user.id);
token = randomBytes(32).toString('base64url');
await prisma.session.create({
data: {
userId: user.id,
tokenHash: createHash('sha256').update(token).digest('hex'),
expiresAt: new Date(Date.now() + 3600000),
},
});
const other = await prisma.user.create({
data: {
username: `other_${randomUUID().replaceAll('-', '').slice(0, 20)}`,
displayName: 'Other user',
},
});
userIds.push(other.id);
const otherToken = randomBytes(32).toString('base64url');
await prisma.session.create({
data: {
userId: other.id,
tokenHash: createHash('sha256').update(otherToken).digest('hex'),
expiresAt: new Date(Date.now() + 3600000),
},
});
for (const name of Object.keys(apps))
await correctness(name, user.id, otherToken);
const readChat = await newChat(user.id);
for (let offset = 0; offset < 100000; offset += 1000) {
await prisma.message.createMany({
data: Array.from({ length: 1000 }, (_, i) => ({
chatId: readChat,
senderId: user.id,
text: `Synthetic message ${offset + i}`,
createdAt: new Date(1700000000000 + offset + i),
})),
});
}
await prisma.chat.update({ where: { id: readChat }, data: { messagesEpoch: 100000n } });
await prisma.$executeRawUnsafe(`INSERT INTO "${manifest.schema}".chat_message_epochs (chat_id, bucket, epoch) SELECT $1::uuid, bucket::smallint, 6250 FROM generate_series(0, 15) AS bucket ON CONFLICT (chat_id, bucket) DO UPDATE SET epoch = EXCLUDED.epoch`, readChat);
for (const [index, order] of report.methodology.order.entries()) {
for (const name of order) {
activate(name);
await clearCache();
const url = `/api/v1/chats/${readChat}/messages?limit=50`;
const warmUntil = performance.now() + 10000;
while (performance.now() < warmUntil) await call(name, 'GET', url);
await measure(name, 'warm-history', index + 1, () =>
call(name, 'GET', url),
);
const writeChat = await newChat(user.id);
const writeUrl = `/api/v1/chats/${writeChat}/messages`;
assert.equal((await call(name, 'GET', writeUrl)).items.length, 0);
await measure(
name,
'writes-single-chat',
index + 1,
(i) => call(name, 'POST', writeUrl, { text: `Concurrent ${i}` }),
4096,
);
assert.equal(
await prisma.message.count({ where: { chatId: writeChat } }),
4096,
);
assert.equal(await epoch(name, writeChat), 4096n);
assert.equal((await call(name, 'GET', writeUrl)).items.length, 50);
}
}
report.completed = true;
} finally {
await reconnect();
if (prisma) {
await prisma.chat.deleteMany({ where: { id: { in: chatIds } } });
await prisma.user.deleteMany({ where: { id: { in: userIds } } });
}
await clearCache();
for (const { app } of Object.values(apps)) await app.close();
observer.disconnect();
await proxy.close();
await writeFile(
'/results/epoch-variants.json',
JSON.stringify(report, null, 2) + '\n',
);
}
console.log(
JSON.stringify({
completed: report.completed,
correctness: report.correctness,
}),
);
+261
View File
@@ -0,0 +1,261 @@
const assert = require('node:assert/strict');
const fs = require('node:fs');
const os = require('node:os');
const path = require('node:path');
const { randomUUID, createHash } = require('node:crypto');
const { spawn } = require('node:child_process');
const ts = require('typescript');
require('dotenv').config({ quiet: true });
const root = path.resolve(__dirname, '..');
const statePath = path.join(root, '.epoch-variants-state.json');
const files = [
'Auth/auth.service.ts',
'User/user.service.ts',
'User/user.guard.ts',
'Chat/chat.service.ts',
'Chat/chat.controller.ts',
];
const digest = (value) => createHash('sha256').update(value).digest('hex');
const command = process.argv[2];
async function main() {
let state;
if (command === 'init') {
assert.ok(!fs.existsSync(statePath));
assert.ok(
/messagesEpoch\s+BigInt/.test(
fs.readFileSync(path.join(root, 'prisma/schema.prisma'), 'utf8'),
),
'Historical comparison requires the pre-bucket schema. Original sources are saved in evidence/epoch-variants-sources.json',
);
state = {
directory: fs.mkdtempSync(path.join(os.tmpdir(), 'lab2-epoch-variants-')),
schema: 'epoch_variants_' + randomUUID().replaceAll('-', ''),
variants: [],
};
await database(async (client) => {
await client.query(`CREATE SCHEMA "${state.schema}"`);
await client.query(
`CREATE TABLE "${state.schema}".chat_message_epochs (chat_id uuid NOT NULL REFERENCES public.chats(id) ON DELETE CASCADE, bucket smallint NOT NULL CHECK (bucket BETWEEN 0 AND 15), epoch bigint NOT NULL DEFAULT 0, PRIMARY KEY (chat_id, bucket))`,
);
});
capture(state, 'baseline');
} else {
state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
}
if (command === 'capture') capture(state, process.argv[3]);
if (command === 'capture-striped') capture(state, 'striped', true);
if (command === 'apply-striped') {
const sources = {};
for (const variant of state.variants) {
sources[variant.name] = Object.fromEntries(
files.map((relative) => [
relative,
fs.readFileSync(
path.join(state.directory, variant.name, relative),
'utf8',
),
]),
);
}
fs.writeFileSync(
path.join(root, 'evidence/epoch-variants-sources.json'),
JSON.stringify(sources, null, 2) + '\n',
);
for (const relative of ['Auth/auth.service.ts', 'Chat/chat.service.ts']) {
const source = sources.striped[relative].replaceAll(
`"${state.schema}".chat_message_epochs`,
'"public"."chat_message_epochs"',
);
fs.writeFileSync(path.join(root, 'src', relative), source);
}
console.log(
'Applied striped epochs to application sources; saved all source snapshots',
);
}
if (['init', 'capture', 'capture-striped'].includes(command)) {
fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
console.log(
'Captured:',
state.variants.map((variant) => variant.name).join(', '),
);
return;
}
if (command === 'run') {
assert.equal(state.variants.length, 4);
fs.writeFileSync(
path.join(state.directory, 'manifest.json'),
JSON.stringify(state, null, 2),
);
const override = path.join(state.directory, 'compose.json');
fs.writeFileSync(
override,
JSON.stringify({
services: {
benchmark: {
volumes: [
{
type: 'bind',
source: state.directory,
target: '/variants',
read_only: true,
},
],
},
},
}),
);
const args = [
'compose',
'-f',
'compose.yaml',
'-f',
'test/compose.benchmark.yaml',
'-f',
override,
'run',
'--rm',
'--no-deps',
'--pull',
'never',
'benchmark',
'node',
'test/epoch-variants-benchmark.mjs',
];
const code = await new Promise((resolve, reject) => {
const child = spawn('docker', args, { cwd: root, stdio: 'inherit' });
child.once('error', reject);
child.once('exit', resolve);
});
fs.writeFileSync(
path.join(root, 'evidence/epoch-variants-code.json'),
JSON.stringify(
{
variants: state.variants,
schema: state.schema,
exit_code: code,
implementation:
'TypeScript source snapshots; variant methods activated sequentially before HTTP workloads. Separate cache prefixes and API instances, shared fixtures and Node process.',
},
null,
2,
),
);
process.exitCode = code ?? 1;
}
if (command === 'seed-read-fixture') {
await database(async (client) => {
const result = await client.query(
`SELECT c.id FROM public.chats c JOIN public.messages m ON m.chat_id = c.id WHERE c.title = 'Variant benchmark' GROUP BY c.id HAVING COUNT(*) = 100000`,
);
assert.equal(result.rows.length, 1);
const chatId = result.rows[0].id;
await client.query(
'UPDATE public.chats SET messages_epoch = 100000 WHERE id = $1::uuid',
[chatId],
);
await client.query(
`INSERT INTO "${state.schema}".chat_message_epochs (chat_id, bucket, epoch) SELECT $1::uuid, bucket::smallint, 6250 FROM generate_series(0, 15) AS bucket ON CONFLICT (chat_id, bucket) DO UPDATE SET epoch = EXCLUDED.epoch`,
[chatId],
);
console.log('Seeded read fixture with 16 nonzero epoch buckets');
});
}
if (command === 'cleanup') {
await database((client) =>
client.query(`DROP SCHEMA "${state.schema}" CASCADE`),
);
const resolved = path.resolve(state.directory);
assert.equal(path.dirname(resolved), path.resolve(os.tmpdir()));
assert.ok(path.basename(resolved).startsWith('lab2-epoch-variants-'));
fs.rmSync(resolved, { recursive: true, force: true });
fs.unlinkSync(statePath);
console.log('Removed experiment schema and temporary source snapshots');
}
}
function capture(state, name, striped = false) {
assert.match(name, /^[a-z-]+$/);
assert.ok(!state.variants.some((variant) => variant.name === name));
const modules = {};
const table = `"${state.schema}".chat_message_epochs`;
for (const relative of files) {
let source = fs
.readFileSync(path.join(root, 'src', relative), 'utf8')
.replace(/\r\n/g, '\n');
if (
striped &&
['Auth/auth.service.ts', 'Chat/chat.service.ts'].includes(relative)
) {
source = source.replaceAll(
'c.messages_epoch',
`COALESCE((SELECT SUM(e.epoch) FROM ${table} AS e WHERE e.chat_id = c.id), 0)::bigint`,
);
if (relative === 'Chat/chat.service.ts') {
const start = source.indexOf(' const [message] =');
const end = source.indexOf(' if (!message)', start);
assert.ok(start !== -1 && end > start);
source =
source.slice(0, start) +
' const messageId = randomUUID();\n' +
' const bucket = parseInt(messageId.slice(0, 2), 16) % 16;\n' +
' const [message] = await this.prisma.$queryRaw<StoredMessage[]>(Prisma.sql`\n' +
` WITH updated AS (\n INSERT INTO ${table} AS e (chat_id, bucket, epoch)\n` +
' SELECT cm.chat_id, ${bucket}::smallint, 1 FROM chat_members AS cm\n' +
' WHERE cm.chat_id = ${id}::uuid AND cm.user_id = ${userId}::uuid\n' +
' ON CONFLICT (chat_id, bucket) DO UPDATE SET epoch = e.epoch + 1\n' +
' RETURNING chat_id\n )\n' +
' INSERT INTO messages (id, chat_id, sender_id, text)\n' +
' SELECT ${messageId}::uuid, updated.chat_id, ${userId}::uuid, ${text} FROM updated\n' +
' RETURNING id, chat_id AS "chatId", sender_id AS "senderId", text, created_at AS "createdAt"\n' +
' `);\n' +
source.slice(end);
}
}
const compiled = ts.transpileModule(source, {
compilerOptions: {
target: ts.ScriptTarget.ES2023,
module: ts.ModuleKind.CommonJS,
experimentalDecorators: true,
emitDecoratorMetadata: true,
},
reportDiagnostics: true,
});
assert.ok(
!compiled.diagnostics.some(
(diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error,
),
);
const destination = path.join(
state.directory,
name,
relative.replace(/\.ts$/, '.js'),
);
fs.mkdirSync(path.dirname(destination), { recursive: true });
fs.writeFileSync(destination, compiled.outputText);
fs.writeFileSync(destination.replace(/\.js$/, '.ts'), source);
modules[relative] = {
source_sha256: digest(source),
js_sha256: digest(compiled.outputText),
};
}
state.variants.push({ name, modules, striped });
}
async function database(operation) {
const client = new (require('pg').Client)({
connectionString: process.env.DATABASE_URL,
});
await client.connect();
try {
return await operation(client);
} finally {
await client.end();
}
}
main().catch((error) => {
console.error(error.message);
process.exitCode = 1;
});
+72
View File
@@ -0,0 +1,72 @@
import assert from 'node:assert/strict';
import { readFile, writeFile } from 'node:fs/promises';
const report = JSON.parse(
await readFile('evidence/epoch-variants.json', 'utf8'),
);
assert.ok(report.completed);
const labels = {
baseline: 'Текущая схема',
'profile-join': 'Профиль из JOIN',
'access-join': 'Профиль + единая проверка доступа',
striped: 'Единая проверка + 16 счётчиков',
};
const aggregates = [];
const lines = [
'# Сравнение трёх оптимизаций эпох и текущей схемы',
'',
`Дата UTC: ${report.recorded_at}.`,
'',
'Все режимы используют Redis. Варианты последовательно добавляют оптимизации: профиль из запроса сессии; объединённую проверку сессии, членства и эпохи; 16 счётчиков истории, увеличиваемых независимо, с суммой как версией кэша. Порядок вариантов меняется между тремя повторами. Чтения: 100 000 сообщений, limit=50, конкурентность 32, прогрев 10 с, измерение 60 с. Запись: 4096 сообщений в отдельный новый чат на вариант/повтор. Только один workload активен одновременно.',
'',
'RPS рассчитан по общему числу успешных запросов и времени повторов. Средняя задержка взвешена по числу запросов. p95 — среднее p95 отдельных повторов, а не перцентиль объединённой выборки. SQL/HTTP исключает BEGIN/COMMIT/ROLLBACK/SET.',
'',
'| Сценарий | Вариант | Средний RPS | Средняя задержка, мс | Среднее p95, мс | SQL/HTTP | RPS по повторам | Ошибки |',
'| --- | --- | ---: | ---: | ---: | ---: | --- | ---: |',
];
for (const workload of ['warm-history', 'writes-single-chat']) {
for (const [name, label] of Object.entries(labels)) {
const samples = report.samples.filter(
(sample) => sample.variant === name && sample.workload === workload,
);
assert.equal(samples.length, 3);
const sum = (select) =>
samples.reduce((total, sample) => total + select(sample), 0);
const successes = sum((sample) => sample.successes);
const errors = sum((sample) => sample.errors);
const aggregate = {
variant: name,
workload,
successes,
errors,
rps: successes / sum((sample) => sample.elapsed_seconds),
mean_latency_ms:
sum((sample) => sample.mean_latency_ms * sample.successes) / successes,
mean_p95_ms: sum((sample) => sample.p95_ms) / samples.length,
sql_per_request:
sum((sample) => sample.sql_queries) / (successes + errors),
repeat_rps: samples.map((sample) => sample.rps),
};
aggregates.push(aggregate);
lines.push(
`| ${workload} | ${label} | ${aggregate.rps.toFixed(3)} | ${aggregate.mean_latency_ms.toFixed(3)} | ${aggregate.mean_p95_ms.toFixed(3)} | ${aggregate.sql_per_request.toFixed(3)} | ${aggregate.repeat_rps.map((value) => value.toFixed(1)).join(' / ')} | ${errors} |`,
);
assert.ok(Object.values(report.correctness[name]).every(Boolean));
}
}
lines.push(
'',
'Все варианты прошли проверки 401/404/400, доступа постороннего пользователя, чтения после записи при недоступном Redis и после восстановления со старыми ключами, отката счётчика при ошибке INSERT, задержанного заполнения старого кэша и работы с пустым кэшем. После каждого нагрузочного блока проверены число сообщений и значение эпохи 4096.',
'',
'Четыре API и HTTP-генератор работают в одном Node-процессе, каждый API имеет отдельный Redis-prefix и пул Prisma прежнего размера. Методы переключаются между скомпилированными снимками исходников перед каждым workload; скрипт сохраняет метаданные маршрутов. Idle-экземпляры присутствуют во всех режимах. CPU/RSS включает генератор и все экземпляры. Другие сервисы Docker-host продолжают работать. Сессии создаются напрямую, KDF не измеряется. Порядок меняется, но три повтора и фоновые нагрузки всё ещё ограничивают выводы об устойчивых коэффициентах ускорения.',
'',
'Распределённые счётчики находятся в отдельной временной схеме. Рабочая схема приложения не переключается на них. В нагрузочном чате 16 ненулевых счётчиков; стоимость их суммирования входит в запрос доступа. Первое чтение baseline выполнено до заполнения счётчиков временной схемы; данные истории неизменны, счётчики подготовлены до первого измерения striped. Это изменение подготовки фикстуры добавлено в скрипт для следующих запусков.',
'',
'Сырые результаты: [epoch-variants.json](epoch-variants.json). Хеши исходников вариантов: [epoch-variants-code.json](epoch-variants-code.json).',
);
await writeFile('evidence/epoch-variants-summary.md', lines.join('\n') + '\n');
await writeFile(
'evidence/epoch-variants-averages.json',
JSON.stringify(aggregates, null, 2) + '\n',
);
console.log(lines.slice(0, 19).join('\n'));
+195
View File
@@ -0,0 +1,195 @@
import 'dotenv/config';
import assert from 'node:assert/strict';
import { createHash, randomUUID } from 'node:crypto';
import { mkdir, writeFile } from 'node:fs/promises';
import { createRequire } from 'node:module';
import { resolve } from 'node:path';
import { spawnSync } from 'node:child_process';
const require = createRequire(import.meta.url);
const { Client } = require('pg');
assert.ok(process.env.DATABASE_URL, 'Set DATABASE_URL for the project PostgreSQL');
const output = resolve('evidence');
const schema = `explain_history_${randomUUID().replaceAll('-', '')}`;
const table = `"${schema}"."messages"`;
const client = new Client({
connectionString: process.env.DATABASE_URL,
connectionTimeoutMillis: 5000,
query_timeout: 60000,
options: '-c statement_timeout=60000 -c lock_timeout=2000',
});
const seed = `
WITH base AS (
SELECT n, CASE WHEN (n - 1) % 6 < 2 THEN 0 ELSE (n - 1) % 6 - 1 END AS chat_no
FROM generate_series(1, 60000) AS n
), ranked AS (
SELECT n, chat_no, row_number() OVER (PARTITION BY chat_no ORDER BY n) AS chat_seq
FROM base
)
INSERT INTO ${table} (id, chat_id, sender_id, text, created_at)
SELECT md5('message:' || n)::uuid, md5('chat:' || chat_no)::uuid,
md5('sender:' || (n % 20))::uuid,
rpad('Synthetic message ' || n || ' ', 256, '.'),
'2026-01-01T00:00:00Z'::timestamptz + ((chat_seq - 1) / 10) * interval '1 second'
FROM ranked ORDER BY n`;
const columns = 'id, chat_id, sender_id, text, created_at';
const firstSql = `SELECT ${columns} FROM ${table}
WHERE chat_id = $1::uuid ORDER BY created_at ASC, id ASC LIMIT $2`;
const orSql = `SELECT ${columns} FROM ${table}
WHERE chat_id = $1::uuid
AND (created_at > $2::timestamptz OR (created_at = $2::timestamptz AND id > $3::uuid))
ORDER BY created_at ASC, id ASC LIMIT $4`;
const tupleSql = `SELECT ${columns} FROM ${table}
WHERE chat_id = $1::uuid AND (created_at, id) > ($2::timestamptz, $3::uuid)
ORDER BY created_at ASC, id ASC LIMIT $4`;
function nodes(plan) {
return [plan, ...(plan.Plans ?? []).flatMap(nodes)];
}
function median(values) {
const sorted = [...values].sort((a, b) => a - b);
return sorted[Math.floor(sorted.length / 2)];
}
function inspectDocker() {
const template = '{"cpus":{{.NCPU}},"memory_bytes":{{.MemTotal}},"server_version":{{json .ServerVersion}},"os":{{json .OperatingSystem}},"arch":{{json .Architecture}}}';
const result = spawnSync('docker', ['info', '--format', template], {
encoding: 'utf8', timeout: 10000, windowsHide: true,
});
try {
if (result.status !== 0) return null;
const info = JSON.parse(result.stdout);
const ids = spawnSync('docker', ['compose', 'ps', '--quiet', 'postgres'], {
encoding: 'utf8', timeout: 10000, windowsHide: true,
});
if (ids.status === 0 && ids.stdout.trim()) {
const limitsTemplate = '{"image":{{json .Config.Image}},"memory_limit_bytes":{{.HostConfig.Memory}},"nano_cpus":{{.HostConfig.NanoCpus}},"cpu_quota":{{.HostConfig.CpuQuota}},"cpu_period":{{.HostConfig.CpuPeriod}},"cpuset_cpus":{{json .HostConfig.CpusetCpus}}}';
const limits = spawnSync('docker', ['inspect', '--format', limitsTemplate, ids.stdout.trim()], {
encoding: 'utf8', timeout: 10000, windowsHide: true,
});
if (limits.status === 0) info.postgres_container = JSON.parse(limits.stdout);
}
return info;
} catch {
return null;
}
}
await client.connect();
const runs = [];
const raw = [];
const signatures = new Map();
let metadata;
let queries;
let cleanup = false;
let sourceIndexes;
try {
sourceIndexes = (await client.query("SELECT indexname, indexdef FROM pg_indexes WHERE schemaname = 'public' AND tablename = 'messages' ORDER BY indexname")).rows;
await client.query('BEGIN');
await client.query(`CREATE SCHEMA "${schema}"`);
await client.query(`CREATE TABLE ${table} (LIKE public.messages INCLUDING DEFAULTS INCLUDING CONSTRAINTS INCLUDING STORAGE)`);
await client.query(seed);
await client.query(`ANALYZE ${table}`);
const distribution = (await client.query(`SELECT chat_id, count(*)::integer AS messages FROM ${table} GROUP BY chat_id ORDER BY messages DESC, chat_id`)).rows;
assert.equal(distribution.reduce((sum, row) => sum + row.messages, 0), 60000);
const chatId = distribution.find((row) => row.messages === 20000).chat_id;
const cursor = async (offset) => (await client.query(
`SELECT id, created_at FROM ${table} WHERE chat_id = $1::uuid ORDER BY created_at, id OFFSET $2 LIMIT 1`,
[chatId, offset],
)).rows[0];
const middle = await cursor(9999);
const late = await cursor(17999);
queries = [
{ name: 'first_page', sql: firstSql, parameters: [chatId, 51] },
{ name: 'middle_page_or', sql: orSql, parameters: [chatId, middle.created_at.toISOString(), middle.id, 51] },
{ name: 'late_page_or', sql: orSql, parameters: [chatId, late.created_at.toISOString(), late.id, 51] },
{ name: 'late_page_tuple', sql: tupleSql, parameters: [chatId, late.created_at.toISOString(), late.id, 51] },
];
const settings = (await client.query(
'SELECT name, setting, unit FROM pg_settings WHERE name = ANY($1::text[]) ORDER BY name',
[['server_version', 'shared_buffers', 'work_mem', 'random_page_cost', 'effective_cache_size', 'max_parallel_workers_per_gather', 'jit', 'block_size']],
)).rows;
metadata = {
recorded_at: new Date().toISOString(),
command: 'node test/explain-history.mjs',
node_version: process.version,
docker: inspectDocker(),
settings,
source_table_indexes_before: sourceIndexes,
dataset: { total_messages: 60000, target_chat_messages: 20000, chats: 5, distribution, text_length: 256, timestamp_ties: 10, insertion_order: 'interleaved chats' },
method: { warmup_runs_per_query_per_phase: 1, measured_runs: 5, page_size: 50, fetched_rows: 51, cursor_positions: [10000, 18000], cache: 'warm PostgreSQL buffers; Redis is bypassed', cleanup: 'ROLLBACK the experiment schema; live tables and indexes unchanged', planner: 'default scan settings; no forced index or disabled sequential scans', schema_difference: 'copied columns/checks/defaults; foreign keys omitted equally in all phases', tuple_variant: 'current cursor SQL in ChatService.listMessages; OR is the pre-fix baseline' },
};
const phases = [
{ name: 'no_indexes', ddl: [] },
{ name: 'without_history_index', ddl: [`CREATE UNIQUE INDEX messages_pkey ON ${table} (id)`, `CREATE INDEX messages_sender_id_idx ON ${table} (sender_id)`] },
{ name: 'with_history_index', ddl: [`CREATE INDEX messages_chat_id_created_at_id_idx ON ${table} (chat_id, created_at, id)`] },
];
for (const phase of phases) {
for (const ddl of phase.ddl) await client.query(ddl);
await client.query(`ANALYZE ${table}`);
const indexes = (await client.query('SELECT indexname, indexdef FROM pg_indexes WHERE schemaname = $1 ORDER BY indexname', [schema])).rows;
const phaseRuns = new Map(queries.map((query) => [query.name, []]));
for (const query of queries) {
const rows = (await client.query(query.sql, query.parameters)).rows;
assert.equal(rows.length, 51);
const signature = createHash('sha256').update(JSON.stringify(rows)).digest('hex');
if (signatures.has(query.name)) assert.equal(signature, signatures.get(query.name));
else signatures.set(query.name, signature);
if (query.name === 'late_page_tuple') assert.equal(signature, signatures.get('late_page_or'));
await client.query(`EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) ${query.sql}`, query.parameters);
}
for (let repetition = 1; repetition <= 5; repetition++) {
for (const query of queries) {
const plan = (await client.query(`EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) ${query.sql}`, query.parameters)).rows[0]['QUERY PLAN'][0];
phaseRuns.get(query.name).push(plan);
}
}
for (const query of queries) {
const plans = phaseRuns.get(query.name);
const medianMs = median(plans.map((plan) => plan['Execution Time']));
const representative = plans.find((plan) => plan['Execution Time'] === medianMs);
const flat = nodes(representative.Plan);
const scan = flat.find((node) => node['Node Type'].includes('Scan'));
runs.push({
phase: phase.name, query: query.name, indexes, sql: query.sql, parameters: query.parameters,
result_sha256: signatures.get(query.name), execution_ms: plans.map((plan) => plan['Execution Time']),
median_execution_ms: medianMs, representative_plan: representative,
scan_type: scan?.['Node Type'], index_name: scan?.['Index Name'] ?? null,
rows_removed_by_filter: scan?.['Rows Removed by Filter'] ?? 0,
scanned_rows: ((scan?.['Actual Rows'] ?? 0) + (scan?.['Rows Removed by Filter'] ?? 0)) * (scan?.['Actual Loops'] ?? 1),
sort: flat.some((node) => node['Node Type'] === 'Sort'),
shared_buffer_hits: representative.Plan['Shared Hit Blocks'] ?? 0,
shared_buffer_reads: representative.Plan['Shared Read Blocks'] ?? 0,
raw_plans: plans,
});
const textPlan = (await client.query(`EXPLAIN (ANALYZE, BUFFERS) ${query.sql}`, query.parameters)).rows.map((row) => row['QUERY PLAN']).join('\n');
raw.push(`=== ${phase.name} / ${query.name} ===\nIndexes: ${indexes.map((index) => index.indexname).join(', ') || '(none)'}\nSQL:\n${query.sql}\nParameters: ${JSON.stringify(query.parameters)}\n\n${textPlan}\n`);
console.log(`${phase.name} / ${query.name}: median ${medianMs.toFixed(3)} ms; ${scan?.['Node Type']}; scanned ${runs.at(-1).scanned_rows}; sort=${runs.at(-1).sort}`);
}
}
} finally {
try {
await client.query('ROLLBACK');
if (metadata) {
metadata.source_table_indexes_after = (await client.query("SELECT indexname, indexdef FROM pg_indexes WHERE schemaname = 'public' AND tablename = 'messages' ORDER BY indexname")).rows;
assert.deepEqual(metadata.source_table_indexes_after, sourceIndexes);
const leftovers = (await client.query('SELECT count(*)::integer AS count FROM pg_namespace WHERE nspname = $1', [schema])).rows[0].count;
assert.equal(leftovers, 0);
metadata.experiment_schema_absent = true;
}
cleanup = true;
} finally {
await client.end();
}
}
assert.equal(cleanup, true);
await mkdir(output, { recursive: true });
await writeFile(resolve(output, 'history-index-explain.json'), JSON.stringify({ ...metadata, cleanup_completed: cleanup, runs }, null, 2) + '\n');
await writeFile(resolve(output, 'history-index-plans.txt'), raw.join('\n'));
const labels = { no_indexes: 'Без индексов', without_history_index: 'PK + sender_id, без индекса истории', with_history_index: 'С индексом истории' };
const tableRows = runs.map((row) => `| ${labels[row.phase]} | ${row.query} | ${row.median_execution_ms.toFixed(3)} | ${row.scan_type} | ${row.scanned_rows} | ${row.sort ? 'да' : 'нет'} | ${row.shared_buffer_hits} / ${row.shared_buffer_reads} |`).join('\n');
const speedup = (query) => runs.find((row) => row.query === query && row.phase === 'no_indexes').median_execution_ms / runs.find((row) => row.query === query && row.phase === 'with_history_index').median_execution_ms;
const summary = `# EXPLAIN истории сообщений: с индексами и без\n\nДата UTC: ${metadata.recorded_at}. PostgreSQL ${metadata.settings.find((setting) => setting.name === 'server_version').setting}.\n\nКоманда: \`node test/explain-history.mjs\` (нужен \`DATABASE_URL\`; PostgreSQL проекта с применёнными миграциями).\n\n60 000 синтетических сообщений в пяти чатах; в целевом чате 20 000. Чаты перемежаются при вставке, текст 256 символов, по 10 сообщений имеют одинаковый created_at. Страница API: 50 сообщений + 1 для next_cursor. Курсоры после 10 000-го и 18 000-го сообщений. Запросы первой страницы и с OR соответствуют прежнему \`ChatService.listMessages\`; tuple — исправленное условие курсора, используемое в текущем API. Скрипт сравнивает прежний и исправленный запросы; сам код API не меняет.\n\n| Индексы | Запрос | Медиана, мс | Scan | Проверено строк | Sort | Buffers hit/read |\n| --- | --- | ---: | --- | ---: | --- | ---: |\n${tableRows}\n\nПервая страница с индексом быстрее варианта без индексов в ${speedup('first_page').toFixed(1)} раза на этом наборе и стенде. Само наличие PK и индекса sender_id не заменяет индекс истории. Составной B-tree \`(chat_id, created_at, id)\` соответствует равенству chat_id и порядку истории; наличие Sort и границы Index Cond видны в сохранённых планах. ORDER BY нужен и при наличии индекса.\n\nПоздняя страница с OR: ${runs.find((row) => row.phase === 'with_history_index' && row.query === 'late_page_or').scanned_rows} проверенных строк. Эквивалентное сравнение пары: ${runs.find((row) => row.phase === 'with_history_index' && row.query === 'late_page_tuple').scanned_rows} строк. Это показывает, удалось ли передать границу курсора в Index Cond или она осталась Filter. Совпадение результатов всех фаз и OR/tuple проверено SHA-256 от полных 51 строк.\n\nМетодика: отдельная таблица с колонками текущей public.messages в случайной схеме; одинаковые данные во всех фазах; ANALYZE после загрузки и изменений индексов; 1 прогрев + 5 измерений каждого запроса в каждой фазе, медиана PostgreSQL Execution Time. Планы не принуждались настройками enable_seqscan/enable_indexscan. Фаза с индексом сохраняет PK и sender_id. Все создание таблиц, данных и индексов выполнены внутри транзакции; ROLLBACK удалил экспериментальную схему. Рабочие таблицы и индексы не изменялись.\n\nОграничения: это прогретый SQL-тест без HTTP, Redis, аутентификации и конкуренции; не cold-cache benchmark, не измерение RPS и не доказательство latency всего API. FK не копировались, поскольку сравнивается чтение; это одинаково во всех фазах. Измерения зависят от ресурсов и нагрузки Docker-host. Лимиты и настройки PostgreSQL записаны в JSON; текстовые планы сняты отдельным запуском, поэтому их времена могут отличаться от медиан JSON.\n\nФайлы: [полные текстовые планы](history-index-plans.txt), [JSON, пять повторов, настройки и результаты](history-index-explain.json).\n`;
await writeFile(resolve(output, 'history-index-summary.md'), summary);
console.log(`Saved EXPLAIN evidence to ${output}; experiment schema rolled back.`);
+268
View File
@@ -0,0 +1,268 @@
const assert = require('node:assert/strict');
const fs = require('node:fs');
const os = require('node:os');
const path = require('node:path');
const { createHash } = require('node:crypto');
const { spawn, execFileSync } = require('node:child_process');
const ts = require('typescript');
const root = path.resolve(__dirname, '..');
const resultPrefix = process.env.EXPERIMENT_PREFIX ?? 'cache-strategy';
assert.match(resultPrefix, /^[a-z0-9-]+$/);
const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'lab2-no-epochs-'));
const hashes = {};
const volumes = [];
const replace = (source, from, to) => {
assert.ok(source.includes(from), `Missing replacement: ${from}`);
assert.equal(
source.indexOf(from),
source.lastIndexOf(from),
`Ambiguous replacement: ${from}`,
);
return source.replace(from, to);
};
const section = (source, from, to, replacement) => {
const start = source.indexOf(from);
const end = source.indexOf(to, start);
assert.ok(start !== -1 && end > start, `Missing section: ${from}`);
return source.slice(0, start) + replacement + source.slice(end);
};
const digest = (value) => createHash('sha256').update(value).digest('hex');
const transforms = {
'Chat/chat.service.ts': (source) => {
source = section(
source,
' await tx.$executeRaw(',
' return created;',
'',
);
source = replace(source, ' epoch: string,\n', '');
source = replace(source, ' epoch,\n', '');
source = section(
source,
' const [membership] =',
' if (!membership)',
' const [membership] = await this.prisma.$queryRaw<{ id: string }[]>(Prisma.sql`\n' +
' SELECT cm.chat_id AS id FROM chat_members AS cm\n' +
' WHERE cm.chat_id = ${id}::uuid AND cm.user_id = ${userId}::uuid\n' +
' `);\n',
);
source = section(
source,
' const [message] =',
' if (!message)',
' const [message] = await this.prisma.$queryRaw<StoredMessage[]>(Prisma.sql`\n' +
' INSERT INTO messages (id, chat_id, sender_id, text)\n' +
' SELECT ${randomUUID()}::uuid, cm.chat_id, ${userId}::uuid, ${text}\n' +
' FROM chat_members AS cm\n' +
' WHERE cm.chat_id = ${id}::uuid AND cm.user_id = ${userId}::uuid\n' +
' RETURNING id, chat_id AS "chatId", sender_id AS "senderId",\n' +
' text, created_at AS "createdAt"\n' +
' `);\n',
);
return replace(source, ' chat.messagesEpoch.toString(),\n', '');
},
'Auth/auth.service.ts': (source) => {
source = source.replace(
/COALESCE\(\(SELECT SUM\(e\.epoch\)[\s\S]*?0\)::bigint AS "messagesEpoch"/g,
'0::bigint AS "messagesEpoch"',
);
return source
.replaceAll('u.chats_epoch', '0::bigint')
.replaceAll('c.messages_epoch', '0::bigint');
},
'User/user.guard.ts': (source) => {
source = replace(source, ' currentChatsEpoch: string;\n', '');
return replace(
source,
' request.currentChatsEpoch = session.chatsEpoch;\n',
'',
);
},
'Chat/chat.controller.ts': (source) =>
replace(source, ' request.currentChatsEpoch,\n', ''),
'cache/cache.service.ts': (source) => {
source = replace(source, ' epoch?: string,\n', '');
return section(
source,
' if (epoch !== undefined)',
' const versionKey =',
'',
);
},
'User/user.service.ts': (source) => {
source = replace(
source,
'const user = await this.prisma.user.findUnique({ where: { id } });',
'const user = await this.prisma.user.findUnique({ where: { id }, select: { id: true, username: true, displayName: true, createdAt: true } });',
);
return source;
},
};
try {
for (const [relative, transform] of Object.entries(transforms)) {
const original = fs.readFileSync(path.join(root, 'src', relative), 'utf8');
const source = transform(original.replace(/\r\n/g, '\n'));
assert.ok(
!/messages_epoch|chats_epoch|chat_message_epochs/.test(source),
relative,
);
const compiled = ts.transpileModule(source, {
compilerOptions: {
target: ts.ScriptTarget.ES2023,
module: ts.ModuleKind.CommonJS,
experimentalDecorators: true,
emitDecoratorMetadata: true,
},
reportDiagnostics: true,
});
assert.equal(
compiled.diagnostics.filter(
(item) => item.category === ts.DiagnosticCategory.Error,
).length,
0,
);
const sourcePath = path.join(directory, relative);
const compiledPath = sourcePath.replace(/\.ts$/, '.js');
fs.mkdirSync(path.dirname(sourcePath), { recursive: true });
fs.writeFileSync(sourcePath, source);
fs.writeFileSync(compiledPath, compiled.outputText);
hashes[relative] = {
original_source: digest(original),
experiment_source: digest(source),
experiment_js: digest(compiled.outputText),
};
volumes.push({
type: 'bind',
source: compiledPath,
target: `/app/dist/${relative.replace(/\.ts$/, '.js')}`,
read_only: true,
});
}
let benchmark = fs
.readFileSync(path.join(root, 'test/cache-benchmark.mjs'), 'utf8')
.replace(/\r\n/g, '\n');
benchmark = replace(
benchmark,
'process.env.CACHE_URL = proxy.url;',
'delete process.env.CACHE_URL;',
);
benchmark = section(
benchmark,
' await prisma.chatMessageEpoch.createMany(',
' const path =',
'',
);
benchmark = section(
benchmark,
' const second = await start();',
' report.completed = true;',
' assert.equal(first.app.get(CacheService).redis, undefined);\n' +
' for (const chatId of chatIds) {\n' +
' assert.equal(await messageEpoch(prisma, chatId), 0n);\n' +
' }\n' +
' assert.equal((await prisma.user.findUniqueOrThrow({ where: { id: userId } })).chatsEpoch, 0n);\n' +
' for (const chatId of chatIds.slice(1)) {\n' +
' const page = await request("GET", `/api/v1/chats/${chatId}/messages`);\n' +
' assert.equal(page.items.length, 50);\n' +
' assert.equal(new Set(page.items.map(message => message.id)).size, 50);\n' +
' }\n' +
' report.correctness = { no_redis_client: true, epochs_unchanged: true, read_after_write: true };\n' +
' }\n',
);
const benchmarkPath = path.join(directory, 'cache-benchmark.mjs');
fs.writeFileSync(benchmarkPath, benchmark);
volumes.push({
type: 'bind',
source: benchmarkPath,
target: '/experiment/cache-benchmark.mjs',
read_only: true,
});
volumes.push({
type: 'bind',
source: path.join(root, 'test/helpers'),
target: '/experiment/helpers',
read_only: true,
});
const override = path.join(directory, 'compose.no-epochs.yaml');
fs.writeFileSync(
override,
JSON.stringify({ services: { benchmark: { volumes } } }, null, 2),
);
const args = [
'compose',
'-f',
'compose.yaml',
'-f',
'test/compose.benchmark.yaml',
'-f',
override,
'run',
'--rm',
'--no-deps',
'--pull',
'never',
'benchmark',
'node',
'/experiment/cache-benchmark.mjs',
'after',
`/results/${resultPrefix}-no-redis-no-epochs.json`,
...process.argv.slice(2),
];
const metadata = {
recorded_at: new Date().toISOString(),
image: execFileSync(
'docker',
['image', 'inspect', 'mtusi2026lab2-fork-backend', '--format', '{{.Id}}'],
{ encoding: 'utf8' },
).trim(),
modified_sources: hashes,
command: ['docker', ...args],
implementation:
'Separate temporary source copies compiled with TypeScript and mounted over six application modules. Workspace sources and running backend remain unchanged.',
schema:
'Epoch storage remains in the database; experiment API paths do not update counters or read authoritative epoch values.',
redis:
'Application starts without CACHE_URL. Observer/proxy are retained only for benchmark setup and cleanup.',
full_result: `${resultPrefix}-full.json`,
experiment_result: `${resultPrefix}-no-redis-no-epochs.json`,
};
const child = spawn('docker', args, {
cwd: root,
stdio: 'inherit',
env: process.env,
});
child.once('error', finish);
child.once('exit', (code, signal) => finish(null, code, signal));
let finished = false;
function finish(error, code, signal) {
if (finished) return;
finished = true;
metadata.exit_code = error ? 1 : code;
metadata.signal = signal;
metadata.sources_unchanged = Object.entries(hashes).every(
([relative, hash]) =>
digest(fs.readFileSync(path.join(root, 'src', relative), 'utf8')) ===
hash.original_source,
);
fs.writeFileSync(
path.join(root, `evidence/${resultPrefix}-experiment.json`),
JSON.stringify(metadata, null, 2) + '\n',
);
cleanup();
if (error) console.error(error.message);
process.exitCode = error ? 1 : (code ?? 1);
}
} catch (error) {
cleanup();
throw error;
}
function cleanup() {
const resolved = path.resolve(directory);
assert.equal(path.dirname(resolved), path.resolve(os.tmpdir()));
assert.ok(path.basename(resolved).startsWith('lab2-no-epochs-'));
fs.rmSync(resolved, { recursive: true, force: true });
}
+85
View File
@@ -0,0 +1,85 @@
import assert from 'node:assert/strict';
import { readFile, writeFile } from 'node:fs/promises';
const report = JSON.parse(
await readFile('evidence/redis-comparison.json', 'utf8'),
);
assert.ok(report.completed);
assert.ok(Object.values(report.correctness.read_after_write).every(Boolean));
const lines = [
'# Redis и работа без кэша приложения',
'',
`Дата UTC: ${report.recorded_at}. Node.js ${report.node}.`,
'',
'Один прогон на одном образе: три повтора каждого режима с чередованием порядка. Второй экземпляр API запущен без CACHE_URL: отключены все кэши приложения, включая профиль пользователя. PostgreSQL-эпохи и запись одним CTE сохранены в обоих режимах. Контейнер Redis не останавливался; экземпляр без кэша не создаёт Redis-клиент.',
'',
'RPS = суммарное число успешных запросов / суммарное время трёх повторов. Средняя задержка взвешена по числу успешных запросов. p95 — среднее трёх отдельных p95, не перцентиль объединённой выборки. SQL/HTTP = суммарные SQL-вызовы / все HTTP-запросы; команды транзакций исключены.',
'',
'| Сценарий | Режим | Средний RPS | Средняя задержка, мс | Среднее p95, мс | SQL/HTTP | CPU, % ядра | Ошибки |',
'| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |',
];
const aggregates = [];
for (const [workload, label] of [
['cold-history-burst', 'Холодная волна истории'],
['warm-history', 'Прогретая история'],
['writes-single-chat', 'Запись в один чат'],
]) {
for (const mode of ['redis', 'no-redis']) {
const samples = report.samples.filter(
(sample) => sample.workload === `${workload}:${mode}`,
);
assert.equal(samples.length, 3);
const sum = (select) =>
samples.reduce((total, sample) => total + select(sample), 0);
const successes = sum((sample) => sample.successes);
const errors = sum((sample) => sample.errors);
const seconds = sum((sample) => sample.elapsed_seconds);
const aggregate = {
workload,
mode,
successes,
errors,
rps: successes / seconds,
mean_latency_ms:
sum((sample) => sample.latency_ms.mean * sample.successes) / successes,
mean_p95_ms: sum((sample) => sample.latency_ms.p95) / samples.length,
sql_per_request:
sum((sample) => sample.sql_queries) / (successes + errors),
cpu_percent_one_core:
sum(
(sample) =>
sample.process_cpu_percent_one_core * sample.elapsed_seconds,
) / seconds,
};
aggregates.push(aggregate);
lines.push(
`| ${label} | ${mode === 'redis' ? 'Redis' : 'Без Redis'} | ${aggregate.rps.toFixed(3)} | ${aggregate.mean_latency_ms.toFixed(3)} | ${aggregate.mean_p95_ms.toFixed(3)} | ${aggregate.sql_per_request.toFixed(3)} | ${aggregate.cpu_percent_one_core.toFixed(2)} | ${errors} |`,
);
}
}
lines.push(
'',
'В этом прогоне кэш полезен для прогретого чтения истории: выше пропускная способность, ниже средняя задержка и меньше SQL-вызовов. Для холодной волны и записи преимущество по времени не показано. Первый повтор с Redis значительно медленнее остальных; средние включают его, поэтому вывод о стабильной скорости записи ограничен. Это сравнение режимов кэша на текущей реализации, а не отдельное измерение цены PostgreSQL-эпох.',
'',
'Нагрузка: 10 000 сообщений, первая страница limit=50, конкурентность 16, 3 с прогрева и 10 с чтения на режим/повтор, холодная волна 32 запроса, 512 записей в новый чат на режим/повтор. Реальный HTTP по loopback; синтетические пользователи и сессии обходят хеширование паролей. Проверены 512 сообщений и эпоха 512 после каждого сценария записи, а также чтение истории после записи.',
'',
'Оба API и генератор HTTP работают в одном Node-процессе. CPU включает генератор, API и инструментацию; RSS общий и не показывает разницу памяти между режимами. PostgreSQL и Redis разделяют Docker-host с другими сервисами. Это короткая нагрузка, не предел производительности; холодные SQL-данные не имитируются. Уменьшение SQL/HTTP показывает снижение числа запросов, но не доказывает пропорциональное снижение CPU PostgreSQL. Цена самих эпох отдельно не измеряется.',
'',
'Команда повторения:',
'',
'```powershell',
'docker compose -f compose.yaml -f test/compose.benchmark.yaml run --rm --no-deps --pull never benchmark node test/cache-benchmark.mjs after /results/redis-comparison.json --compare-redis',
'node test/redis-comparison-summary.mjs',
'```',
'',
'Сырые результаты и хеши измеренных модулей: [redis-comparison.json](redis-comparison.json).',
);
await writeFile(
'evidence/redis-comparison-summary.md',
lines.join('\n') + '\n',
);
await writeFile(
'evidence/redis-comparison-averages.json',
JSON.stringify(aggregates, null, 2) + '\n',
);
console.log(lines.slice(0, 16).join('\n'));