callman-core 1.36.0 → 1.37.0

package/dist/loadtest/node/worker-core.js

@@ -0,0 +1,744 @@
+// One load worker: owns a share of the virtual users (closed model) or of the
+// iteration arrivals (open model), drives them over its own HTTP pool, and
+// reports compact per-interval deltas to the orchestrator.
+//
+// The same class runs inside a `worker_threads` Worker (see worker.ts) and
+// inline on the calling thread (small runs, tests, hosts that can't resolve a
+// worker file) — the orchestrator can't tell the difference.
+import { monitorEventLoopDelay, performance } from "node:perf_hooks";
+import { DEFAULT_USER_AGENT } from "../../request/executeRequest.js";
+import { compileTemplate } from "../../templating/compile.js";
+import { createTemplateRuntimeContext } from "../../templating/template-engine.js";
+import { LatencyHistogram } from "../histogram.js";
+import { buildLoadPlan, cumulativeIterationsAt, intendedStartMs, targetAt } from "../plan.js";
+import { createResponseEvaluator } from "../flow-eval.js";
+import { compileStep, newTemplateContext } from "./step-compiler.js";
+import { LoadTransport } from "./transport.js";
+const FLUSH_INTERVAL_MS = 500;
+const SLOWEST_KEEP = 20;
+const MONITOR_CAP_PER_INTERVAL = 40;
+const MONITOR_BODY_LIMIT = 64 * 1024;
+const CAPTURE_BODY_LIMIT = 1024 * 1024;
+const DEFAULT_OK = { min: 200, max: 399 };
+/**
+ * Arrivals are dispatched from a 2 ms timer, so an iteration due a moment ago
+ * legitimately starts up to a couple of milliseconds late. That is generator
+ * granularity, not a stalled server, so it is not charged to the latency; a
+ * real stall (the thing coordinated-omission correction exists for) is far
+ * larger than this.
+ */
+const SCHEDULER_TOLERANCE_MS = 6;
+const LEGACY_FAKER_ALIASES = {
+    $randomUuid: "$randomUUID",
+    $randomString: "random.string(12)",
+    $randomInt: "random.int(0,1000000)",
+};
+class Interval {
+    requests = 0;
+    failed = 0;
+    networkErrors = 0;
+    iterations = 0;
+    dropped = 0;
+    bytesSent = 0;
+    bytesReceived = 0;
+    checksPassed = 0;
+    checksFailed = 0;
+    newConnections = 0;
+    blockedRequests = 0;
+    statusClass = { c2: 0, c3: 0, c4: 0, c5: 0, c0: 0 };
+    statusCodes = {};
+    duration = new LatencyHistogram();
+    corrected = new LatencyHistogram();
+    waiting = new LatencyHistogram();
+    receiving = new LatencyHistogram();
+    sending = new LatencyHistogram();
+    blocked = new LatencyHistogram();
+    connecting = new LatencyHistogram();
+    tls = new LatencyHistogram();
+    iteration = new LatencyHistogram();
+    steps = new Map();
+    errors = new Map();
+    step(id) {
+        let entry = this.steps.get(id);
+        if (!entry) {
+            entry = { requests: 0, failed: 0, checksPassed: 0, checksFailed: 0, checks: {}, statusCodes: {}, duration: new LatencyHistogram() };
+            this.steps.set(id, entry);
+        }
+        return entry;
+    }
+}
+const sleep = (ms, signal) => new Promise((resolve) => {
+    if (ms <= 0 || signal.aborted) {
+        resolve();
+        return;
+    }
+    const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve();
+    }, ms);
+    const onAbort = () => {
+        clearTimeout(timer);
+        resolve();
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+});
+const randomBetween = (min, max) => max <= min ? Math.max(0, min) : Math.floor(min + Math.random() * (max - min + 1));
+const yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
+export const createSharedCounterStore = (shared, slots) => {
+    const cells = new BigInt64Array(shared);
+    const local = new Map();
+    return {
+        getNextValue: (key, startAt = 1) => {
+            const slot = slots[key];
+            if (slot)
+                return Number(Atomics.add(cells, slot.slot, 1n)) + 1 + (slot.start - 1);
+            const next = (local.get(key) ?? startAt - 1) + 1;
+            local.set(key, next);
+            return next;
+        },
+        snapshot: () => [],
+        hydrate: () => undefined,
+        reset: () => undefined,
+    };
+};
+export class LoadWorker {
+    init;
+    emit;
+    plan;
+    transport;
+    controller = new AbortController();
+    counters;
+    counterStore;
+    iterationSteps;
+    baseVars;
+    oauth;
+    lag = monitorEventLoopDelay({ resolution: 10 });
+    datasetRows;
+    fakerBindings = [];
+    okRange;
+    monitorEnabled;
+    monitorEvery;
+    cookieJar;
+    timeoutMs;
+    maxRedirects;
+    graceMs;
+    correct;
+    maxShare;
+    startPerf = 0;
+    interval = new Interval();
+    flushTimer = null;
+    scheduleTimer = null;
+    ending = false;
+    stopRequested = false;
+    hardDeadline = Number.POSITIVE_INFINITY;
+    finished = false;
+    resolveFinished = null;
+    vus = [];
+    freeVus = [];
+    nextVuSeq = 0;
+    inflight = 0;
+    issued = 0;
+    slowest = [];
+    monitorBuffer = [];
+    oauthCache = new Map();
+    constructor(init, emit) {
+        this.init = init;
+        this.emit = emit;
+        const config = init.config;
+        this.plan = buildLoadPlan(config.executor);
+        this.transport = new LoadTransport({
+            keepAlive: config.keepAlive !== false,
+            verifySsl: config.verifySsl !== false,
+            clientCertificate: config.clientCertificate,
+        });
+        this.counters = new BigInt64Array(init.shared);
+        this.counterStore = createSharedCounterStore(init.shared, init.counterSlots);
+        const userAgent = config.userAgent ?? DEFAULT_USER_AGENT;
+        this.iterationSteps = config.steps.filter((step) => step.phase !== "setup").map((step) => compileStep(step, { userAgent }));
+        this.baseVars = { ...(config.environment ?? {}), ...init.setupVars };
+        this.okRange = config.okStatus ?? DEFAULT_OK;
+        this.monitorEnabled = config.monitor?.enabled === true;
+        this.monitorEvery = Math.max(1, config.monitor?.sampleEvery ?? 50);
+        this.cookieJar = config.cookieJar !== false;
+        this.timeoutMs = config.timeoutMs ?? 30_000;
+        this.maxRedirects = config.maxRedirects ?? 5;
+        this.graceMs = config.gracefulStopMs ?? 5_000;
+        this.correct = config.correctCoordinatedOmission !== false && this.plan.kind === "rate";
+        this.maxShare = Math.max(1, Math.ceil(this.plan.maxVus / init.count));
+        this.datasetRows = init.dataset;
+        if (init.dataset?.kind === "fakers") {
+            for (const binding of init.dataset.bindings) {
+                let expression = binding.generator.trim().replace(/^\{\{\s*|\s*\}\}$/g, "");
+                expression = LEGACY_FAKER_ALIASES[expression] ?? expression;
+                this.fakerBindings.push({ name: binding.name, compiled: compileTemplate(`{{${expression}}}`) });
+            }
+        }
+        this.oauth = {
+            cache: this.oauthCache,
+            post: async (request) => {
+                const result = await this.transport.send({
+                    url: request.url,
+                    method: request.method,
+                    headers: request.headers,
+                    body: request.body,
+                    timeoutMs: this.timeoutMs,
+                    captureBody: true,
+                    captureOnError: false,
+                    maxBodyBytes: CAPTURE_BODY_LIMIT,
+                    maxRedirects: 0,
+                    signal: this.controller.signal,
+                });
+                let data = result.bodyText;
+                try {
+                    data = result.bodyText ? JSON.parse(result.bodyText) : null;
+                }
+                catch {
+                    // keep text
+                }
+                return { status: result.status, data };
+            },
+        };
+    }
+    /** Start generating load; resolves when this worker has drained and reported `done`. */
+    run() {
+        this.lag.enable();
+        this.startPerf = performance.now() + (this.init.startAtEpochMs - Date.now());
+        const finished = new Promise((resolve) => {
+            this.resolveFinished = resolve;
+        });
+        this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
+        if (this.plan.kind === "vus")
+            this.scheduleVus();
+        else
+            this.scheduleArrivals();
+        return finished;
+    }
+    stop(graceMs) {
+        this.stopRequested = true;
+        this.ending = true;
+        this.hardDeadline = performance.now() + Math.max(0, graceMs);
+        if (!this.controller.signal.aborted)
+            setTimeout(() => this.controller.abort(), Math.max(0, graceMs)).unref?.();
+    }
+    elapsed() {
+        return performance.now() - this.startPerf;
+    }
+    // ── Closed model ───────────────────────────────────────────────────────────
+    shareOf(total) {
+        const whole = Math.round(total);
+        const base = Math.floor(whole / this.init.count);
+        return base + (this.init.index < whole % this.init.count ? 1 : 0);
+    }
+    scheduleVus() {
+        const tick = () => {
+            if (this.finished)
+                return;
+            const elapsed = this.elapsed();
+            if (!this.ending && elapsed >= this.plan.totalDurationMs)
+                this.ending = true;
+            if (elapsed >= 0 && !this.ending) {
+                const wanted = this.shareOf(targetAt(this.plan, elapsed));
+                const active = this.vus.filter((vu) => !vu.exit).length;
+                for (let n = active; n < wanted; n += 1)
+                    this.spawnVu();
+                if (active > wanted) {
+                    let toRetire = active - wanted;
+                    for (let i = this.vus.length - 1; i >= 0 && toRetire > 0; i -= 1) {
+                        if (!this.vus[i].exit) {
+                            this.vus[i].exit = true;
+                            toRetire -= 1;
+                        }
+                    }
+                }
+            }
+            this.checkDrained();
+            if (!this.finished)
+                this.scheduleTimer = setTimeout(tick, 50);
+        };
+        this.scheduleTimer = setTimeout(tick, Math.max(0, -this.elapsed()));
+    }
+    spawnVu() {
+        const seq = this.nextVuSeq;
+        this.nextVuSeq += 1;
+        const vu = {
+            id: seq * this.init.count + this.init.index + 1,
+            exit: false,
+            running: true,
+            iterations: 0,
+            vars: {},
+            cookies: new Map(),
+        };
+        this.vus.push(vu);
+        void this.vuLoop(vu);
+    }
+    async vuLoop(vu) {
+        const think = this.init.config.thinkTimeMs;
+        try {
+            while (!vu.exit && !this.ending) {
+                const index = Number(Atomics.add(this.counters, 0, 1n));
+                await this.runIteration(vu, index, null);
+                if (think && think.max > 0 && !this.ending && !vu.exit) {
+                    await sleep(randomBetween(think.min, think.max), this.controller.signal);
+                }
+                await yieldToEventLoop();
+            }
+        }
+        finally {
+            vu.running = false;
+            const at = this.vus.indexOf(vu);
+            if (at >= 0)
+                this.vus.splice(at, 1);
+        }
+    }
+    // ── Open model ─────────────────────────────────────────────────────────────
+    scheduleArrivals() {
+        const tick = () => {
+            if (this.finished)
+                return;
+            const elapsed = this.elapsed();
+            if (!this.ending && elapsed >= this.plan.totalDurationMs) {
+                // Issue whatever was due before the end, then stop arriving.
+                this.issueDue(this.plan.totalDurationMs);
+                this.ending = true;
+            }
+            if (elapsed >= 0 && !this.ending)
+                this.issueDue(elapsed);
+            this.checkDrained();
+            if (!this.finished)
+                this.scheduleTimer = setTimeout(tick, 2);
+        };
+        this.scheduleTimer = setTimeout(tick, Math.max(0, -this.elapsed()));
+    }
+    issueDue(elapsed) {
+        const { index, count } = this.init;
+        const cumulative = cumulativeIterationsAt(this.plan, elapsed);
+        const due = cumulative >= index + 1 ? Math.floor((cumulative - (index + 1)) / count) + 1 : 0;
+        while (this.issued < due) {
+            this.issued += 1;
+            const globalNumber = (this.issued - 1) * count + index + 1;
+            if (this.inflight >= this.maxShare) {
+                this.interval.dropped += 1;
+                continue;
+            }
+            const intended = intendedStartMs(this.plan, globalNumber);
+            const vu = this.freeVus.pop() ?? this.newPooledVu();
+            this.inflight += 1;
+            const iterationIndex = Number(Atomics.add(this.counters, 0, 1n));
+            void this.runIteration(vu, iterationIndex, intended).finally(() => {
+                this.inflight -= 1;
+                this.freeVus.push(vu);
+            });
+        }
+    }
+    newPooledVu() {
+        const seq = this.nextVuSeq;
+        this.nextVuSeq += 1;
+        return { id: seq * this.init.count + this.init.index + 1, exit: false, running: true, iterations: 0, vars: {}, cookies: new Map() };
+    }
+    // ── Drain ──────────────────────────────────────────────────────────────────
+    idle() {
+        return this.plan.kind === "vus" ? this.vus.length === 0 : this.inflight === 0;
+    }
+    checkDrained() {
+        if (this.finished)
+            return;
+        if (this.ending && performance.now() > this.hardDeadline)
+            this.controller.abort();
+        if (this.ending && this.hardDeadline === Number.POSITIVE_INFINITY) {
+            // Natural end: in-flight work gets `graceMs` to finish.
+            this.hardDeadline = performance.now() + this.graceMs;
+            setTimeout(() => this.controller.abort(), this.graceMs).unref?.();
+        }
+        if (this.ending && this.idle())
+            this.finish();
+    }
+    finish() {
+        if (this.finished)
+            return;
+        this.finished = true;
+        if (this.scheduleTimer)
+            clearTimeout(this.scheduleTimer);
+        if (this.flushTimer)
+            clearInterval(this.flushTimer);
+        this.flush();
+        this.flushMonitor();
+        this.lag.disable();
+        this.transport.destroy();
+        this.emit({ t: "done", worker: this.init.index, slowest: this.slowest });
+        this.resolveFinished?.();
+    }
+    // ── Iteration ──────────────────────────────────────────────────────────────
+    nextRow(iterationIndex) {
+        const dataset = this.datasetRows;
+        if (!dataset)
+            return {};
+        if (dataset.kind === "rows") {
+            if (dataset.rows.length === 0)
+                return {};
+            return dataset.mode === "random"
+                ? dataset.rows[Math.floor(Math.random() * dataset.rows.length)]
+                : dataset.rows[iterationIndex % dataset.rows.length];
+        }
+        const row = {};
+        const context = createTemplateRuntimeContext({}, { counterStore: this.counterStore });
+        for (const binding of this.fakerBindings)
+            row[binding.name] = binding.compiled(context);
+        return row;
+    }
+    async runIteration(vu, iterationIndex, intendedMs) {
+        const startedPerf = performance.now();
+        const delayMs = intendedMs === null ? 0 : Math.max(0, startedPerf - this.startPerf - intendedMs - SCHEDULER_TOLERANCE_MS);
+        const row = this.nextRow(iterationIndex);
+        const variables = Object.assign({}, this.baseVars, vu.vars, row);
+        for (let stepIndex = 0; stepIndex < this.iterationSteps.length; stepIndex += 1) {
+            if (this.controller.signal.aborted)
+                break;
+            const prepared = this.iterationSteps[stepIndex];
+            if (prepared.step.firstIterationOnly && vu.iterations > 0)
+                continue;
+            const outcome = await this.runStep(vu, prepared, variables, row, iterationIndex, delayMs);
+            if (!outcome && prepared.step.stopIterationOnFailure)
+                break;
+            const pause = prepared.step.thinkTimeMs;
+            if (pause && pause.max > 0 && stepIndex < this.iterationSteps.length - 1) {
+                await sleep(randomBetween(pause.min, pause.max), this.controller.signal);
+            }
+        }
+        vu.iterations += 1;
+        if (!this.controller.signal.aborted) {
+            const total = performance.now() - startedPerf;
+            this.interval.iterations += 1;
+            this.interval.iteration.record(total);
+            if (this.correct)
+                this.interval.corrected.record(total + delayMs);
+        }
+    }
+    cookieHeader(vu, url) {
+        if (!this.cookieJar)
+            return null;
+        let host;
+        try {
+            host = new URL(url).host;
+        }
+        catch {
+            return null;
+        }
+        const jar = vu.cookies.get(host);
+        if (!jar || jar.size === 0)
+            return null;
+        return [...jar.entries()].map(([name, value]) => `${name}=${value}`).join("; ");
+    }
+    storeCookies(vu, url, setCookies) {
+        if (!this.cookieJar || setCookies.length === 0)
+            return;
+        let host;
+        try {
+            host = new URL(url).host;
+        }
+        catch {
+            return;
+        }
+        let jar = vu.cookies.get(host);
+        if (!jar) {
+            jar = new Map();
+            vu.cookies.set(host, jar);
+        }
+        for (const cookie of setCookies) {
+            const [pair, ...attributes] = cookie.split(";");
+            const eq = pair.indexOf("=");
+            if (eq <= 0)
+                continue;
+            const name = pair.slice(0, eq).trim();
+            const value = pair.slice(eq + 1).trim();
+            const expired = attributes.some((attribute) => /^\s*max-age\s*=\s*0\s*$/i.test(attribute));
+            if (expired || value === "")
+                jar.delete(name);
+            else
+                jar.set(name, value);
+        }
+    }
+    /** Returns whether the step counted as a success. */
+    async runStep(vu, prepared, variables, row, iterationIndex, delayMs) {
+        const step = prepared.step;
+        const context = newTemplateContext(variables, this.counterStore);
+        let request;
+        try {
+            request = await prepared.build(context, this.oauth);
+        }
+        catch (error) {
+            this.recordFailure(step.id, step.name, "config", error instanceof Error ? error.message : String(error), prepared);
+            return false;
+        }
+        const cookie = this.cookieHeader(vu, request.url);
+        if (cookie && !Object.keys(request.headers).some((key) => key.toLowerCase() === "cookie")) {
+            request.headers.Cookie = cookie;
+        }
+        const sampled = this.monitorEnabled && iterationIndex % this.monitorEvery === 0;
+        const atMs = this.elapsed();
+        const result = await this.transport.send({
+            url: request.url,
+            method: request.method,
+            headers: request.headers,
+            body: request.body,
+            timeoutMs: step.timeoutMs ?? this.timeoutMs,
+            captureBody: prepared.needsBody || sampled,
+            captureOnError: this.monitorEnabled,
+            maxBodyBytes: prepared.needsBody ? CAPTURE_BODY_LIMIT : MONITOR_BODY_LIMIT,
+            maxRedirects: this.maxRedirects,
+            signal: this.controller.signal,
+        });
+        if (result.error?.class === "aborted")
+            return false;
+        this.storeCookies(vu, request.url, result.setCookies);
+        const status = result.status;
+        const networkError = result.error !== undefined;
+        const ok = !networkError && (prepared.expectOk ? prepared.expectOk(status) : status >= this.okRange.min && status <= this.okRange.max);
+        let checksPassed = 0;
+        let checksFailed = 0;
+        const stepInterval = this.interval.step(step.id);
+        if (!networkError && ((step.extract && step.extract.length > 0) || (step.checks && step.checks.length > 0))) {
+            const evaluator = createResponseEvaluator({
+                status,
+                durationMs: result.timings.total,
+                headers: result.headers,
+                bodyText: result.bodyText,
+            });
+            if (step.extract?.length) {
+                evaluator.extract(step.extract, variables);
+                if (step.firstIterationOnly)
+                    for (const extractor of step.extract)
+                        if (variables[extractor.variable] !== undefined)
+                            vu.vars[extractor.variable] = variables[extractor.variable];
+            }
+            if (step.checks?.length) {
+                for (const outcome of evaluator.check(step.checks, prepared.resolve(newTemplateContext(variables, this.counterStore)))) {
+                    const slot = (stepInterval.checks[outcome.name] ??= { p: 0, f: 0 });
+                    if (outcome.passed) {
+                        slot.p += 1;
+                        checksPassed += 1;
+                    }
+                    else {
+                        slot.f += 1;
+                        checksFailed += 1;
+                    }
+                }
+            }
+        }
+        else if (networkError && step.checks?.length) {
+            for (const check of step.checks) {
+                const slot = (stepInterval.checks[check.name] ??= { p: 0, f: 0 });
+                slot.f += 1;
+                checksFailed += 1;
+            }
+        }
+        this.recordRequest(prepared, result, ok, checksPassed, checksFailed, delayMs, iterationIndex, vu.id);
+        if (!ok || sampled) {
+            this.captureMonitor(prepared, request, result, ok, iterationIndex, vu.id, atMs, row);
+        }
+        return ok;
+    }
+    // ── Recording ──────────────────────────────────────────────────────────────
+    recordFailure(stepId, name, errorClass, message, prepared) {
+        void name;
+        void prepared;
+        const interval = this.interval;
+        interval.requests += 1;
+        interval.failed += 1;
+        interval.networkErrors += 1;
+        interval.statusClass.c0 += 1;
+        interval.statusCodes["0"] = (interval.statusCodes["0"] ?? 0) + 1;
+        const step = interval.step(stepId);
+        step.requests += 1;
+        step.failed += 1;
+        step.statusCodes["0"] = (step.statusCodes["0"] ?? 0) + 1;
+        this.noteError(errorClass, message);
+    }
+    noteError(errorClass, message) {
+        const current = this.interval.errors.get(errorClass);
+        if (current)
+            current.count += 1;
+        else
+            this.interval.errors.set(errorClass, { count: 1, example: message.slice(0, 300) });
+    }
+    recordRequest(prepared, result, ok, checksPassed, checksFailed, delayMs, iterationIndex, vuId) {
+        const interval = this.interval;
+        const status = result.status;
+        const timings = result.timings;
+        interval.requests += 1;
+        interval.bytesSent += result.bytesSent;
+        interval.bytesReceived += result.bytesReceived;
+        interval.checksPassed += checksPassed;
+        interval.checksFailed += checksFailed;
+        if (result.newConnection)
+            interval.newConnections += 1;
+        if (timings.blocked > 5)
+            interval.blockedRequests += 1;
+        interval.duration.record(timings.total);
+        interval.waiting.record(timings.waiting);
+        interval.receiving.record(timings.receiving);
+        interval.sending.record(timings.sending);
+        interval.blocked.record(timings.blocked);
+        interval.connecting.record(timings.dns + timings.connecting);
+        interval.tls.record(timings.tls);
+        if (this.correct)
+            interval.corrected.record(timings.total + delayMs);
+        const code = String(status);
+        interval.statusCodes[code] = (interval.statusCodes[code] ?? 0) + 1;
+        if (status === 0)
+            interval.statusClass.c0 += 1;
+        else if (status < 300)
+            interval.statusClass.c2 += 1;
+        else if (status < 400)
+            interval.statusClass.c3 += 1;
+        else if (status < 500)
+            interval.statusClass.c4 += 1;
+        else
+            interval.statusClass.c5 += 1;
+        const stepInterval = interval.step(prepared.step.id);
+        stepInterval.requests += 1;
+        stepInterval.checksPassed += checksPassed;
+        stepInterval.checksFailed += checksFailed;
+        stepInterval.duration.record(timings.total);
+        stepInterval.statusCodes[code] = (stepInterval.statusCodes[code] ?? 0) + 1;
+        if (!ok) {
+            interval.failed += 1;
+            stepInterval.failed += 1;
+            if (result.error) {
+                interval.networkErrors += 1;
+                this.noteError(result.error.class, result.error.message);
+            }
+            else {
+                this.noteError(status >= 500 ? "http_5xx" : "http_4xx", `HTTP ${status} from ${prepared.step.name}`);
+            }
+        }
+        this.trackSlowest(prepared, result, status, iterationIndex, vuId);
+    }
+    trackSlowest(prepared, result, status, iterationIndex, vuId) {
+        const duration = result.timings.total;
+        if (this.slowest.length >= SLOWEST_KEEP && duration <= this.slowest[this.slowest.length - 1].durationMs)
+            return;
+        this.slowest.push({
+            iterationIndex,
+            vuId,
+            stepId: prepared.step.id,
+            stepName: prepared.step.name,
+            atMs: Math.round(this.elapsed()),
+            status,
+            durationMs: duration,
+            ...(result.error ? { errorMessage: result.error.message } : {}),
+        });
+        this.slowest.sort((a, b) => b.durationMs - a.durationMs);
+        if (this.slowest.length > SLOWEST_KEEP)
+            this.slowest.length = SLOWEST_KEEP;
+    }
+    captureMonitor(prepared, request, result, ok, iterationIndex, vuId, atMs, row) {
+        void row;
+        if (this.monitorBuffer.length >= MONITOR_CAP_PER_INTERVAL) {
+            const okAt = this.monitorBuffer.findIndex((entry) => entry.ok);
+            if (okAt >= 0)
+                this.monitorBuffer.splice(okAt, 1);
+            else if (ok)
+                return;
+            else
+                this.monitorBuffer.shift();
+        }
+        const body = request.bodyPreview;
+        const responseBody = result.bodyText ?? "";
+        this.monitorBuffer.push({
+            id: `${this.init.config.runId}:${this.init.index}:${iterationIndex}:${prepared.step.id}`,
+            iterationIndex,
+            vuId,
+            stepId: prepared.step.id,
+            stepName: prepared.step.name,
+            atMs: Math.round(atMs),
+            method: request.method,
+            url: request.url,
+            status: result.status,
+            ok,
+            durationMs: result.timings.total,
+            bytesSent: result.bytesSent,
+            bytesReceived: result.bytesReceived,
+            ...(result.error ? { errorMessage: result.error.message, errorClass: result.error.class } : {}),
+            detail: {
+                request: {
+                    headers: Object.entries(request.headers).map(([key, value]) => ({ key, value })),
+                    query: request.query.map(([key, value]) => ({ key, value })),
+                    body: body.length > MONITOR_BODY_LIMIT ? body.slice(0, MONITOR_BODY_LIMIT) : body,
+                    bodyTruncated: body.length > MONITOR_BODY_LIMIT,
+                },
+                response: {
+                    headers: Object.entries(result.headers).map(([key, value]) => ({ key, value })),
+                    body: responseBody.length > MONITOR_BODY_LIMIT ? responseBody.slice(0, MONITOR_BODY_LIMIT) : responseBody,
+                    bodyTruncated: result.bodyTruncated || responseBody.length > MONITOR_BODY_LIMIT,
+                },
+            },
+        });
+    }
+    flushMonitor() {
+        if (this.monitorBuffer.length === 0)
+            return;
+        const records = this.monitorBuffer;
+        this.monitorBuffer = [];
+        this.emit({ t: "monitor", worker: this.init.index, records });
+    }
+    flush() {
+        const interval = this.interval;
+        this.interval = new Interval();
+        const steps = {};
+        for (const [id, entry] of interval.steps) {
+            steps[id] = {
+                requests: entry.requests,
+                failed: entry.failed,
+                checksPassed: entry.checksPassed,
+                checksFailed: entry.checksFailed,
+                checks: entry.checks,
+                statusCodes: entry.statusCodes,
+                duration: entry.duration.toSparse(),
+            };
+        }
+        const errors = {};
+        for (const [key, value] of interval.errors)
+            errors[key] = value;
+        const lagMean = Number.isFinite(this.lag.mean) ? this.lag.mean / 1e6 : 0;
+        const lagMax = Number.isFinite(this.lag.max) ? this.lag.max / 1e6 : 0;
+        this.lag.reset();
+        const delta = {
+            t: "delta",
+            worker: this.init.index,
+            atMs: Math.round(this.elapsed()),
+            activeVus: this.plan.kind === "vus" ? this.vus.length : this.inflight,
+            requests: interval.requests,
+            failed: interval.failed,
+            networkErrors: interval.networkErrors,
+            iterations: interval.iterations,
+            dropped: interval.dropped,
+            bytesSent: interval.bytesSent,
+            bytesReceived: interval.bytesReceived,
+            checksPassed: interval.checksPassed,
+            checksFailed: interval.checksFailed,
+            newConnections: interval.newConnections,
+            blockedRequests: interval.blockedRequests,
+            statusClass: interval.statusClass,
+            statusCodes: interval.statusCodes,
+            histograms: {
+                duration: interval.duration.toSparse(),
+                corrected: interval.corrected.toSparse(),
+                waiting: interval.waiting.toSparse(),
+                receiving: interval.receiving.toSparse(),
+                sending: interval.sending.toSparse(),
+                blocked: interval.blocked.toSparse(),
+                connecting: interval.connecting.toSparse(),
+                tls: interval.tls.toSparse(),
+                iteration: interval.iteration.toSparse(),
+            },
+            steps,
+            errors,
+            loopLagMeanMs: lagMean,
+            loopLagMaxMs: lagMax,
+            rssBytes: process.memoryUsage().rss,
+        };
+        this.emit(delta);
+        this.flushMonitor();
+    }
+}
+//# sourceMappingURL=worker-core.js.map