Debugging and Performance

function log(level, message, fields = {}) {
  console.log(JSON.stringify({ level, message, ...fields }));
}

function slowSum(n) {
  let total = 0;
  for (let i = 0; i < n; i++) total += Math.sqrt(i);
  return total;
}

const t0 = performance.now();
const result = slowSum(5_000_000);
const ms = performance.now() - t0;

log('info', 'Sum calculated', { result: Math.round(result), fast: ms < 2000 });
log('warn', 'Low stock', { product: 'mug', remaining: 2 });

console.table([
  { route: '/products', avgMs: 12 },
  { route: '/orders', avgMs: 87 },
]);

import { monitorEventLoopDelay } from 'node:perf_hooks';

const histogram = monitorEventLoopDelay({ resolution: 10 });
histogram.enable();

function blockFor(ms) {
  const end = Date.now() + ms;
  while (Date.now() < end) {}
}

await new Promise((r) => setTimeout(r, 200));
const before = histogram.max / 1e6;

blockFor(300);
await new Promise((r) => setTimeout(r, 50));
const after = histogram.max / 1e6;

histogram.disable();
console.log(`Max delay while idle under 100 ms: ${before < 100}`);
console.log(`Max delay after blocking over 250 ms: ${after > 250}`);

const leakyCache = new Map();
function leakyLookup(id) {
  if (!leakyCache.has(id)) leakyCache.set(id, { id, data: 'x'.repeat(1000) });
  return leakyCache.get(id);
}

class TtlCache {
  constructor(ttlMs, maxEntries) {
    this.ttlMs = ttlMs;
    this.max = maxEntries;
    this.map = new Map();
  }
  get(key, now = Date.now()) {
    const hit = this.map.get(key);
    if (!hit || hit.expires < now) { this.map.delete(key); return undefined; }
    return hit.value;
  }
  set(key, value, now = Date.now()) {
    if (this.map.size >= this.max) this.map.delete(this.map.keys().next().value);
    this.map.set(key, { value, expires: now + this.ttlMs });
  }
}

for (let i = 0; i < 50_000; i++) leakyLookup(i);
console.log(`Leaky cache entries: ${leakyCache.size}`);

const cache = new TtlCache(60_000, 1000);
let dbCalls = 0;
function getProduct(id, now) {
  const cached = cache.get(id, now);
  if (cached) return cached;
  dbCalls++;
  const product = { id, name: `Product ${id}` };
  cache.set(id, product, now);
  return product;
}

for (let i = 0; i < 50_000; i++) getProduct(i % 200, 0);
console.log(`Bounded cache entries: ${cache.map.size}, database calls: ${dbCalls}`);
getProduct(5, 61_000);
console.log(`After expiry, database calls: ${dbCalls}`);