<%# The Runtime view: what the process is doing, sampled on an interval. Per-request figures live on each profile's Performance tab; this is the shape over time a single request cannot show. %> <% const runtime = data; const now = runtime.current; const history = runtime.history || []; const seconds = (total) => { const d = Math.floor(total / 86400); const h = Math.floor((total % 86400) / 3600); const m = Math.floor((total % 3600) / 60); if (d > 0) return `${d}d ${h}h`; if (h > 0) return `${h}h ${m}m`; if (m > 0) return `${m}m ${total % 60}s`; return `${total}s`; }; // One sparkline helper for every series on the page: bars scaled to the series' own range, so // a flat series reads flat rather than as noise amplified to full height. const spark = (values, colorFor) => { if (!values || values.length < 2) return ''; const min = Math.min(...values); const max = Math.max(...values); const span = max - min || 1; return values .map((v) => { const pct = Math.round(((v - min) / span) * 80) + 20; return `
`; }) .join(''); }; const heapPressure = runtime.heap.percentOfLimit; const heapPressureClass = heapPressure > 85 ? 'text-danger' : heapPressure > 70 ? 'dur-medium' : 'text-foreground'; // Severity is absolute, never a position within the sampled range. Bars are scaled to their // own min/max so a flat series stays readable — which means the tallest bar is always at the // top of the range, and colouring on that alone paints a process sitting at 2% of its heap // limit bright red. Memory therefore reads its share of the real ceiling, and CPU and lag read // thresholds that mean something on their own. const memColor = (share) => share > 85 ? 'bg-danger/60' : share > 70 ? 'bg-amber-400/60' : 'bg-nest/40'; const heapColor = () => memColor(heapPressure); const rssColor = () => memColor(now ? now.memory.percentOfTotal : 0); const cpuColor = (v) => (v > 80 ? 'bg-danger/60' : v > 40 ? 'bg-amber-400/60' : 'bg-nest/40'); const lagColor = (v) => (v > 100 ? 'bg-danger/60' : v > 20 ? 'bg-amber-400/60' : 'bg-nest/40'); const heapSeries = history.map((s) => s.memory.heapUsed); const rssSeries = history.map((s) => s.memory.rss); const cpuSeries = history.map((s) => s.cpu.percent); const lagSeries = history.map((s) => s.eventLoop.lag.p99); %>
<%# Headline tiles: the four numbers worth reading before anything else. %>

Heap used

<%= mb(runtime.heap.usedHeapSize) %>

<%= heapPressure %>% of the <%= mb(runtime.heap.heapSizeLimit) %> limit

Resident

<%= now ? mb(now.memory.rss) : '—' %>

<%= now ? now.memory.percentOfTotal + '% of ' + mb(runtime.process.totalMemory) : 'sampling…' %>

CPU

<%= now ? now.cpu.percent : '—' %><% if (now) { %>%<% } %>

of one core, over <%= runtime.interval / 1000 %>s · <%= runtime.process.cpuCount %> available

Loop lag p99

<%= now ? formatDuration(now.eventLoop.lag.p99) : '—' %><% if (now) { %>ms<% } %>

<%= now ? Math.round(now.eventLoop.utilization * 100) + '% utilization' : 'sampling…' %>

<% if (history.length < 2) { %>

Collecting the first samples

Trends appear after a couple of intervals (<%= runtime.interval / 1000 %>s each).

<% } else { %> <%# Trends. Four series over the same window, so a heap climb can be read against the CPU and loop behaviour that came with it. %>

Trends

last <%= history.length %> samples · <%= isoDate(history[0].at) %> → <%= isoDate(history[history.length - 1].at) %>
<% const series = [ { label: 'Heap used', values: heapSeries, color: heapColor, fmt: mb }, { label: 'Resident set', values: rssSeries, color: rssColor, fmt: mb }, { label: 'CPU (% of a core)', values: cpuSeries, color: cpuColor, fmt: (v) => v + '%' }, { label: 'Loop lag p99', values: lagSeries, color: lagColor, fmt: (v) => formatDuration(v) + 'ms' }, ]; %> <% for (const s of series) { %>
<%= s.label %> min <%= s.fmt(Math.min(...s.values)) %> · max <%= s.fmt(Math.max(...s.values)) %> · now <%= s.fmt(s.values[s.values.length - 1]) %>
<%- spark(s.values, s.color) %>
<% } %>
<% } %> <%# Garbage collection over the last interval, split by kind: a major collection is the one that stops the world long enough to show up as a slow request. %> <% if (now) { %>

Garbage collection — last <%= runtime.interval / 1000 %>s

<% for (const kind of ['minor', 'major', 'incremental']) { %> <% const bucket = now.gc.byKind[kind]; %> <% } %>
Kind Collections Total pause Average
<%= kind %> <%= bucket.count %> <%= formatDuration(bucket.duration) %>ms <%= bucket.count > 0 ? formatDuration(bucket.duration / bucket.count) + 'ms' : '—' %>
<% } %> <%# V8 heap spaces — where the used heap actually sits. %>

V8 heap spaces

<% for (const space of runtime.heap.spaces) { %> <% } %>
Space Size Used Available
<%= space.name %> <%= mb(space.size) %> <%= mb(space.used) %> <%= mb(space.available) %>
<%# The process itself. %>

Process

<%- kvTable({ 'PID': runtime.process.pid, 'Uptime': seconds(runtime.process.uptime), 'Node': runtime.process.nodeVersion, 'Platform': runtime.process.platform + ' / ' + runtime.process.arch, 'CPUs': runtime.process.cpuCount, 'Total memory': mb(runtime.process.totalMemory), 'Load average': runtime.process.loadAverage.join(' · '), 'External memory': mb(runtime.heap.externalMemory), 'Sampling interval': runtime.interval / 1000 + 's', }) %>

Process-wide figures for the whole Node process, sampled every <%= runtime.interval / 1000 %>s — not attributable to any one request. Per-request CPU and memory live on each profile's Performance tab. Turn this view off with runtime: false.