Scenarios: Performance, Scale & Memory

rps = 2000, W_request = 50 ms  → in-flight requests = 100
W_db_hold = 5 ms               → busy connections   = 2000 × 0.005 = 10
pods = 5, pool = 4/pod         → 20 connections (2× headroom) ✓

P(page slow) = 1 - (1 - 0.01)^N
N = 1   → 1%
N = 40  → 33%
N = 100 → 63%

# closed model: 100 connections, mỗi connection chờ response rồi mới gửi tiếp
npx autocannon -c 100 -d 60 https://staging.example.com/products/42
# k6 open model: giữ 10k req/s bất kể server chậm
# scenarios: { load: { executor: 'constant-arrival-rate', rate: 10000, timeUnit: '1s',
#   duration: '5m', preAllocatedVUs: 2000, maxVUs: 5000 } }

import { Pool } from 'pg';
// 20 pods × max 10 = 200 connections > max_connections = 100
export const pool = new Pool({
  max: 10,
  // default connectionTimeoutMillis = 0 → wait forever for a free client
});

app.post('/orders/:id/confirm', async (req, res) => {
  const client = await pool.connect();
  await client.query('BEGIN');
  const { rows } = await client.query('SELECT * FROM orders WHERE id = $1 FOR UPDATE', [req.params.id]);
  if (rows.length === 0) return res.status(404).end();          // (a)

  const payment = await paymentApi.capture(rows[0].payment_id);  // (b) 300 ms – 30 s
  await client.query('UPDATE orders SET status = $1 WHERE id = $2', ['confirmed', req.params.id]);
  await client.query('COMMIT');
  client.release();
  res.json({ ok: true, payment });
});

app.get('/orders', async (req, res) => {
  const orders = await db.query('SELECT * FROM orders WHERE customer_id = $1 ORDER BY created_at DESC LIMIT 50', [req.user.id]);
  for (const o of orders.rows) {
    o.items = (await db.query('SELECT * FROM order_items WHERE order_id = $1', [o.id])).rows;
    o.shipping = (await db.query('SELECT * FROM shipments WHERE order_id = $1', [o.id])).rows[0];
  }
  res.json(orders.rows);
});

SELECT pid, state, wait_event_type, wait_event, now() - xact_start AS tx_age, left(query, 80)
FROM pg_stat_activity
WHERE state <> 'idle'
ORDER BY tx_age DESC NULLS LAST;

POST /orders HTTP/1.1
Idempotency-Key: 7f3c...

HTTP/1.1 202 Accepted
Location: /orders/jobs/8812
Retry-After: 2

import { monitorEventLoopDelay } from 'node:perf_hooks';
const h = monitorEventLoopDelay({ resolution: 20 }); h.enable();
let inFlight = 0;
app.use((req, res, next) => {
  const lagMs = h.percentile(99) / 1e6;
  if ((lagMs > 200 || inFlight > 500) && !req.path.startsWith('/checkout')) {
    res.set('Retry-After', String(1 + Math.floor(Math.random() * 3)));
    return res.status(503).json({ error: 'overloaded' });
  }
  inFlight++; res.on('close', () => inFlight--); next();
});
setInterval(() => h.reset(), 5000).unref();

inflow  = 100k/min, capacity = 20k/min, duration = 60 min
backlog = (100k - 20k) × 60 = 4.8M
drain   = 4.8M / 20k = 240 min after peak (if inflow drops to 0)

const [user, cart, recs] = await Promise.allSettled([
  getUser(id),
  getCart(id),
  getRecs(id, { signal: AbortSignal.timeout(80) }),
]);

const products = await repo.findAllToEnrich(); // 20,000 rows
await Promise.all(
  products.map(async (p) => {
    const data = await supplier.get(`/items/${p.sku}`);
    await repo.update(p.id, data);
  }),
);

const ac = new AbortController();
try {
  const [a, b] = await Promise.all([
    fetch(urlA, { signal: ac.signal }),
    fetch(urlB, { signal: ac.signal }),
  ]);
} catch (e) {
  ac.abort(); // stop the calls that are still running
  throw e;
}

gateway (3 retries) → api (3 retries) → service (3 retries) → db
1 user request can become up to 4 × 4 × 4 = 64 DB calls

HTTP/1.1 200 OK
Server-Timing: db;dur=412, cache;desc="miss";dur=2, render;dur=38, ext-pricing;dur=910

app.use((req, res, next) => {
  const start = Date.now();
  next();
  const ms = Date.now() - start;
  metrics.histogram('http_duration_ms', ms, { route: req.path });
});

consumer.on('message', async (e) => {
  await db.query(
    'INSERT INTO events (id, tenant_id, type, payload, created_at) VALUES ($1, $2, $3, $4, $5)',
    [e.id, e.tenantId, e.type, e.payload, e.createdAt],
  );
});

const buffer: Event[] = [];
app.post('/events', (req, res) => {
  buffer.push(req.body);
  res.status(202).end();
});
setInterval(async () => {
  const batch = buffer.splice(0, buffer.length);
  if (batch.length) await repo.insertMany(batch);
}, 1000);

app.use(compression({
  threshold: 1024,
  filter: (req, res) =>
    res.getHeader('Content-Type')?.toString().startsWith('text/event-stream')
      ? false
      : compression.filter(req, res),
}));

app.get('/catalog', async (req, res) => {
  const version = await redis.get('catalog:version');       // cheap
  const etag = `W/"catalog-${version}"`;
  if (req.headers['if-none-match'] === etag) return res.status(304).end();
  const body = await getSerializedCatalog(version);          // cached string
  res.set({ ETag: etag, 'Cache-Control': 'private, max-age=30' }).type('json').send(body);
});

import { performance } from 'node:perf_hooks';
const t0 = performance.now();
const s = JSON.stringify(bigObject);
console.log({ ms: performance.now() - t0, mb: Buffer.byteLength(s) / 1e6 });

app.get('/export', (req, res) => {
  const stream = db.queryStream('SELECT * FROM orders'); // object mode, one row per 'data'
  res.write('[');
  stream.on('data', (row) => {
    res.write(JSON.stringify(row));
  });
  res.end(']');
});

// main thread still pays: structured clone of bigObject (sync)
new Worker('./stringify.js', { workerData: bigObject });
// better: pass a small query and let the worker load + serialize
pool.run({ reportId: 42 }); // piscina, worker returns a transferable Buffer

app.get('/products', {
  schema: { response: { 200: { type: 'array', items: {
    type: 'object',
    properties: { id: { type: 'string' }, name: { type: 'string' }, price: { type: 'number' } },
  } } } },
}, async () => repo.list());

import { gzipSync } from 'node:zlib';
let snapshot: { version: string; gz: Buffer } | undefined;
async function rebuild(version: string) {              // off the request path
  const json = JSON.stringify(await repo.loadCatalog());
  snapshot = { version, gz: gzipSync(json, { level: 6 }) }; // once per change
}
app.get('/catalog', (req, res) => {
  res.set({ 'Content-Type': 'application/json', 'Content-Encoding': 'gzip', ETag: `W/"${snapshot!.version}"` });
  res.end(snapshot!.gz);
});

const priceCache = new Map<string, { value: Price; at: number }>();

export async function getPrice(tenantId: string, sku: string, currency: string, userId: string) {
  const key = `${tenantId}:${sku}:${currency}:${userId}`;
  const hit = priceCache.get(key);
  if (hit && Date.now() - hit.at < 60_000) return hit.value;
  const value = await pricing.compute(tenantId, sku, currency, userId);
  priceCache.set(key, { value, at: Date.now() });
  return value;
}

io.on('connection', (socket) => {
  const session = loadSessionSnapshot(socket.data.userId); // ~200 KB
  priceBus.on('tick', (t) => {
    if (session.watchlist.includes(t.symbol)) socket.emit('tick', t);
  });
  setInterval(() => {
    socket.emit('heartbeat', { at: Date.now(), watched: session.watchlist.length });
  }, 10_000);
});

async function check(url: string) {
  const res = await fetch(url, { signal: AbortSignal.timeout(2000) });
  if (!res.ok) return { url, ok: false, status: res.status }; // body never read
  return { url, ok: true, data: await res.json() };
}

node --max-old-space-size=1536 --heapsnapshot-near-heap-limit=2 dist/main.js
node -e "console.log(require('v8').getHeapStatistics().heap_size_limit / 2**20, 'MB')"

function applyPromotions(products: Product[], promos: Promotion[]) {
  return products.map((p) => {
    const promo = promos.find((x) => x.skus.includes(p.sku)); // nested linear scans
    return { ...p, finalPrice: promo ? p.price * (1 - promo.rate) : p.price };
  });
}

import pino from 'pino';
import pinoHttp from 'pino-http';
const logger = pino({ level: 'info' });
app.use(pinoHttp({ logger })); // logs req with headers (Authorization, Cookie)
app.post('/login', (req, res) => {
  logger.info({ body: req.body }, 'login attempt'); // { email, password }
  // ...
});
app.use((err, req, res, next) => {
  logger.error({ err, config: err.config }, 'upstream failed'); // axios error: config.headers
  res.status(500).end();
});