@harperfast/harper 5.3.0-alpha.1 → 5.3.0-beta.1

package/dist/utility/logging/logRotation.js

@@ -0,0 +1,365 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVALID_MAX_SIZE_MSG = void 0;
+exports.parseMaxSize = parseMaxSize;
+exports.resolveRotatedLogDir = resolveRotatedLogDir;
+exports.isArchiveName = isArchiveName;
+exports.archivePathFor = archivePathFor;
+exports.rotateLogFileSync = rotateLogFileSync;
+exports.publishArchivedGeneration = publishArchivedGeneration;
+exports.isArchivePendingQuiescence = isArchivePendingQuiescence;
+exports.retryPendingGenerations = retryPendingGenerations;
+exports.compressPendingArchives = compressPendingArchives;
+exports.compressArchive = compressArchive;
+exports.createRotationGuard = createRotationGuard;
+// The rotation primitives the log write path needs. Kept free of every Harper import so
+// harper_logger.ts can pull it in eagerly: logRotator.ts reaches server/storageReclamation.ts ->
+// manageThreads.js -> harper_logger.ts, which is why it may only ever be required lazily, and a
+// guard installed on a timer is a guard the first megabytes of a burst are written without.
+const node_fs_1 = require("node:fs");
+const node_zlib_1 = require("node:zlib");
+const promises_1 = require("node:stream/promises");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const node_worker_threads_1 = require("node:worker_threads");
+const logGenerationCoordinator_ts_1 = require("./logGenerationCoordinator.js");
+// Bounds each writer's blind window at one quantum plus the flush that crosses it, so the file is
+// bounded by maxBytes + T * (quantum + batch) rather than by elapsed time. Fixed, not a remaining
+// budget: a budget assumes one thread's stat accounts for the other threads' future bytes.
+const CHECK_QUANTUM_DIVISOR = 16;
+const ROTATION_RETRY_COOLDOWN = 5000;
+const SIZE_UNIT_MULTIPLIERS = { K: 1e3, M: 1e6, G: 1e9 };
+exports.INVALID_MAX_SIZE_MSG = "'maxSize' must be a positive size with a K, M or G unit (for example '64M')";
+/**
+ * Convert `logging.rotation.maxSize` to bytes, or undefined if it cannot be a byte limit. One
+ * definition, shared with validation/configValidator.ts.
+ */
+function parseMaxSize(maxSize) {
+    if (typeof maxSize !== 'string')
+        return undefined;
+    const multiplier = SIZE_UNIT_MULTIPLIERS[maxSize.slice(-1)];
+    if (!multiplier)
+        return undefined;
+    const size = maxSize.slice(0, -1);
+    // Number(), not a stricter grammar, so every mantissa that yields a usable cap today keeps working.
+    if (size.trim() === '')
+        return undefined;
+    const bytes = Number(size) * multiplier;
+    return Number.isSafeInteger(bytes) && bytes > 0 ? bytes : undefined;
+}
+function resolveRotatedLogDir(logPath, configuredPath) {
+    return configuredPath || (0, node_path_1.join)((0, node_path_1.dirname)(logPath), 'rotated');
+}
+// threadId is load-bearing in the suffix below: worker threads share the process pid, and this
+// counter is per-isolate, so pid+seq alone cannot keep two threads' archives apart.
+let rotationSequence = 0;
+// A configured rotation path may also contain live logs, so destructive scans must identify archives.
+const ARCHIVE_NAME = /-[0-9a-f]{8}-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.\d{3}Z-\d+-\d+-\d+\.log(\.gz)?$/;
+function isArchiveName(file) {
+    return ARCHIVE_NAME.test(file);
+}
+function archivePathFor(logPath, rotatedLogDir) {
+    // Name the archive after its source log (hdb, external, a component name, ...), not a fixed
+    // "HDB" literal — external/component loggers inherit rotation from the main logger (#1877) and
+    // default to the same rotated directory. A basename alone is not enough either: two distinct
+    // source paths can share one (`/logs/a/hdb.log`, `/logs/b/hdb.log`), so a hash of the resolved
+    // source path plus the unique suffix give every archive a name rename() can never clobber.
+    const sourceName = (0, node_path_1.basename)(logPath, (0, node_path_1.extname)(logPath)) || 'HDB';
+    // sha256, not sha1: this only needs a stable identifier, but a FIPS-mode OpenSSL provider
+    // disables sha1 and throws synchronously, which would crash every rotation.
+    const sourceId = (0, node_crypto_1.createHash)('sha256').update((0, node_path_1.resolve)(logPath)).digest('hex').slice(0, 8);
+    const uniqueSuffix = `${process.pid}-${node_worker_threads_1.threadId}-${rotationSequence++}`;
+    const timestamp = new Date().toISOString().replaceAll(':', '-');
+    return (0, node_path_1.join)(rotatedLogDir, `${sourceName}-${sourceId}-${timestamp}-${uniqueSuffix}.log`);
+}
+/**
+ * Move the active log aside and release this isolate's descriptor, with nothing awaited in between:
+ * a rotation that yields to the event loop lets the logging loop that triggered it keep appending,
+ * which is the rate-dependent overshoot this whole change exists to remove.
+ */
+function rotateLogFileSync(logPath, rotatedLogDir, closeLogFile, activeStats) {
+    const active = activeStats ?? (0, node_fs_1.statSync)(logPath);
+    const archivePath = archivePathFor(logPath, rotatedLogDir);
+    (0, node_fs_1.renameSync)(logPath, archivePath);
+    closeLogFile();
+    // From the archive, not from the stat above: another isolate can rotate this generation away and
+    // its sink recreate the pathname between the two, and then this rename moves an inode the earlier
+    // stat never saw. Announcing that stat's identity would name a generation nobody holds, so every
+    // peer would answer "released" while still appending to the one about to be destroyed.
+    let { ino, dev } = active;
+    try {
+        ({ ino, dev } = (0, node_fs_1.statSync)(archivePath));
+    }
+    catch {
+        // Already claimed by retention or another pass; the pre-rename identity is the best available.
+    }
+    return { logPath, archivePath, ino, dev, generation: (0, logGenerationCoordinator_ts_1.nextGenerationId)() };
+}
+/**
+ * Publish an archived generation: ask every enumerable in-process peer to release it, then compress
+ * it if requested. The plain archive is only unlinked once that release is proven.
+ */
+async function publishArchivedGeneration(generation, compress, reportCompressionError) {
+    if (!(await (0, logGenerationCoordinator_ts_1.requestGenerationClose)(generation))) {
+        rememberUnprovenArchive(generation.archivePath, { generation, compress });
+        return generation.archivePath;
+    }
+    // A worker's peer set is eventually consistent while replacements join. Its release request can
+    // make peers reopen promptly, but only the main thread has an authoritative worker list and may
+    // destroy the plain archive; its audit will obtain a fresh proof for the archived snapshot.
+    if (compress && node_worker_threads_1.isMainThread) {
+        try {
+            return await compressArchive(generation.archivePath);
+        }
+        catch (error) {
+            reportCompressionError?.(error);
+        }
+    }
+    return generation.archivePath;
+}
+// A compression retry queue, not the safety mechanism — safety is the release the tick proves before
+// anything is destroyed. Bounded because rotation happens mostly in workers, which run no tick to
+// drain it, and because the archives are found on disk anyway.
+const MAX_UNPROVEN_ARCHIVES = 64;
+const unprovenArchives = new Map();
+function rememberUnprovenArchive(archivePath, pending) {
+    unprovenArchives.set(archivePath, pending);
+    while (unprovenArchives.size > MAX_UNPROVEN_ARCHIVES) {
+        unprovenArchives.delete(unprovenArchives.keys().next().value);
+    }
+}
+function isArchivePendingQuiescence(archivePath) {
+    return unprovenArchives.has(archivePath);
+}
+// Bounded per pass: a peer that never answers must not let the retry queue starve the audit work.
+const MAX_RETRIES_PER_PASS = 4;
+async function retryPendingGenerations(options = {}) {
+    const { deadline = Infinity, shouldStop = () => false } = options;
+    let attempts = 0;
+    for (const [archivePath, pending] of [...unprovenArchives]) {
+        if (shouldStop() || Date.now() >= deadline)
+            return;
+        if (attempts++ >= MAX_RETRIES_PER_PASS)
+            return;
+        if (!(0, node_fs_1.existsSync)(archivePath)) {
+            unprovenArchives.delete(archivePath);
+            continue;
+        }
+        if (!(await (0, logGenerationCoordinator_ts_1.requestGenerationClose)(pending.generation, deadline)))
+            continue;
+        unprovenArchives.delete(archivePath);
+        // One archive that will not compress must not stop the rest of the queue.
+        if (pending.compress)
+            await compressArchive(archivePath).catch(() => { });
+    }
+}
+/**
+ * Compress archives left plain by any isolate, from a listing taken before quiescence was proven.
+ * Write-path rotations happen mostly in the HTTP workers, whose unproven-archive bookkeeping the
+ * main thread cannot see, so without this a worker's archive would silently stay uncompressed for
+ * the life of the process however the operator configured `compress`.
+ * Only safe to call once quiescence has been proven for exactly this listing.
+ */
+async function compressPendingArchives(rotatedLogDir, files, liveLogPaths, options = {}) {
+    const { deadline = Infinity, shouldStop = () => false } = options;
+    const present = new Set(files);
+    let firstError;
+    for (const file of files) {
+        if (shouldStop() || Date.now() >= deadline)
+            break;
+        if (!file.endsWith('.log') || !isArchiveName(file))
+            continue;
+        const archivePath = (0, node_path_1.join)(rotatedLogDir, file);
+        if (liveLogPaths.has((0, node_path_1.resolve)(archivePath)) || unprovenArchives.has(archivePath))
+            continue;
+        try {
+            if (present.has(`${file}.gz`)) {
+                // Both representations of one generation: a crash between the .gz rename and the source
+                // unlink leaves the plain copy behind, and every later pass skipped it as already done, so
+                // it survived until retention aged it out — or forever, retention being unset by default.
+                // The .gz is renamed into place whole, and this pass already proved every peer released it.
+                await node_fs_1.promises.unlink(archivePath);
+                continue;
+            }
+            const result = await tryCompressArchive(archivePath);
+            if (!result.compressed)
+                break;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT' && !firstError)
+                firstError = { error, file };
+        }
+    }
+    return firstError;
+}
+// One compression at a time per rotated directory. A small maxSize on a busy instance rotates
+// hundreds of times a second, and a pipeline per rotation would exhaust descriptors and memory long
+// before retention could run.
+const compressionByDirectory = new Map();
+async function compressArchive(archivePath) {
+    return (await tryCompressArchive(archivePath)).path;
+}
+async function tryCompressArchive(archivePath) {
+    const directory = (0, node_path_1.dirname)(archivePath);
+    // Declined rather than queued: chaining would grow an unbounded list of pending jobs whenever
+    // rotation outruns gzip. The archive is left for the tick's bounded sweep, which is where an
+    // uncompressed rotation leaves it anyway. The slot is released by the promise this returns, not by
+    // a detached continuation, because that sweep awaits each call before making the next.
+    if (compressionByDirectory.has(directory))
+        return { path: archivePath, compressed: false };
+    const chain = compressOneArchive(archivePath).finally(() => {
+        if (compressionByDirectory.get(directory) === chain)
+            compressionByDirectory.delete(directory);
+    });
+    compressionByDirectory.set(directory, chain);
+    return { path: await chain, compressed: true };
+}
+async function compressOneArchive(archivePath) {
+    const compressedPath = `${archivePath}.gz`;
+    // Written to a temp file and renamed into place, so a crash mid-gzip can never leave a truncated
+    // `.gz` looking like the authoritative copy of a generation.
+    const temporaryPath = `${compressedPath}.${process.pid}-${node_worker_threads_1.threadId}-${rotationSequence++}.tmp`;
+    try {
+        await (0, promises_1.pipeline)((0, node_fs_1.createReadStream)(archivePath), (0, node_zlib_1.createGzip)(), (0, node_fs_1.createWriteStream)(temporaryPath));
+        await node_fs_1.promises.rename(temporaryPath, compressedPath);
+    }
+    catch (error) {
+        await node_fs_1.promises.unlink(temporaryPath).catch(() => { });
+        throw error;
+    }
+    await node_fs_1.promises.unlink(archivePath);
+    return compressedPath;
+}
+/**
+ * The write-path size guard. One subtraction and one branch per flush; one pathname stat once per
+ * quantum of this writer's own output.
+ */
+function createRotationGuard(options) {
+    const { logPath, maxBytes, rotatedLogDir, compress, getLogIdentity, closeLogFile, report, onRotated } = options;
+    const checkQuantum = Math.max(1, Math.floor(maxBytes / CHECK_QUANTUM_DIVISOR));
+    const logDir = (0, node_path_1.dirname)(logPath);
+    (0, node_fs_1.mkdirSync)(rotatedLogDir, { recursive: true });
+    // The sink creates this one lazily, on the first append that gets ENOENT, and rotatedLogDir is not
+    // always under it — so without this the stat below throws ENOENT on a directory that is about to
+    // exist, and rotation stays off for the life of the process.
+    (0, node_fs_1.mkdirSync)(logDir, { recursive: true });
+    // Rotation is a rename, and a rename across devices can never succeed. Refusing to build the guard
+    // here turns a misconfiguration that would otherwise fail closed on every write — ending file
+    // logging for the life of the process — into one startup error and today's unrotated behavior.
+    if ((0, node_fs_1.statSync)(rotatedLogDir).dev !== (0, node_fs_1.statSync)(logDir).dev) {
+        throw new Error(`the rotation directory ${rotatedLogDir} is on a different filesystem than ${logPath}`);
+    }
+    let bytesUntilCheck = checkQuantum;
+    let retryAfter = 0;
+    let rotationPending = false;
+    let rotating = false;
+    try {
+        // Seeded from the file as it actually is, so an instance restarted onto an already-oversized
+        // log rotates on its first write rather than on the first audit tick a minute later.
+        bytesUntilCheck = Math.min(checkQuantum, Math.max(0, maxBytes - (0, node_fs_1.statSync)(logPath).size));
+    }
+    catch {
+        // No log file yet.
+    }
+    return { beforeAppend, recordWrite, checkQuantum };
+    /**
+     * Try a pending rotation before the next append. A failed rotation leaves the active file
+     * writable: daemonized services discard stdio, so refusing the append would silently lose logs.
+     */
+    function beforeAppend() {
+        // `rotating` first: the rotation notice is written back through this same sink, and it must
+        // not re-enter a rotation that has not finished setting its own state.
+        if (rotating || !rotationPending)
+            return true;
+        if (retryAfter > performance.now())
+            return true;
+        attemptRotation();
+        // If rotation is still unavailable, preserving records in the writable active log is safer
+        // than silently dropping them (scripted services have no stdio fallback).
+        return true;
+    }
+    function recordWrite(byteLength) {
+        bytesUntilCheck -= byteLength;
+        if (bytesUntilCheck > 0)
+            return;
+        bytesUntilCheck = checkQuantum;
+        // `rotating` covers the rotation notice, which is written back through this same sink.
+        if (rotating || retryAfter > performance.now())
+            return;
+        attemptRotation();
+    }
+    function attemptRotation() {
+        rotating = true;
+        try {
+            checkAndRotate();
+            rotationPending = false;
+        }
+        catch (error) {
+            // rename() reports ENOENT for a missing source AND for a missing destination directory, and
+            // only the first is benign. A missing source is the normal multi-writer outcome: another
+            // thread (or the audit tick) renamed the generation between this thread's stat and its
+            // rename, so the file is under the cap now, which is all this check wanted. A missing
+            // destination means no rotation can ever succeed, and treating that as a race would clear
+            // the cap check on every pass and let the log grow without a bound or a diagnostic. The
+            // destination is what is asked about: a peer can recreate the source pathname between the
+            // failed rename and this check, which would make the benign case look like the fatal one.
+            if (error.code === 'ENOENT' && (0, node_fs_1.existsSync)(rotatedLogDir)) {
+                closeLogFile();
+                rotationPending = false;
+                return;
+            }
+            rotationPending = true;
+            retryAfter = performance.now() + ROTATION_RETRY_COOLDOWN;
+            closeLogFile();
+            report(`Harper cannot rotate its log file: ${error}`);
+            // A rotation target removed under a running instance is recoverable; recreate it here rather
+            // than on every rotation, so the common path keeps costing one stat and one rename.
+            if (error.code === 'ENOENT') {
+                try {
+                    (0, node_fs_1.mkdirSync)(rotatedLogDir, { recursive: true });
+                }
+                catch {
+                    // Reported above already; the retry will fail the same way and report again.
+                }
+            }
+        }
+        finally {
+            rotating = false;
+        }
+    }
+    function checkAndRotate() {
+        let active;
+        try {
+            active = (0, node_fs_1.statSync)(logPath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            // The generation this descriptor belongs to has already been rotated away by someone else.
+            closeLogFile();
+            return;
+        }
+        // The descriptor's identity is cached when it is opened, so the common checkpoint costs this
+        // one pathname stat rather than a stat plus an fstat.
+        if (!holdsGeneration(active)) {
+            closeLogFile();
+            return;
+        }
+        if (active.size < maxBytes)
+            return;
+        const generation = rotateLogFileSync(logPath, rotatedLogDir, closeLogFile, active);
+        onRotated?.(generation.archivePath);
+        publishArchivedGeneration(generation, compress, (error) => report(`Harper could not compress a rotated log file: ${error}`)).catch((error) => report(`Harper could not publish a rotated log file: ${error}`));
+    }
+    function holdsGeneration(active) {
+        const identity = getLogIdentity();
+        if (!identity)
+            return true;
+        // Some Windows filesystems report an unstable or zero ino, where identity cannot distinguish
+        // generations; there this defers to the size check rather than closing a descriptor at random.
+        if (identity.ino === 0 || active.ino === 0)
+            return true;
+        return identity.ino === active.ino && identity.dev === active.dev;
+    }
+}
+//# sourceMappingURL=logRotation.js.map

package/dist/utility/logging/logRotation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logRotation.js","sourceRoot":"","sources":["../../../utility/logging/logRotation.ts"],"names":[],"mappings":"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"}

package/dist/utility/logging/logRotator.d.ts

@@ -5,7 +5,7 @@ export { logRotator };
  * If log file is within the values set in config, log file will be renamed/moved and a new empty hdb.log created.
  * @returns LogRotator
  */
-declare function logRotator({ logger, maxSize, interval, retention, enabled, path: rotatedLogDir, auditInterval }: any): {
+declare function logRotator({ logger, maxSize, interval, retention, enabled, compress, path: rotatedLogDir, auditInterval, }: any): {
     end(): void;
     getLastRotatedLogPath(): any;
 };