@researchdatabox/redbox-core 5.1.0-beta.12568 → 5.1.0-beta.13939

package/dist/utilities/RequestChronicle.js

@@ -0,0 +1,770 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestChronicleHelper = exports.RequestChronicleLimits = exports.RequestChronicleClassifications = exports.RequestChronicleOutcomes = exports.defaultRequestChronicleSettings = void 0;
+exports.sanitizeChroniclePath = sanitizeChroniclePath;
+exports.safeChronicleText = safeChronicleText;
+exports.sanitizeChronicleValue = sanitizeChronicleValue;
+exports.summarizeChronicleValue = summarizeChronicleValue;
+exports.toChronicleError = toChronicleError;
+exports.toChronicleLogRecord = toChronicleLogRecord;
+const node_crypto_1 = require("node:crypto");
+const node_perf_hooks_1 = require("node:perf_hooks");
+const api_1 = require("@opentelemetry/api");
+const RedactionUtils_1 = require("./RedactionUtils");
+const RequestChronicleSettings_1 = require("./RequestChronicleSettings");
+var RequestChronicleSettings_2 = require("./RequestChronicleSettings");
+Object.defineProperty(exports, "defaultRequestChronicleSettings", { enumerable: true, get: function () { return RequestChronicleSettings_2.defaultRequestChronicleSettings; } });
+/**
+ * What happened to the request.
+ * - success: the response was sent with a status below 400, and no errors were recorded.
+ * - failure: the response was sent with a 4xx or 5xx status, or errors were recorded.
+ * - aborted: the connection closed before the response was completely sent.
+ */
+exports.RequestChronicleOutcomes = ['success', 'failure', 'aborted'];
+/**
+ * Why the request chronicle was retained (or discarded), which also determines the log level.
+ */
+exports.RequestChronicleClassifications = [
+    'error',
+    'client-error',
+    'aborted',
+    'slow',
+    'warning',
+    'sample',
+    'discard',
+];
+/**
+ * The log level used for each classification.
+ * Client errors are logged at 'warn' instead of 'info' when errors were recorded.
+ */
+const classificationLevels = {
+    error: 'error',
+    'client-error': 'info',
+    aborted: 'info',
+    slow: 'warn',
+    warning: 'warn',
+    sample: 'info',
+    discard: null,
+};
+/**
+ * Limits on the size of the captured data.
+ */
+exports.RequestChronicleLimits = Object.freeze({
+    maxDepth: 4,
+    maxStringLength: 500,
+    maxArrayItems: 20,
+    maxObjectKeys: 30,
+    maxValueJsonLength: 4096,
+    maxInfoKeys: 100,
+    maxErrors: 20,
+    maxErrorDepth: 3,
+    maxErrorDetails: 10,
+    maxErrorMessageLength: 1000,
+    maxErrorJsonLength: 8192,
+    maxStackLength: 4000,
+    maxStackLines: 12,
+    maxKeyLength: 100,
+});
+const reservedKeys = [
+    // Request chronicle fields.
+    'requestId',
+    'traceId',
+    'result',
+    'req',
+    'res',
+    'errors',
+    'errorsOmitted',
+    // Fields set by pino, which must not be overwritten by request details.
+    'level',
+    'time',
+    'pid',
+    'hostname',
+    'name',
+    'msg',
+    'err',
+    'v',
+];
+const sensitiveKeyPattern = /token|authorization|secret|apikey|api_key|password|credential|cookie/i;
+const upstreamRequestIdPattern = /^[A-Za-z0-9._:-]{1,128}$/;
+const tokenPathPatterns = [
+    // Branding preview stylesheets: /:branding/:portal/preview/:token.css
+    [/(\/preview\/)[^/?#\s]+(\.css)/gi, '$1REDACTED$2'],
+    // Token-like query parameters.
+    [/([?&](?:token|access_token|id_token|code|key|apiKey|api_key)=)[^&#\s]*/gi, '$1REDACTED'],
+];
+/**
+ * Remove tokens from request paths and URLs.
+ * @param value The path or URL.
+ */
+function sanitizeChroniclePath(value) {
+    let result = value;
+    for (const [pattern, replacement] of tokenPathPatterns) {
+        result = result.replace(pattern, replacement);
+    }
+    return result;
+}
+/**
+ * Convert a value to a string that is safe to log: secrets and token-bearing paths are redacted,
+ * and the length is bounded. Only the start of a very long string is processed.
+ * @param value The value.
+ * @param maxLength The maximum length, excluding the truncation marker.
+ */
+function safeChronicleText(value, maxLength) {
+    let text;
+    try {
+        text = typeof value === 'string' ? value : String(value);
+    }
+    catch {
+        return '[Unprintable]';
+    }
+    // Process a little more than the limit, so tokens near the limit can still be recognised.
+    const head = text.length > maxLength + 200 ? text.substring(0, maxLength + 200) : text;
+    const redacted = sanitizeChroniclePath(String((0, RedactionUtils_1.redactSecret)(head)))
+        // Credentials can be embedded in diagnostic text, including an Error's stack.
+        .replace(/(\bBearer\s+)[A-Za-z0-9._~+/-]+=*/gi, '$1REDACTED')
+        .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]*)?/g, 'REDACTED')
+        .replace(/\bsk_(?:live|test)_[A-Za-z0-9]+\b/g, 'REDACTED');
+    if (redacted.length <= maxLength && head.length === text.length) {
+        return redacted;
+    }
+    // Redact a token path that is cut off by the truncation.
+    const truncated = redacted.substring(0, maxLength).replace(/(\/preview\/)[^/?#\s]*$/i, '$1REDACTED');
+    return `${truncated}…[truncated ${Math.max(text.length - maxLength, 0)} chars]`;
+}
+function isSensitiveKey(key) {
+    return sensitiveKeyPattern.test(key);
+}
+/**
+ * Sanitise the top-level entries of a details object: bound the number and length of keys,
+ * redact sensitive keys, and sanitise the values.
+ */
+function sanitizeChronicleEntries(info) {
+    const entries = [];
+    let omitted = 0;
+    for (const rawKey in info) {
+        if (!Object.prototype.hasOwnProperty.call(info, rawKey)) {
+            continue;
+        }
+        if (entries.length >= exports.RequestChronicleLimits.maxInfoKeys) {
+            omitted += 1;
+            break;
+        }
+        const key = safeChronicleText(rawKey, exports.RequestChronicleLimits.maxKeyLength);
+        entries.push([key, isSensitiveKey(rawKey) ? 'REDACTED' : sanitizeChronicleValue(info[rawKey])]);
+    }
+    return { entries, omitted };
+}
+/**
+ * Make an operation name safe to use as a key and in log messages.
+ */
+function safeOperationName(operation) {
+    return (safeChronicleText(operation, exports.RequestChronicleLimits.maxKeyLength).replace(/[^A-Za-z0-9._:-]/g, '_') || 'operation');
+}
+/**
+ * Convert a value to a plain, size-bounded representation that is safe to log.
+ * Redacts sensitive keys and token-bearing paths, and limits depth, items, keys, and string length.
+ * @param value The value to sanitise.
+ */
+function sanitizeChronicleValue(value) {
+    const sanitized = sanitizeInner(value, 0, new WeakSet());
+    try {
+        const json = JSON.stringify(sanitized);
+        if (json !== undefined && json.length > exports.RequestChronicleLimits.maxValueJsonLength) {
+            return { truncated: true, jsonLength: json.length };
+        }
+    }
+    catch {
+        return '[Unserialisable]';
+    }
+    return sanitized;
+}
+function sanitizeInner(value, depth, seen) {
+    if (value === null || value === undefined || typeof value === 'boolean' || typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return safeChronicleText(value, exports.RequestChronicleLimits.maxStringLength);
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (typeof value === 'function') {
+        return '[Function]';
+    }
+    if (typeof value !== 'object') {
+        return String(value);
+    }
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? 'Invalid Date' : value.toISOString();
+    }
+    if (value instanceof Error) {
+        return toChronicleErrorInner(value, depth, seen);
+    }
+    if (Buffer.isBuffer(value)) {
+        return `[Buffer ${value.length} bytes]`;
+    }
+    if (seen.has(value)) {
+        return '[Circular]';
+    }
+    if (Array.isArray(value)) {
+        if (depth >= exports.RequestChronicleLimits.maxDepth) {
+            return `[Array(${value.length})]`;
+        }
+        seen.add(value);
+        const items = value
+            .slice(0, exports.RequestChronicleLimits.maxArrayItems)
+            .map(item => sanitizeInner(item, depth + 1, seen));
+        if (value.length > exports.RequestChronicleLimits.maxArrayItems) {
+            items.push(`…${value.length - exports.RequestChronicleLimits.maxArrayItems} more items`);
+        }
+        seen.delete(value);
+        return items;
+    }
+    if (depth >= exports.RequestChronicleLimits.maxDepth) {
+        return '[Object]';
+    }
+    seen.add(value);
+    const result = {};
+    let count = 0;
+    for (const key in value) {
+        if (!Object.prototype.hasOwnProperty.call(value, key)) {
+            continue;
+        }
+        if (count >= exports.RequestChronicleLimits.maxObjectKeys) {
+            result['…'] = 'more keys omitted';
+            break;
+        }
+        count += 1;
+        result[safeChronicleText(key, exports.RequestChronicleLimits.maxKeyLength)] = isSensitiveKey(key)
+            ? 'REDACTED'
+            : sanitizeInner(value[key], depth + 1, seen);
+    }
+    seen.delete(value);
+    return result;
+}
+/**
+ * Describe the shape of a value without including its content.
+ * Use this for results that may be large or contain personal or sensitive data.
+ * @param value The value to describe.
+ */
+function summarizeChronicleValue(value) {
+    if (value === null) {
+        return { type: 'null' };
+    }
+    if (Array.isArray(value)) {
+        return { type: 'array', length: value.length };
+    }
+    if (typeof value === 'string') {
+        return { type: 'string', length: value.length };
+    }
+    if (typeof value === 'object') {
+        return { type: 'object', keyCount: Object.keys(value).length };
+    }
+    return { type: typeof value };
+}
+function isRBValidationErrorLike(item) {
+    return item.name === 'RBValidationError' && Array.isArray(item.displayErrors);
+}
+/** A summary of a display error, which is already a plain, safe object. */
+class DisplayErrorSummary {
+    name;
+    message;
+    constructor(name, message) {
+        this.name = name;
+        this.message = message;
+    }
+}
+/**
+ * Convert a possible error to a consistent, size-bounded plain object representation.
+ * Handles causes, aggregate and suppressed errors, and cycles, without throwing.
+ * Names, messages, codes, and stacks are redacted and bounded, as is the whole result.
+ * @param item This might be an error, or a string, or something else.
+ */
+function toChronicleError(item) {
+    try {
+        const result = toChronicleErrorInner(item, 0, new WeakSet());
+        // Check each complete candidate, including omission markers and JSON escaping.
+        const { details: _details, ...withoutDetails } = result;
+        const { stack: _stack, ...summary } = withoutDetails;
+        const candidates = [
+            result,
+            { ...withoutDetails, details: [{ message: 'Nested errors omitted due to size.' }] },
+            { ...summary, details: [{ message: 'Stack and nested errors omitted due to size.' }] },
+        ];
+        return (candidates.find(candidate => JSON.stringify(candidate).length <= exports.RequestChronicleLimits.maxErrorJsonLength) ?? {
+            message: 'Error details omitted due to size.',
+        });
+    }
+    catch {
+        return { message: 'Unable to record the error.' };
+    }
+}
+function toChronicleErrorInner(item, depth, seen) {
+    const limits = exports.RequestChronicleLimits;
+    if (item instanceof Error || Array.isArray(item)) {
+        if (seen.has(item)) {
+            return { message: '[Circular]' };
+        }
+        seen.add(item);
+    }
+    const result = {};
+    // Only the first few nested errors are processed; the total is counted.
+    const maxDetails = limits.maxErrorDetails;
+    const details = [];
+    let detailsTotal = 0;
+    const addDetails = (items) => {
+        detailsTotal += items.length;
+        const remaining = maxDetails - details.length;
+        if (remaining > 0) {
+            details.push(...items.slice(0, remaining));
+        }
+    };
+    if (item instanceof Error) {
+        if (item.name) {
+            result.name = safeChronicleText(item.name, limits.maxStringLength);
+        }
+        if (item.message) {
+            result.message = safeChronicleText(item.message, limits.maxErrorMessageLength);
+        }
+        const code = item.code;
+        if (typeof code === 'string' || typeof code === 'number') {
+            result.code = safeChronicleText(code, limits.maxStringLength);
+        }
+        if (isRBValidationErrorLike(item)) {
+            const displayErrors = item.displayErrors;
+            detailsTotal += displayErrors.length;
+            details.push(...displayErrors.slice(0, maxDetails).map(displayError => new DisplayErrorSummary(displayError?.title !== undefined && displayError?.title !== null
+                ? safeChronicleText(displayError.title, limits.maxStringLength)
+                : undefined, safeChronicleText(Object.entries({
+                id: displayError?.id,
+                status: displayError?.status,
+                code: displayError?.code,
+                detail: displayError?.detail,
+            })
+                .filter(([_key, value]) => value !== undefined && value !== null)
+                .map(([key, value]) => `${key}: ${safeChronicleText(value, limits.maxStringLength)}`)
+                .join(', '), limits.maxErrorMessageLength))));
+        }
+        else if (depth === 0 && typeof item.stack === 'string') {
+            // Keep the location of unexpected errors.
+            result.stack = safeChronicleText(item.stack, limits.maxStackLength)
+                .split('\n')
+                .slice(0, limits.maxStackLines)
+                .join('\n');
+        }
+        if (item.cause !== undefined && item.cause !== null) {
+            addDetails([item.cause]);
+        }
+        if (typeof SuppressedError !== 'undefined' && item instanceof SuppressedError) {
+            addDetails([item.error, item.suppressed]);
+        }
+        if (item instanceof AggregateError && Array.isArray(item.errors)) {
+            addDetails(item.errors);
+        }
+    }
+    else if (Array.isArray(item)) {
+        addDetails(item);
+    }
+    else if (typeof item === 'string') {
+        result.message = safeChronicleText(item, limits.maxErrorMessageLength);
+    }
+    else if (item !== null && typeof item === 'object' && typeof item.message === 'string') {
+        result.message = safeChronicleText(item.message, limits.maxErrorMessageLength);
+    }
+    else {
+        const sanitized = sanitizeInner(item, depth, seen);
+        result.message = safeChronicleText(typeof sanitized === 'string' ? sanitized : (JSON.stringify(sanitized) ?? String(item)), limits.maxErrorMessageLength);
+    }
+    if (detailsTotal > 0) {
+        if (depth >= limits.maxErrorDepth) {
+            result.details = [{ message: `${detailsTotal} nested errors omitted` }];
+        }
+        else {
+            result.details = details.map(detail => {
+                if (detail instanceof DisplayErrorSummary) {
+                    return { ...(detail.name !== undefined ? { name: detail.name } : {}), message: detail.message };
+                }
+                return toChronicleErrorInner(detail, depth + 1, seen);
+            });
+            if (detailsTotal > details.length) {
+                result.details.push({ message: `${detailsTotal - details.length} more errors omitted` });
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Convert arrays to objects keyed by index, so that the structure survives
+ * log formats that flatten nested objects but not arrays (e.g. pino-logfmt: `errors_0_message`).
+ * @param value The value to convert.
+ */
+function toChronicleLogRecord(value) {
+    if (Array.isArray(value)) {
+        return Object.fromEntries(value.map((item, index) => [String(index), toChronicleLogRecord(item)]));
+    }
+    if (value !== null && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, toChronicleLogRecord(item)]));
+    }
+    return value;
+}
+// Source and compiled modules can coexist in the development loader.
+const helperBrand = Symbol.for('@researchdatabox/redbox-core/RequestChronicleHelper');
+class RequestChronicleHelper {
+    logger;
+    [helperBrand] = true;
+    #data = {};
+    #recordedErrors = new WeakSet();
+    #state = 'pending';
+    #startedAt = 0;
+    #logged = false;
+    #hasWarnings = false;
+    #requestId;
+    #settings;
+    #random;
+    #now;
+    #generateRequestId;
+    #successSampleExclude = null;
+    constructor(logger, options = {}) {
+        this.logger = logger;
+        const configured = typeof sails !== 'undefined' ? sails?.config?.log?.requestChronicle : undefined;
+        this.#settings = (0, RequestChronicleSettings_1.resolveRequestChronicleSettings)(options.settings ?? configured);
+        this.#random = options.random ?? Math.random;
+        this.#now = options.now ?? (() => node_perf_hooks_1.performance.now());
+        this.#generateRequestId = options.generateRequestId ?? node_crypto_1.randomUUID;
+        if (this.#settings.successSampleExcludePattern) {
+            try {
+                this.#successSampleExclude = new RegExp(this.#settings.successSampleExcludePattern, 'i');
+            }
+            catch {
+                // An invalid pattern excludes nothing.
+            }
+        }
+    }
+    /**
+     * Get the request chronicle helper for a request, creating it if needed.
+     * The logger and options are only used when the helper is created.
+     */
+    static fromReq(logger, req, options) {
+        const request = req;
+        if (request.options === undefined || request.options === null) {
+            request.options = {};
+        }
+        if (request.options.requestChronicleHelper === undefined || request.options.requestChronicleHelper === null) {
+            // Make the event accessible to other middleware, plus anywhere that can access the req.
+            request.options.requestChronicleHelper = new RequestChronicleHelper(logger, options);
+        }
+        return request.options.requestChronicleHelper;
+    }
+    /**
+     * Get the request chronicle helper for a request, without creating it.
+     * Requests that did not pass through the HTTP middleware (e.g. socket and virtual requests) have no helper.
+     */
+    static existing(req) {
+        try {
+            const helper = req?.options?.requestChronicleHelper;
+            return helper?.[helperBrand] === true ? helper : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Get the current request chronicle data.
+     * Do not use this for logging - use the `log` method.
+     */
+    get data() {
+        return structuredClone(this.#data);
+    }
+    /** The request id, generated when the chronicle starts. */
+    get requestId() {
+        return this.#requestId;
+    }
+    get settings() {
+        return { ...this.#settings };
+    }
+    get isRunning() {
+        return this.#state === 'running';
+    }
+    get isFinished() {
+        return this.#state === 'finished';
+    }
+    start() {
+        this.#safely('start', () => {
+            if (this.#state !== 'pending') {
+                this.logger.warn('Request Chronicle Helper: Cannot start request chronicle that is running or finished.');
+                return;
+            }
+            this.#state = 'running';
+            this.#startedAt = this.#now();
+            this.#requestId = this.#generateRequestId();
+            this.#data.requestId = this.#requestId;
+            const spanContext = api_1.trace.getActiveSpan()?.spanContext();
+            if (spanContext && (0, api_1.isSpanContextValid)(spanContext)) {
+                this.#data.traceId = spanContext.traceId;
+            }
+            this.#data.result = { timestamp: new Date().toISOString() };
+        });
+    }
+    updateReq(req) {
+        this.#safely('updateReq', () => {
+            if (!this.isRunning || this.#data.req !== undefined) {
+                this.logger.warn('Request Chronicle Helper: Cannot update request chronicle that is not running or has existing req.');
+                return;
+            }
+            const path = req.path ?? req.url?.split('?')[0];
+            const upstreamRequestId = req.headers?.['x-request-id'];
+            this.#data.req = {
+                method: typeof req.method === 'string'
+                    ? safeChronicleText(req.method, exports.RequestChronicleLimits.maxKeyLength)
+                    : undefined,
+                path: typeof path === 'string' ? safeChronicleText(path, exports.RequestChronicleLimits.maxStringLength) : undefined,
+                hostname: typeof req.hostname === 'string'
+                    ? safeChronicleText(req.hostname, exports.RequestChronicleLimits.maxStringLength)
+                    : undefined,
+                ...(typeof upstreamRequestId === 'string' && upstreamRequestIdPattern.test(upstreamRequestId)
+                    ? { upstreamRequestId }
+                    : {}),
+            };
+        });
+    }
+    /**
+     * Conclude the request chronicle.
+     * Only the first call has an effect.
+     * @param res The response. A response that has not finished writing is recorded as aborted.
+     * @return True if this call concluded the chronicle, otherwise false.
+     */
+    finish(res) {
+        let concluded = false;
+        this.#safely('finish', () => {
+            if (!this.isRunning) {
+                return;
+            }
+            const durationMs = Math.max(0, Math.round(this.#now() - this.#startedAt));
+            const completed = res === undefined ? true : res.writableFinished === true;
+            const statusCode = res !== undefined && (res.headersSent || res.writableFinished) && Number.isFinite(res.statusCode)
+                ? res.statusCode
+                : undefined;
+            this.#state = 'finished';
+            this.#data.res = { ...(statusCode !== undefined ? { statusCode } : {}), completed };
+            const outcome = this.#outcome(completed, statusCode);
+            const classification = this.#classify(completed, statusCode, durationMs);
+            this.#data.result = {
+                ...this.#data.result,
+                durationMs,
+                outcome,
+                classification,
+                severity: this.#level(classification) ?? 'none',
+            };
+            concluded = true;
+        });
+        return concluded;
+    }
+    /**
+     * Log the finished request chronicle once, at the level for its classification.
+     * @param logger The logger to use.
+     */
+    log(logger = this.logger) {
+        this.#safely('log', () => {
+            if (!this.isFinished || this.#logged) {
+                return;
+            }
+            this.#logged = true;
+            const classification = this.#data.result?.classification;
+            const level = classification ? this.#level(classification) : null;
+            if (level !== null) {
+                logger[level](toChronicleLogRecord(this.#data), 'Request chronicle');
+            }
+        });
+    }
+    get hasErrors() {
+        return (this.#data.errors?.length ?? 0) > 0 || (this.#data.errorsOmitted ?? 0) > 0;
+    }
+    /**
+     * Record an error.
+     * Errors recorded when the chronicle is not running are logged immediately, with the request id.
+     * @param error The error.
+     * @param info Safe operation details to include when the error is logged outside a running chronicle.
+     */
+    addError(error, info) {
+        this.#safely('addError', () => {
+            // Services may record a failure before rethrowing it to a controller.
+            // Retain that error once while the request runs, without hiding late failures.
+            if (this.isRunning && error !== null && typeof error === 'object') {
+                if (this.#recordedErrors.has(error)) {
+                    return;
+                }
+                this.#recordedErrors.add(error);
+            }
+            const chronicleError = toChronicleError(error);
+            if (!this.isRunning) {
+                let safeInfo;
+                try {
+                    if (info !== undefined) {
+                        safeInfo = sanitizeChronicleValue(info);
+                    }
+                }
+                catch {
+                    // Hostile details must not suppress the error itself.
+                }
+                this.logger.error(toChronicleLogRecord({
+                    requestId: this.#requestId,
+                    ...(safeInfo !== undefined ? { info: safeInfo } : {}),
+                    error: chronicleError,
+                }), this.isFinished
+                    ? 'Request chronicle: error recorded after the request finished.'
+                    : 'Request chronicle: error recorded without an active request chronicle.');
+                return;
+            }
+            if (!Array.isArray(this.#data.errors)) {
+                this.#data.errors = [];
+            }
+            if (this.#data.errors.length >= exports.RequestChronicleLimits.maxErrors) {
+                this.#data.errorsOmitted = (this.#data.errorsOmitted ?? 0) + 1;
+                return;
+            }
+            this.#data.errors.push(chronicleError);
+        });
+    }
+    /**
+     * Add arbitrary details to the request chronicle.
+     * Values are sanitised and size-bounded.
+     * Warnings retain the request and raise its severity to at least warn.
+     * Details added after the chronicle finished are logged at the supplied level, with the request id.
+     * Details added when there is no running chronicle (e.g. socket requests) are ignored.
+     * @param info The details to add.
+     * @param level The severity of these details; defaults to debug for late details.
+     */
+    addInfo(info, level = 'debug') {
+        this.#safely('addInfo', () => {
+            if (info === null || info === undefined || typeof info !== 'object') {
+                return;
+            }
+            if (!this.isRunning && !this.isFinished) {
+                // There is no request chronicle (e.g. socket requests), so there is nothing to relate the details to.
+                return;
+            }
+            if (this.isRunning && level === 'warn') {
+                this.#hasWarnings = true;
+            }
+            const { entries, omitted } = sanitizeChronicleEntries(info);
+            if (entries.length === 0) {
+                return;
+            }
+            if (this.isFinished) {
+                this.logger[level](toChronicleLogRecord({
+                    requestId: this.#requestId,
+                    info: Object.fromEntries(entries),
+                    ...(omitted > 0 ? { infoOmitted: true } : {}),
+                }), 'Request chronicle: details recorded after the request finished.');
+                return;
+            }
+            if (omitted > 0) {
+                this.logger.warn('Request Chronicle Helper: Too many request chronicle details, some were ignored.');
+            }
+            for (const [key, value] of entries) {
+                if (reservedKeys.includes(key)) {
+                    this.logger.warn(`Request Chronicle Helper: Cannot overwrite reserved request chronicle key '${key}'.`);
+                    continue;
+                }
+                if (!(key in this.#data) && Object.keys(this.#data).length >= exports.RequestChronicleLimits.maxInfoKeys) {
+                    this.logger.warn(`Request Chronicle Helper: Too many request chronicle keys, ignoring key '${key}'.`);
+                    continue;
+                }
+                // Later values replace earlier values for the same key.
+                this.#data[key] = value;
+            }
+        });
+    }
+    /**
+     * Record the result of work that may continue after the response is sent, such as an audit event.
+     * While the request is running, the result is added to the request chronicle.
+     * After the request finishes, the result is logged separately, with the request id.
+     * @param operation A short name for the operation.
+     * @param error The error if the operation failed, otherwise undefined.
+     */
+    addOperationResult(operation, error) {
+        this.#safely('addOperationResult', () => {
+            const name = safeOperationName(operation);
+            const failed = error !== undefined;
+            if (this.isRunning) {
+                this.addInfo({ [name]: failed ? 'failure' : 'success' });
+                if (failed) {
+                    this.addError(error);
+                }
+                return;
+            }
+            const details = { requestId: this.#requestId, operation: name, outcome: failed ? 'failure' : 'success' };
+            if (failed) {
+                this.logger.error(toChronicleLogRecord({ ...details, error: toChronicleError(error) }), `Request chronicle: operation '${name}' failed after the request finished.`);
+            }
+            else {
+                this.logger.debug(details, `Request chronicle: operation '${name}' succeeded after the request finished.`);
+            }
+        });
+    }
+    #outcome(completed, statusCode) {
+        if (!completed) {
+            return 'aborted';
+        }
+        if ((statusCode ?? 0) >= 400 || this.hasErrors) {
+            return 'failure';
+        }
+        return 'success';
+    }
+    /**
+     * Classify this request chronicle.
+     * Keep all failed, aborted, slow, and warning requests, and a sample of the successful requests.
+     */
+    #classify(completed, statusCode, durationMs) {
+        const status = statusCode ?? 0;
+        if (status >= 500) {
+            return 'error';
+        }
+        if (status >= 400) {
+            return 'client-error';
+        }
+        if (this.hasErrors) {
+            return 'error';
+        }
+        if (!completed) {
+            return 'aborted';
+        }
+        if (durationMs > this.#settings.slowThresholdMs) {
+            return 'slow';
+        }
+        if (this.#hasWarnings) {
+            return 'warning';
+        }
+        const path = this.#data.req?.path;
+        if (this.#successSampleExclude !== null && typeof path === 'string' && this.#successSampleExclude.test(path)) {
+            return 'discard';
+        }
+        return this.#random() < this.#settings.successSampleRate ? 'sample' : 'discard';
+    }
+    #level(classification) {
+        if ((classification === 'client-error' && this.hasErrors) ||
+            (this.#hasWarnings && classificationLevels[classification] === 'info')) {
+            return 'warn';
+        }
+        return classificationLevels[classification];
+    }
+    /**
+     * Run a function, logging instead of throwing any error, so that recording never breaks the request.
+     */
+    #safely(name, func) {
+        try {
+            func();
+        }
+        catch {
+            try {
+                // Don't include the error: it may come from hostile or unprintable input.
+                this.logger.warn(`Request Chronicle Helper: '${name}' failed.`);
+            }
+            catch {
+                // Ignore logging failures.
+            }
+        }
+    }
+}
+exports.RequestChronicleHelper = RequestChronicleHelper;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RequestChronicle.js","sourceRoot":"","sources":["../../src/utilities/RequestChronicle.ts"],"names":[],"mappings":"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"}