Производительность и память в Node
Сервис на Node редко падает от одной большой ошибки — чаще он деградирует постепенно: растёт p99, контейнер перезапускается по OOM, а под нагрузкой появляются таймауты, которых нет на стенде. Причина почти всегда в одном: в горячем пути возникла работа, которую единственный поток не может пропустить. Ниже — как измерить эту работу, найти её профилировщиком, поймать утечку памяти и проверить результат нагрузочным тестом, а не догадками.
Содержание
- Latency, throughput и узкое место
- Порядок действий: измерять, а не угадывать
- CPU-профилирование
- Event loop lag и блокирующие операции
- Память: heap, external и GC
- Утечки памяти в Node-сервисе
- Heap snapshot: снять и сравнить
- Память в проде: метрики и лимиты
- Нагрузочное тестирование
- Что оптимизировать в первую очередь
- Практика: TaskFlow
- Частые ошибки
- Ключевые тезисы для интервью
- Заключение
- Полезные ссылки
Latency, throughput и узкое место
Производительность сервиса описывают две величины, и путать их дорого. Throughput — сколько запросов в секунду сервис успевает обработать, сохраняя приемлемое время ответа. Latency — сколько ждёт один клиент, причём смотреть нужно на распределение, а не на среднее.
Среднее время ответа почти бесполезно: один запрос из сотни, который длился четыре секунды, меняет среднее на десятки миллисекунд, но именно он раздражает пользователя и попадает в алерты. Поэтому меряют перцентили: p50 показывает типичный опыт, p95 и p99 — хвост, из-за которого клиенты ставят таймауты и уходят.
Связь между величинами задаёт закон Литтла: L = λ × W, где L — число одновременных запросов, λ — пропускная способность, W — время ответа. При 200 RPS и 100 мс в системе одновременно живут около 20 запросов. Если пул соединений к базе равен десяти, остальные десять стоят в очереди — и это уже задержка, которой нет ни в CPU, ни в дисках.
У насыщения есть точка перегиба. До неё рост нагрузки почти не меняет latency, после — RPS перестаёт расти, а задержка растёт нелинейно, потому что запросы копятся в очередях. Искать эту точку важнее, чем гнаться за максимумом RPS: работать нужно с запасом до перегиба.
| Симптом | Вероятная причина | Куда смотреть |
|---|---|---|
p99 растёт, CPU упирается в 100% | синхронные вычисления в обработчике | CPU-профиль, worker_threads |
p99 растёт, CPU низкий | ожидание базы, внешнего API или пула | трейс, метрики пула и очередей |
| RPS падает, ошибок в логах нет | таймауты и насыщение очередей | event loop lag, насыщение ресурсов |
| RSS растёт от часа к часу | утечка или неограниченный кеш | heap snapshot, memoryUsage |
| Память падает после рестарта и снова растёт | утечка, замаскированная перезапуском | сравнение heap snapshots |
В Node есть особенность, которой нет у многих рантаймов: насыщение проявляется не только в CPU и пулах, но и в event loop lag. Цикл занят — значит, не обслуживаются ни новые соединения, ни таймеры, ни продолжения await. Поэтому лаг входит в базовый набор метрик наравне с RPS и памятью («Логирование и наблюдаемость»).
Порядок действий: измерять, а не угадывать
Работа над производительностью — это цикл, а не список трюков. Порядок почти всегда такой:
- Сформулировать симптом. Не «сервис медленный», а «
p99наGET /tasksвырос с 200 до 900 мс после релиза» или «RSS растёт на 100 МБ в час». - Посмотреть метрики. RPS, перцентили, доля ошибок, CPU, память, event loop lag, насыщение пулов. Симптом без цифр — это жалоба, а не задача.
- Классифицировать проблему. Вычисления, ожидание ввода-вывода, очередь или память — у каждого свой инструмент.
- Воспроизвести. Нагрузочный тест или синтетический сценарий с прод-подобными данными: на пустой базе и маленьком JSON всё летает.
- Снять профиль. CPU-профиль или heap snapshot — в зависимости от шага 3.
- Исправить и проверить тем же измерением. Сравнение «до/после» на одинаковой нагрузке, а не ощущение, что стало лучше.
Три правила, которые экономят недели:
- Одна переменная за раз. Поменяли кеш и пул одновременно — непонятно, что дало эффект.
- Профилировщик искажает. Сэмплирование добавляет накладные расходы, инструментирование меняет тайминги; выводы делают по устойчивым горячим точкам, а не по единичному всплеску.
- Горячий путь важнее редкого. Оптимизация админского экспорта раз в сутки не поможет
p99на листинге задач.
Отдельно про микробенчмарки: замерять отдельную функцию полезно, только когда узкое место уже локализовано. JIT разогревается не сразу, а результат может быть выброшен как неиспользуемый — поэтому берут готовые харнессы вроде tinybench, делают прогрев и несколько прогонов. Микрооптимизация в 5% редко видна на фоне запроса к базе.
CPU-профилирование
Если CPU занят, а latency растёт, нужно понять, какой стек его занимает. CPU-профилировщик периодически снимает стек вызовов и агрегирует сэмплы: в отчёте видно, сколько времени пришлось на функцию и кто её вызвал.
| Инструмент | Что даёт | Когда использовать |
|---|---|---|
--inspect + DevTools | интерактивный профиль, heap и пошаговая отладка | локально, на стенде |
--cpu-prof | файл .cpuprofile для DevTools | стенд, контейнер, воспроизводимый сценарий |
--prof + --prof-process | текстовый отчёт по тикам | сервер без GUI, быстрый взгляд |
clinic doctor | диагноз: CPU, I/O, event loop | непонятно, что именно болит |
clinic flame / 0x | флеймграф | поиск горячей ветки вызовов |
--perf-basic-prof + perf | нативные стеки | Linux, нативные аддоны |
Самый простой путь — записать профиль файлом и открыть его в DevTools:
# файл .cpuprofile появится в ./profiles
node --cpu-prof --cpu-prof-dir=./profiles src/server.js
# текстовый отчёт без графики: удобно на стенде и в контейнере
node --prof src/server.js
node --prof-process isolate-*.log > profile.txt
Читать флеймграф просто: ширина блока — доля времени, верхушка стека — функция, которая реально работала. Ищут не «самую длинную функцию», а широкую ветку: например, JSON.parse внутри контроллера, сериализацию ответа или регулярное выражение, которое не заканчивается.
npx clinic doctor -- node src/server.js
npx clinic flame -- node src/server.js
npx 0x src/server.js
Две оговорки. Пустой профиль — тоже результат: если процесс почти всё время ждёт, сэмплы попадают в простой, и проблема не в CPU, а в I/O или пуле. И не открывайте инспектор наружу: --inspect=0.0.0.0:9229 в проде даёт любому желающему отладчик с исполнением кода, поэтому только 127.0.0.1 и через туннель.
Асинхронный код усложняет картину: работа распределена между колбэками, и «функция-виновник» может быть маленькой, но вызываемой на каждый чанк. Здесь помогают агрегированные отчёты по типам операций (clinic doctor) и трейсы, где видно, сколько времени ушло в базу, а сколько — в JS («Логирование и наблюдаемость»).
Event loop lag и блокирующие операции
Event loop lag — разница между моментом, когда таймер должен был сработать, и моментом, когда цикл до него дошёл. Это прямая мера того, насколько процесс занят синхронной работой, и она реагирует раньше, чем клиентские таймауты: лаг в 200 мс при SLO в 300 мс уже съедает две трети бюджета.
// src/lib/event-loop.js
import { monitorEventLoopDelay, performance } from 'node:perf_hooks';
const histogram = monitorEventLoopDelay({ resolution: 20 }); // разрешение в мс
histogram.enable();
let previous = performance.eventLoopUtilization();
let utilization = 0;
// окно наблюдения: гистограмма и загрузка считаются за последнюю минуту
setInterval(() => {
utilization = performance.eventLoopUtilization(previous).utilization;
previous = performance.eventLoopUtilization();
histogram.reset();
}, 60_000).unref();
export function readLag() {
return {
p50: histogram.percentile(50) / 1e6, // гистограмма считает в наносекундах
p99: histogram.percentile(99) / 1e6,
max: histogram.max / 1e6,
// доля времени, когда цикл был занят, а не спал в poll
utilization,
};
}
Лаг и eventLoopUtilization дополняют друг друга. Высокая утилизация означает, что цикл почти не простаивает: сервис упирается в CPU или в объём работы на итерацию. Низкая утилизация при высокой latency говорит, что время уходит не в JavaScript, а в ожидание ввода-вывода или пула.
Что чаще всего блокирует поток:
- Синхронные API в обработчике:
readFileSync,execSync,pbkdf2Sync,zlib.gzipSync. Пока они работают, цикл стоит. - Большие JSON:
JSON.parseтела на десятки мегабайт иJSON.stringifyответа — это работа V8, а не пула. - Регулярные выражения с катастрофическим бэктрекингом: строка на несколько килобайт может занять секунды, и это классический ReDoS.
- Тяжёлые циклы и сортировки: расчёт отчёта, пересчёт статистики, обход большого дерева.
- Синхронная запись в stdout:
console.logв горячем пути добавляет лаг, особенно когда поток логов далеко.
Асинхронная версия той же операции уходит в пул libuv (fs, dns.lookup, crypto.pbkdf2, zlib), и это помогает, только если операция нативная. JSON.parse, регэксп и цикл в пул не уходят ни при каком UV_THREADPOOL_SIZE — их выносят в worker_threads или в фоновую очередь («Worker Threads и cluster»).
Отдельно про пул: если он занят, колбэки fs и crypto приходят с задержкой, но event loop при этом свободен. Поэтому высокий лаг и высокий CPU указывают на JS, а высокая latency при низком лаге — на ожидание пула, базы или внешнего сервиса.
Память: heap, external и GC
process.memoryUsage() отдаёт несколько чисел, и они отвечают на разные вопросы:
| Поле | Что считает | Растёт при |
|---|---|---|
rss | всю резидентную память процесса | буферах, нативных структурах, утечке кучи |
heapTotal | сколько V8 зарезервировал под объекты | нагрузке и фрагментации кучи |
heapUsed | живые объекты после последней сборки | утечке объектов |
external | память C++-объектов, привязанных к JS | Buffer, сжатии, криптографии |
arrayBuffers | часть external под ArrayBuffer и SharedArrayBuffer | бинарных данных, стримах |
Куча V8 делится на поколения. Молодое поколение небольшое, чистится часто и дешёво (scavenge); объекты, пережившие несколько сборок, переезжают в старое поколение, где работает mark-compact — дороже и реже. Поэтому heapUsed в норме пилообразный: растёт между сборками и падает после них. Утечка — это не пила, а растущая нижняя граница после GC.
Высокая скорость аллокаций сама по себе стоит денег: чем больше мусора, тем чаще minor GC, тем больше CPU уходит не на запросы. Иногда «оптимизация памяти» — это не поиск утечки, а уменьшение числа временных объектов: стрим вместо буферизации, пагинация вместо всего массива, отказ от глубокого клонирования.
Внешняя память — отдельная ловушка Node. Buffer и ArrayBuffer живут вне кучи V8, в external, и именно они чаще всего приводят к тому, что процесс убивает cgroup. --max-old-space-size ограничивает только старое поколение кучи, поэтому буферная утечка спокойно проходит мимо лимита и упирается в лимит контейнера.
Паузы GC видны в метриках через PerformanceObserver:
// src/lib/gc.js
import { PerformanceObserver } from 'node:perf_hooks';
import { Histogram } from 'prom-client';
import { registry } from './metrics.js';
export const gcDuration = new Histogram({
name: 'nodejs_gc_duration_seconds',
help: 'GC pause duration',
buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5],
registers: [registry],
});
new PerformanceObserver((list) => {
for (const entry of list.getEntries()) {
gcDuration.observe(entry.duration / 1000); // прометей ждёт секунды
}
}).observe({ entryTypes: ['gc'] });
Рост времени в GC при стабильном RPS — признак того, что либо копится мусор, либо куча приближается к лимиту: сборщик тратит больше времени на те же операции. Устройство кучи и mark-and-sweep разобраны в статье «Память и производительность»; здесь важна серверная часть — какие объекты удерживаются дольше запроса.
Утечки памяти в Node-сервисе
Утечка в Node — это объект, до которого можно добраться от корня (глобальный объект, модульный кеш, активный таймер, слушатель, стек), хотя он больше не нужен. Сборщик не ошибается: он не может освободить то, на что есть ссылка. Значит, искать нужно не «плохой GC», а держателя.
Самые частые держатели в серверном коде:
- Модульный кеш без eviction.
Map, объект на уровне модуля или глобальная переменная, которая пополняется на каждый запрос и никогда не чистится. Это утечка номер один, потому что выглядит как оптимизация. - Слушатели событий. Подписка на
EventEmitter,processили сокет внутри обработчика, которая не снимается при закрытии соединения. Слушатель держит замыкание, замыкание —req/res, аres— буферы ответа. - Таймеры и периодические задачи.
setInterval, созданный на запрос и не очищенный; задача в очереди, которая держит контекст запроса. - Замкнутые ссылки на большие данные. Кеш функций, мемоизация с ключом-объектом, замыкание над ответом целиком.
- Срезы буферов.
buf.subarray()иbuf.slice()не копируют: килобайтный срез держит родительский буфер на сотни мегабайт. - Очереди без границ. Накопитель задач,
maxQueueу пула воркеров, массив незавершённых промисов. - Контексты
AsyncLocalStorage. Если в хранилище положить тело запроса или ответ, контекст переживёт запрос дольше, чем нужно.
Два примера, которые встречаются чаще остальных:
// плохо: подписка на каждый запрос и никогда не снимается
app.get('/tasks/:id/watch', (req, res) => {
taskEvents.on('updated', (task) => res.write(`${JSON.stringify(task)}\n`));
});
// хорошо: слушатель снимается при закрытии соединения
app.get('/tasks/:id/watch', (req, res) => {
const onUpdate = (task) => res.write(`${JSON.stringify(task)}\n`);
taskEvents.on('updated', onUpdate);
res.on('close', () => taskEvents.off('updated', onUpdate));
});
import { LRUCache } from 'lru-cache';
// плохо: Map растёт, пока жив процесс
const cache = new Map();
// хорошо: ограничение по числу записей и времени жизни
export const tasksCache = new LRUCache({
max: 10_000, // записей
ttl: 30_000, // мс
});
lru-cache умеет и ограничение по байтам (maxSize + sizeCalculation), что важно, когда значения сильно разного размера. Главное — у кеша есть верхняя граница и правило вытеснения; без них это не кеш, а медленно растущее хранилище.
Сигналы, по которым утечку замечают раньше, чем OOM:
- предупреждение
MaxListenersExceededWarning— кто-то подписывается в цикле; emitter.listenerCount()иprocess.getActiveResourcesInfo()— рост числа слушателей и активных ресурсов;heapUsedпосле GC и RSS на графике — монотонный тренд вместо пилы;- рост времени в GC при неизменном RPS.
Диагностика всегда идёт от метрики: сначала подтверждают, что память действительно не возвращается, потом снимают heap snapshot. Снимок «на всякий случай» без гипотезы даёт тысячу объектов и никакого ответа.
Heap snapshot: снять и сравнить
Heap snapshot — это граф всех объектов кучи с их размерами и ссылками. Сам по себе он бесполезен: важно сравнение двух снимков, сделанных в одинаковых условиях через равное число итераций.
Порядок работы:
- Прогреть приложение и дать ему выйти на стабильный режим.
- Снять базовый снимок после принудительной сборки мусора.
- Выполнить сценарий N раз — те же запросы, что в проде, или повторяющееся действие, которое подозревают.
- Снять второй снимок, повторить сценарий ещё N раз и снять третий.
- Сравнить снимки по приросту объектов между итерациями и по
Retained Size, затем раскрыть путь удержания до корня.
Если объекты растут линейно от итерации к итерации, это утечка. Если после второй итерации число стабилизировалось — это прогревочный кеш или ленивая инициализация, а не утечка.
Локально снимок делают из DevTools (Memory → Heap snapshot) или из кода:
// запускать с --expose-gc, иначе global.gc недоступен
import { writeHeapSnapshot } from 'node:v8';
global.gc(); // убираем мусор, чтобы в снимок попали только живые объекты
const file = writeHeapSnapshot('/tmp/taskflow-1.heapsnapshot');
console.log(file);
В проде удобнее сигнал: процесс пишет снимок по требованию и не требует перезапуска.
# Linux и macOS: снимок по SIGUSR2
node --heapsnapshot-signal=SIGUSR2 src/server.js
kill -USR2 <pid>
# автоматический снимок при приближении к лимиту кучи
node --heapsnapshot-near-heap-limit=2 --diagnostic-dir=/var/tmp/taskflow src/server.js
Три ограничения, о которых забывают:
- Снимок останавливает процесс на время обхода кучи — от сотен миллисекунд до секунд, а файл может занимать сотни мегабайт.
- Память на время снимка удваивается: граф строится в том же процессе. На инстансе у лимита это может стать последним толчком к OOM.
- Снимок показывает объекты V8, но не внешнюю память. Буферы в нём видны как объекты-обёртки, а их содержимое живёт в
external; для буферной утечки смотрятprocess.memoryUsage()иarrayBuffers, а не только граф.
Поэтому в проде снимок снимают на одном инстансе, выведенном из балансировки, либо полагаются на --heapsnapshot-near-heap-limit и разбирают дамп уже после аварии.
Память в проде: метрики и лимиты
Наблюдать за памятью нужно трендом, а не абсолютным значением. «Занято 400 МБ» ничего не говорит: для одного сервиса это норма, для другого — начало конца. Полезны три графика: RSS, heapUsed после GC и external, все — с разбивкой по инстансам.
// src/lib/memory.js
import { Gauge } from 'prom-client';
export const processMemory = new Gauge({
name: 'nodejs_process_memory_bytes',
help: 'Process memory by kind',
labelNames: ['kind'],
collect() {
const memory = process.memoryUsage();
this.set({ kind: 'rss' }, memory.rss);
this.set({ kind: 'heap_used' }, memory.heapUsed);
this.set({ kind: 'heap_total' }, memory.heapTotal);
this.set({ kind: 'external' }, memory.external);
this.set({ kind: 'array_buffers' }, memory.arrayBuffers);
},
});
Дальше настраивают лимиты. В контейнере память ограничена cgroup, и превышение заканчивается не ошибкой в приложении, а SIGKILL — процесс не успевает ни залогировать, ни закрыть соединения. Код выхода 137 в логах оркестратора — это именно оно.
Два разных OOM важно различать:
| Что произошло | Признак | Причина |
|---|---|---|
| V8 исчерпал старую кучу | JavaScript heap out of memory, аварийное завершение | утечка объектов или слишком маленький лимит |
| Контейнер убил процесс | код 137, нет сообщения от Node | внешняя память, буферы, нативные библиотеки |
--max-old-space-size задаёт предел старого поколения и должен оставлять место всему остальному: буферам, коду, стекам, нативным структурам. Практическое правило — 70–80% от лимита контейнера, а не «столько же»: иначе убийца cgroup сработает раньше, чем V8 успеет пожаловаться.
node --max-old-space-size=768 src/server.js # контейнер на 1 ГБ
Если процесс регулярно перезапускается по памяти, рестарт не решение: он маскирует утечку и добавляет холодный старт, потерю соединений и рост p99 после каждого перезапуска. Правильный порядок — подтвердить тренд, снять снимок, найти держателя, исправить, а лимит выставить с запасом.
Нагрузочное тестирование
Нагрузочный тест отвечает на вопрос, который метрики прода не отвечают: где предел и что ломается первым. Но цифры зависят от модели нагрузки, и здесь есть главная ловушка.
Закрытая модель держит фиксированное число соединений или виртуальных пользователей: следующий запрос уходит только после ответа. Так работает autocannon с -c. Открытая модель задаёт интенсивность поступления: фиксированное число запросов в секунду, независимо от того, успевает ли сервер. Так работает k6 с constant-arrival-rate.
Разница проявляется при деградации. В закрытой модели сервер замедлился — инструмент тоже стал отправлять реже, очередь не выросла, задержка в отчёте осталась скромной. Это coordinated omission: самое интересное ожидание просто не было измерено. Открытая модель продолжает давить с той же интенсивностью, и в отчёте видно реальное время ответа вместе с очередью.
# быстрый смоук: 50 соединений, 30 секунд, 10 запросов в пайплайне
npx autocannon -c 50 -d 30 -p 10 http://localhost:3000/api/tasks
// load/tasks.js — открытая модель и пороги как часть теста
import http from 'k6/http';
import { check } from 'k6';
export const options = {
scenarios: {
steady: {
executor: 'constant-arrival-rate',
rate: 200, // запросов в секунду
timeUnit: '1s',
duration: '3m',
preAllocatedVUs: 50,
maxVUs: 500,
},
},
thresholds: {
http_req_duration: ['p(95)<300', 'p(99)<800'],
http_req_failed: ['rate<0.01'],
},
};
export default function () {
const response = http.get(`${__ENV.BASE_URL}/api/tasks`);
check(response, { 'status is 200': (r) => r.status === 200 });
}
k6 run -e BASE_URL=http://localhost:3000 load/tasks.js
Что мерить, кроме RPS:
- Перцентили задержки на клиенте и на сервере отдельно: разница показывает сеть и прокси.
- Долю ошибок и таймаутов, а не только
5xx: оборванные соединения и429тоже отказ. - Насыщение сервера: CPU, event loop lag, время в GC, занятость пула базы, глубина очередей.
- Память на длинном прогоне. Утечка видна только на soak-тесте: пять минут ничего не покажут, час — покажет.
- Поведение после снятия нагрузки: вернулся ли
p99к базовому уровню и освободилась ли память.
Виды прогонов, которые стоит держать в наборе: smoke (проверка, что тест вообще работает), load (целевой RPS с запасом), stress (поиск точки перегиба), soak (утечки и деградация на часах), spike (резкий всплеск и восстановление).
Методические требования простые, но их игнорируют чаще всего: генератор нагрузки не должен жить на том же хосте, данные должны быть прод-подобными по объёму, тест начинают после прогрева, длительность — минуты, а не секунды, и каждый прогон сравнивают с сохранённым базовым результатом.
Что оптимизировать в первую очередь
Порядок по убыванию отдачи почти всегда один и тот же.
1. Убрать работу. Самая быстрая операция — та, которой нет. Кеш на чтение, пагинация вместо всего списка, select только нужных колонок, батчинг вместо N+1, отказ от пересчёта того, что не изменилось.
2. Убрать блокировки. Синхронные вызовы заменить асинхронными, тяжёлые вычисления вынести в пул воркеров, большие JSON — в стриминг, катастрофические регэкспы — переписать или ограничить вход.
3. Уменьшить аллокации и копии. Стримы вместо буферизации, transferList вместо копирования буферов, отказ от глубокого клонирования на каждом запросе, один пул соединений на процесс вместо пула на вызов.
4. Масштабировать. Несколько реплик или cluster, размер пула базы под число соединений, UV_THREADPOOL_SIZE под нагрузку на fs/crypto/zlib.
5. Микрооптимизировать. Только после профиля и только с бенчмарком: здесь выигрыш редко превышает проценты.
| Антипаттерн | Что происходит | Чем заменить |
|---|---|---|
readFileSync в обработчике | цикл стоит на диске | fs.promises или стрим |
pbkdf2Sync / bcryptSync | блокировка на десятки миллисекунд | асинхронная версия или воркер |
JSON.parse тела на 50 МБ | пик памяти и блокировка | лимит размера, стрим-парсер |
| Регэксп с вложенными квантификаторами | ReDoS на одной строке | безопасное выражение, лимит входа |
Promise.all на 10 000 элементов | пик памяти и забитый пул | батчи, ограничитель параллелизма |
Новый Pool или Agent на запрос | соединения не переиспользуются | один пул на процесс |
console.log в горячем пути | синхронная запись, рост лага | pino с асинхронным назначением |
Map без ограничения | утечка памяти | LRU с TTL |
res.json() огромного массива | сериализация целиком в памяти | стрим или пагинация |
| Проверка без индекса | рост latency при росте таблицы | индекс и план запроса |
Последняя строка — напоминание, что узкое место часто находится не в Node. Пул, индексы, транзакции и N+1 разобраны в статье «Доступ к базам данных», а стриминг и backpressure — в «Стримы и backpressure».
Практика: TaskFlow
Добавим производительность в TaskFlow из статей «Express и middleware», «Доступ к базам данных» и «Логирование и наблюдаемость».
1. Базовая линия. До любых правок снимаем цифры на одинаковом тесте:
npx autocannon -c 50 -d 30 http://localhost:3000/api/tasks
Записываем RPS, p95, p99, долю ошибок и RSS после прогона. Это точка сравнения, без неё «стало быстрее» недоказуемо.
2. Метрики рантайма. Подключаем monitorEventLoopDelay, eventLoopUtilization и process.memoryUsage() из разделов выше. В дашборд выводим nodejs_eventloop_lag_p99_seconds, nodejs_process_memory_bytes и nodejs_gc_duration_seconds.
3. Кеш с границей. Если листинг задач кешируется в Map, заменяем на LRUCache с max и ttl, а на запись инвалидируем ключ проекта. Это одновременно убирает утечку и делает поведение предсказуемым.
4. Тяжёлый экспорт — в воркеры. Экспорт задач в CSV на 100 000 строк не должен сериализоваться в обработчике. Пул Piscina на availableParallelism() воркеров, ограниченная очередь и 503 при переполнении — по схеме из статьи «Worker Threads и cluster».
5. Слушатели и стримы. Для SSE-подписки на обновления задач слушатель снимается по close; для скачивания вложения файл отдаётся createReadStream и pipeline, а не readFile («WebSocket и SSE на сервере», «Стримы и backpressure»).
6. Диагностика в проде. В контейнере выставляем лимит кучи и включаем дампы:
node --max-old-space-size=768 \
--heapsnapshot-near-heap-limit=2 \
--diagnostic-dir=/var/tmp/taskflow \
src/server.js
7. Повторное измерение. Тот же autocannon, те же данные, те же 30 секунд. Сравниваем с базовой линией:
| Метрика | До | После |
|---|---|---|
RPS при p99 < 300 мс | 180 | 420 |
p99 | 780 мс | 240 мс |
| RSS через час нагрузки | 1.4 ГБ | 380 МБ |
Event loop lag p99 | 260 мс | 40 мс |
Цифры здесь иллюстративные: важен сам формат фиксации результата, а не конкретные значения.
Что закрыто: есть базовая линия и метрики рантайма, кеш ограничен, тяжёлая работа вынесена из event loop, слушатели снимаются, память под наблюдением, дампы доступны без перезапуска.
Что добавляют в проде: soak-тест на несколько часов в CI по расписанию, профилирование под синтетической нагрузкой, алерты на тренд RSS и на лаг, регрессионные пороги в k6, сравнение heap snapshots по релизам.
Частые ошибки
- Оптимизация без измерения. Правки по интуиции не сдвигают узкое место и добавляют сложность.
- Среднее вместо перцентилей. Медленные запросы исчезают в среднем, а именно они ломают SLO.
- Нагрузочный тест на той же машине. Генератор отнимает CPU у сервера, и цифры ничего не значат.
- Закрытая модель нагрузки без поправки на coordinated omission. Замер занижает задержки при деградации сервера.
- Тест на пустой базе и маленьком JSON. Прод-профиль другой: объём данных определяет время запроса.
- Один прогон без прогрева. JIT, кеши и пулы выходят на режим не сразу.
console.logв горячем пути. Синхронная запись добавляет лаг и шум в логи.readFileSyncиexecSyncв обработчике. Прямая блокировка единственного потока.- Огромный
JSON.parseбез лимита тела. Пик памяти и блокировка на десятки миллисекунд. Promise.allна весь список. Тысячи параллельных задач, пик памяти и забитый пул.Mapв роли кеша. Растёт до OOM, потому что записи никто не удаляет.- Слушатель без
off. Каждый запрос добавляет подписку и держитresс буферами. subarrayна большом буфере. Маленький срез держит родительские сотни мегабайт.--max-old-space-sizeкак лечение утечки. Поднимает порог, но не освобождает объекты.- Рестарт по расписанию вместо поиска утечки. Маскирует проблему и добавляет холодные старты.
- Heap snapshot на всех инстансах сразу. Останавливает сервис и удваивает память в самый неподходящий момент.
- Инспектор, открытый в интернет.
--inspect=0.0.0.0даёт удалённое исполнение кода. - Кеш без TTL и инвалидации. Убирает нагрузку с базы, но отдаёт устаревшие данные.
Ключевые тезисы для интервью
- Производительность измеряют перцентилями и насыщением, а не средним: до точки перегиба рост нагрузки почти не меняет latency, после — RPS стоит, а очередь растёт.
- CPU-профиль отвечает, где горит процессор, heap snapshot — кто держит память; выбор инструмента диктует метрика, а не привычка.
- Event loop lag — ранний признак деградации: он растёт до клиентских таймаутов, измеряется
monitorEventLoopDelayи дополняетсяeventLoopUtilization. - CPU-bound код блокирует единственный поток, и пул libuv тут не помогает: вычисления уходят в
worker_threads, а синхронные API заменяются асинхронными. - Память V8 делится на кучу и
external: буферы живут вне кучи, поэтому--max-old-space-sizeих не ограничивает, а OOM контейнера приходит какSIGKILL. - Утечка — это удержанная ссылка: кеш без eviction, слушатели, замыкания, таймеры и срезы буферов; ищут её сравнением снимков по retained size и путям удержания.
- Нагрузочный тест даёт цифры только при открытой модели, прод-подобных данных и метриках с обеих сторон; порядок оптимизации — убрать работу, убрать блокировки, уменьшить аллокации, масштабировать, потом микрооптимизации.
Заключение
Производительность Node-сервиса упирается в один поток и в память, которую этот поток удерживает. Лаг показывает, когда цикл перестал успевать; CPU-профиль — какая функция его занимает; heap snapshot — какой объект не даёт памяти вернуться. Нагрузочный тест связывает всё это с реальностью: он проверяет, что оптимизация видна на перцентилях, а не только в профилировщике. Главная дисциплина здесь не знание флагов, а привычка сначала измерить, потом менять и обязательно сравнивать с базовой линией. Дальше — надёжность: таймауты, ретраи и корректная остановка сервиса, без которых даже быстрый бэкенд остаётся хрупким.
Полезные ссылки
- Node.js: Command-line options —
--cpu-prof,--heapsnapshot-near-heap-limit,--max-old-space-size - Node.js: perf_hooks —
monitorEventLoopDelay,eventLoopUtilization,PerformanceObserver - Node.js: Diagnostics — официальные гайды по памяти и профилированию
- Chrome DevTools: Memory problems — heap snapshots, сравнение и пути удержания
- clinic.js — doctor, flame и bubbleprof для Node
- 0x — флеймграфы на основе
--prof - autocannon — быстрый HTTP-бенчмарк
- k6 documentation — сценарии, исполнители и пороги
- lru-cache — ограничение кеша по записям и байтам
- V8: Trash talk — как устроена сборка мусора в V8