@harperfast/harper 5.2.13 → 5.3.0-beta.1

package/dist/utility/logging/harper_logger.js

@@ -37,6 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.forComponent = exports.getLogFilePath = exports.externalLogger = exports.logLevel = exports.OUTPUTS = void 0;
+exports.updateLogger = updateLogger;
 exports.isErrorLike = isErrorLike;
 exports.disableStdio = disableStdio;
 exports.isStdioBrokenError = isStdioBrokenError;
@@ -72,6 +73,8 @@ const packageUtils_js_1 = require("../../utility/packageUtils.js");
 const globals_js_1 = require("../../globals.js");
 const console_1 = require("console");
 const node_util_1 = require("node:util");
+const logRotation_ts_1 = require("./logRotation.js");
+const logGenerationCoordinator_ts_1 = require("./logGenerationCoordinator.js");
 const { isNativeError } = node_util_1.types;
 // store the native write function so we can call it after we write to the log file (and store it on process.stdout
 // because unit tests will create multiple instances of this module)
@@ -100,6 +103,17 @@ exports.OUTPUTS = {
 // Location of default config YAML.
 const DEFAULT_CONFIG_FILE = join(packageUtils_js_1.PACKAGE_ROOT, 'static', hdbTerms.HDB_DEFAULT_CONFIG_FILE);
 const CLOSE_LOG_FD_TIMEOUT = 10000;
+// Above the module-scope initLogSettings() call below, which reaches getFileLogger: a const
+// declared after it is still in its temporal dead zone when the file sink first reads one.
+const LOG_TIME_USAGE_THRESHOLD = 100;
+// How long to write straight to stdio after the log file refuses an append.
+const APPEND_RETRY_COOLDOWN = 5000;
+// Ceiling on how often a failing rotation may report itself; the failure repeats every check point.
+const ROTATION_REPORT_INTERVAL = 60000;
+const SET_ROTATION_POLICY = Symbol('setRotationPolicy');
+const GET_ROTATION_POLICY = Symbol('getRotationPolicy');
+const FILE_ROTATION_SOURCE = Symbol('fileRotationSource');
+const SERVICE_NAME = worker_threads_1.workerData?.name?.replace(/ /g, '-') || 'main';
 let logConsole;
 let log_to_file;
 let logToStdstreams;
@@ -149,8 +163,19 @@ let logImmediately;
 // Call init to get all the required log settings.
 let hdbProperties;
 let rootConfig;
-function updateLogger(logger, logOptions, name) {
-    logger.rotation = logOptions.rotation;
+// `mainLoggerRef` defaults to the module's private `mainLogger` singleton (the real production
+// behavior) but can be overridden by callers (currently just tests) so the inheritance decision
+// below can be exercised against a throwaway logger without reaching into module-private state.
+function updateLogger(logger, logOptions, name, mainLoggerRef = mainLogger) {
+    // Fall back to the main logger's rotation (like level/path below) so an external/component
+    // logger with no rotation block of its own inherits maxSize/interval/etc rather than losing
+    // rotation entirely (#1877). Excluded when `logger` IS mainLoggerRef: the fallback would just
+    // reassign mainLogger.rotation to itself, making it impossible to ever clear main's rotation.
+    const inheritedRotation = logOptions.rotation ?? (logger === mainLoggerRef ? undefined : mainLoggerRef?.rotation);
+    const loggerPolicy = logger[GET_ROTATION_POLICY]?.();
+    const mainPolicy = mainLoggerRef?.[GET_ROTATION_POLICY]?.();
+    const inheritsRotation = logOptions.rotation == null && logger !== mainLoggerRef;
+    const rotationSource = inheritsRotation ? mainPolicy?.source : loggerPolicy?.ownSource;
     let path = logOptions.path;
     if (path) {
         if (!logOptions.root)
@@ -160,20 +185,49 @@ function updateLogger(logger, logOptions, name) {
         path = join(logOptions.root, logName);
     }
     else {
-        path = mainLogger.path;
+        path = mainLoggerRef.path;
         if (!logOptions.root)
             logOptions.root = pathModule.dirname(path);
     }
+    if (inheritedRotation && inheritedRotation === mainLoggerRef?.rotation && path !== mainLoggerRef?.path) {
+        // This logger has no rotation block of its own and is inheriting main's wholesale — but
+        // inheriting `rotation.path` too would point this logger's archives at wherever main
+        // archives to. If this logger's file lives on a different filesystem/volume than that
+        // directory, the rotator's fs.rename() there fails with EXDEV and the tick error leaks
+        // (contained in logRotator.ts) without ever rotating this log. Strip the inherited path so
+        // rotation instead defaults beside this logger's own path (logRotator's own <log dir>/rotated
+        // fallback); an explicit `rotation.path` in this logger's own config still wins, since that
+        // goes through `logOptions.rotation` above, not this fallback. Clone rather than mutate:
+        // `inheritedRotation` is the literal object shared by mainLogger.rotation and every other
+        // component that inherited it.
+        //
+        // Only when the paths differ. A logger writing to main's own file shares main's rotation
+        // state — file loggers are cached per path — so stripping there discards the operator's
+        // configured rotation.path for the main log itself, which no EXDEV risk justifies.
+        const { path: _inheritedPath, ...rotationWithoutPath } = inheritedRotation;
+        setRotationPolicy(rotationWithoutPath);
+    }
+    else {
+        setRotationPolicy(inheritedRotation);
+    }
+    // After the rotation above: assigning `path` goes through the setter that rebuilds this path's
+    // file logger, and it reads `logger.rotation` as it stands at that moment.
     if (path)
         logger.path = path;
     else
         console.error('No path for logger', logOptions);
-    logger.level = LOG_LEVEL_HIERARCHY[logOptions.level] ?? mainLogger?.level ?? LOG_LEVEL_HIERARCHY.info;
+    logger.level = LOG_LEVEL_HIERARCHY[logOptions.level] ?? mainLoggerRef?.level ?? LOG_LEVEL_HIERARCHY.info;
     updateConditional(logger);
     logger.logToStdstreams = logOptions.stdStreams ?? false;
     // if there is a configured tag or if a component is logging to default/main log path, use the component name as the tag
     // to differentiate it
-    logger.tag = logOptions.tag ?? ((mainLogger.path === logger.path || exports.externalLogger.path === logger.path) && name);
+    logger.tag = logOptions.tag ?? ((mainLoggerRef.path === logger.path || exports.externalLogger.path === logger.path) && name);
+    function setRotationPolicy(rotation) {
+        if (logger[SET_ROTATION_POLICY])
+            logger[SET_ROTATION_POLICY](rotation, rotationSource, inheritsRotation);
+        else
+            logger.rotation = rotation;
+    }
 }
 // creates a logger where the methods are only defined if they are within the log level.
 // Using this conditional logger means that every method call must be optional like log.trace?.('message),
@@ -202,13 +256,25 @@ function resolveLogPath(configPath, rootPath) {
 async function updateLogSettings() {
     if (!rootConfig) {
         // set up the initial watcher
-        rootConfig = new RootConfigWatcher_ts_1.RootConfigWatcher();
+        rootConfig = (0, RootConfigWatcher_ts_1.getSharedRootConfigWatcher)();
         // wait for it to be ready
         await rootConfig.ready;
         // TODO: Any way to differentiate changes that we can and can't handle?
         rootConfig.on('change', updateLogSettings);
     }
-    let rootConfigObject = rootConfig.config;
+    applyLogSettings(rootConfig.config);
+}
+// Separate from the watcher wiring above because the watcher it builds reads a process-wide path,
+// which leaves no way to exercise these settings against a given config.
+function applyLogSettings(rootConfigObject) {
+    // `ready` settles on every terminal read outcome, including ones that carry no config at all —
+    // see DESIGN.md, "Every terminal read outcome settles the barrier". Applying that as settings
+    // would not be "the defaults": `updateLogger` reads an absent `rotation` as rotation off and an
+    // absent `console` as console off, so an unreadable config would silently disable logging.
+    // What `initLogSettings()` established at startup stands until a real config arrives, which
+    // is why the watcher settles those outcomes with no config rather than an empty one.
+    if (!rootConfigObject || typeof rootConfigObject !== 'object')
+        return;
     const logOptions = rootConfigObject.logging ?? {};
     // Resolve relative paths against rootPath from the same config
     const rootPath = rootConfigObject.rootPath;
@@ -231,7 +297,9 @@ async function updateLogSettings() {
     for (const name in rootConfigObject) {
         // we now scan each component to see if it has logging individual configured
         const component = rootConfigObject[name];
-        if (component.logging) {
+        // `myComponent:` with nothing under it parses to null, and an async listener's TypeError
+        // escapes the watcher's emit guard as an unhandled rejection.
+        if (component?.logging) {
             updateLogger(mainLogger.forComponent(name), component.logging, name);
         }
         else if (mainLogger.hasComponent(name)) {
@@ -431,6 +499,8 @@ module.exports = {
     // we can start using the RootConfigWatcher
     start: updateLogSettings,
     startOnMainThread: updateLogSettings,
+    // Test-only: applies a config without the process-wide watcher `updateLogSettings` builds.
+    _applyLogSettingsForTests: applyLogSettings,
     errorToString,
     errorForLog,
     inspectForLog,
@@ -438,7 +508,19 @@ module.exports = {
     disableStdio,
     isStdioBrokenError,
     externalLogger: exports.externalLogger,
+    updateLogger,
 };
+// Writes past the stdio guard installed by installStdioGuard, which would otherwise route the
+// text back into the file logger this is the fallback for, and swallows a broken pipe - there is
+// nowhere left to report it.
+function writeToStdioDirectly(stream, text) {
+    try {
+        nativeStdWrite.call(stream, text);
+    }
+    catch {
+        // stdio is gone too
+    }
+}
 // A bare no-op would read as permanent backpressure to a pipe()'d source; this drains and
 // discards instead.
 function noopWrite(_chunk, encoding, callback) {
@@ -479,6 +561,14 @@ function logsAtLevel(level) {
 function initLogSettings(forceInit = false) {
     try {
         if (hdbProperties === undefined || forceInit) {
+            if (forceInit && mainLogger?.[SET_ROTATION_POLICY]) {
+                const currentPath = mainLogger.path;
+                if (currentPath) {
+                    const { ownSource } = mainLogger[GET_ROTATION_POLICY]();
+                    mainLogger[SET_ROTATION_POLICY](undefined, ownSource, false);
+                    mainLogger.path = currentPath;
+                }
+            }
             closeLogFile();
             const bootPropsFilePath = getPropsFilePath();
             let properties = (0, assignCmdEnvVariables_ts_1.default)(['ROOTPATH']);
@@ -557,10 +647,17 @@ function initLogSettings(forceInit = false) {
             log_to_file = false;
             logToStdstreams = true;
             exports.logLevel = exports.logLevel === undefined ? defaultLevel : exports.logLevel;
-            mainLogger = createLogger({ level: exports.logLevel });
+            // createLogger shadows the module-level `logToStdstreams` with this option, so omitting it
+            // drops every log written before a config exists rather than routing it to the streams.
+            mainLogger = createLogger({ level: exports.logLevel, stdStreams: logToStdstreams });
             // setup the external logger
             exports.externalLogger = mainLogger.forComponent('external');
             exports.externalLogger.tag = null; // don't tag by default
+            // The streams are this branch's only sink, so it needs the same EPIPE/EIO listeners the
+            // configured path installs below: `harper install | head -1` closes the reader, and the
+            // async error would otherwise land on a stream with none and take the install down. The
+            // guard's write override is inert here, because `log_to_file` is false.
+            stdioLogging();
             return;
         }
         console.error(err);
@@ -648,14 +745,18 @@ function suppressLogging(callback) {
         loggingEnabled = true;
     }
 }
-const SERVICE_NAME = worker_threads_1.workerData?.name?.replace(/ /g, '-') || 'main';
 // these are used to store information about the current service and tag so we can prepend them to the log during
 // the writes, without having to pass the information through the Console instance
 let currentLevel = 'info'; // default is info
 let currentServiceName;
 let currentTag;
 function createLogger(options = {}) {
-    let { path: logFilePath, level: logLevel, stdStreams: logToStdstreams, rotation, isExternalInstance, writeToLog, component, } = options;
+    let { path: logFilePath, level: logLevel, stdStreams: logToStdstreams, rotation, isExternalInstance, writeToLog, component, rotationSource, rotationInherited = false, } = options;
+    const ownRotationSource = Symbol('rotationPolicySource');
+    let currentRotationSource = rotationSource ?? ownRotationSource;
+    let previousRotationSource;
+    let currentRotationInherited = rotationInherited;
+    let rotationChangeIsAuthoritative = rotation !== undefined;
     if (!logLevel)
         logLevel = 'info';
     let level = typeof logLevel === 'number' ? logLevel : LOG_LEVEL_HIERARCHY[logLevel];
@@ -706,7 +807,8 @@ function createLogger(options = {}) {
         else if (logToStdstreams)
             process.stderr.write(log);
     }
-    let logToFile = logFilePath && getFileLogger(logFilePath, rotation, isExternalInstance);
+    let logToFile = logFilePath && getFileLogger(logFilePath, rotation, isExternalInstance, rotationPolicy());
+    rotationPolicyApplied();
     function logPrepend(write) {
         return {
             write(log) {
@@ -728,6 +830,14 @@ function createLogger(options = {}) {
         stderr: logPrepend(writeToLog ?? logStdErr),
         colorMode: (logToStdstreams && colorMode) || false,
     }, level);
+    logger[SET_ROTATION_POLICY] = function (newRotation, source = ownRotationSource, inherited = false) {
+        previousRotationSource = currentRotationSource;
+        currentRotationSource = source ?? ownRotationSource;
+        currentRotationInherited = inherited;
+        rotationChangeIsAuthoritative = true;
+        logger.rotation = newRotation;
+    };
+    logger[GET_ROTATION_POLICY] = () => ({ ownSource: ownRotationSource, source: currentRotationSource });
     updateConditional(logger);
     logger.path = logFilePath;
     Object.defineProperty(logger, 'path', {
@@ -736,7 +846,10 @@ function createLogger(options = {}) {
         },
         set(path) {
             logFilePath = path;
-            logToFile = getFileLogger(logFilePath, logger.rotation, isExternalInstance);
+            if (!logFilePath)
+                return;
+            logToFile = getFileLogger(logFilePath, logger.rotation, isExternalInstance, rotationPolicy());
+            rotationPolicyApplied();
             if (isExternalInstance)
                 writeToLogFile = logToFile;
         },
@@ -750,12 +863,15 @@ function createLogger(options = {}) {
             let componentLogger = components.get(name);
             if (!componentLogger) {
                 const protoLogger = isExternal ? exports.externalLogger : logger;
+                const protoRotationPolicy = protoLogger[GET_ROTATION_POLICY]?.();
                 componentLogger = createLogger({
                     path: protoLogger.path,
                     level: protoLogger.level,
                     stdStreams: protoLogger.logToStdstreams,
                     isExternalInstance: isExternal || name === 'external',
                     rotation: protoLogger.rotation,
+                    rotationSource: protoRotationPolicy?.source,
+                    rotationInherited: true,
                     writeToLog,
                     component: true,
                 });
@@ -772,33 +888,80 @@ function createLogger(options = {}) {
         logger.components = components;
     }
     return logger;
+    function rotationPolicy() {
+        return {
+            source: currentRotationSource,
+            previousSource: previousRotationSource,
+            inherited: currentRotationInherited,
+            authoritative: rotationChangeIsAuthoritative,
+        };
+    }
+    function rotationPolicyApplied() {
+        previousRotationSource = currentRotationSource;
+        rotationChangeIsAuthoritative = false;
+    }
 }
-const LOG_TIME_USAGE_THRESHOLD = 100;
 /**
  * Get the file logger for the given path. If it doesn't exist, create it.
  * @param path
  * @param isExternalInstance
  * @return {any}
  */
-function getFileLogger(path, rotation, isExternalInstance) {
+function getFileLogger(path, rotation, isExternalInstance, rotationPolicy) {
     let logger = fileLoggers.get(path);
-    let logFD, loggedFDError, logTimer;
+    let logFD, loggedFDError, loggedAppendError, logTimer, retryAppendAfter;
     let logBuffer;
+    let rotationProblemNotice;
     let logTimeUsage = 0;
+    let rotationGuard, logFDIdentity, nextRotationReport = 0;
     if (!logger) {
         logger = logToFile;
         logger.closeLogFile = closeLogFile;
+        // The guard has to be installed through the live closure: later calls for this path get the
+        // cached logger back, and their own logFD/logBuffer are dead.
+        logger.installRotationGuard = installRotationGuard;
         logger.path = path;
         fileLoggers.set(path, logger);
-    }
-    if (worker_threads_1.isMainThread && JSON.stringify(rotation) !== JSON.stringify(logger.rotation)) {
+        // Registered by the sink, not by the size guard: a thread that writes this file but has no
+        // guard (no maxSize, or rotation driven only by interval) still holds a descriptor, and an
+        // answer from it has to mean "released" rather than only "handler ran".
+        (0, logGenerationCoordinator_ts_1.registerLogSink)(path, { identity: () => logFDIdentity, close: closeLogFile });
+    }
+    const currentSource = logger[FILE_ROTATION_SOURCE];
+    const sameSource = currentSource === rotationPolicy.source;
+    const replacesPreviousSource = currentSource !== undefined && currentSource === rotationPolicy.previousSource;
+    const canInstall = rotation !== undefined &&
+        (!rotationPolicy.inherited || currentSource === undefined || sameSource || replacesPreviousSource);
+    const canClear = rotation === undefined && rotationPolicy.authoritative && (sameSource || replacesPreviousSource);
+    let reconfigured = false;
+    if (canInstall) {
+        logger[FILE_ROTATION_SOURCE] = rotationPolicy.source;
+        reconfigured = JSON.stringify(rotation) !== JSON.stringify(logger.rotation);
+    }
+    if (reconfigured) {
         logger.rotation = rotation;
+        // Every writing thread, and synchronously: request logging is produced by the HTTP workers, and
+        // at the rates that make maxSize matter a deferred guard misses megabytes before it exists.
+        logger.installRotationGuard(rotation);
+    }
+    else if (canClear) {
+        logger.rotation = undefined;
+        logger[FILE_ROTATION_SOURCE] = undefined;
+        logger.installRotationGuard(undefined);
+        reconfigured = true;
+    }
+    if (worker_threads_1.isMainThread && reconfigured) {
         setTimeout(() => {
-            logger.rotator?.end();
-            if (!rotation)
-                return;
-            const { logRotator } = require('./logRotator');
+            // Everything inside the try: a throw from a timer callback is unhandled, and neither
+            // require('./logRotator') (which reaches environmentManager's synchronous init) nor a
+            // rotator teardown may take the process down over log rotation (#847).
             try {
+                const previousRotator = logger.rotator;
+                logger.rotator = undefined;
+                previousRotator?.end();
+                if (!rotation)
+                    return;
+                const { logRotator } = require('./logRotator');
                 logger.rotator = logRotator({
                     logger,
                     ...rotation,
@@ -810,6 +973,50 @@ function getFileLogger(path, rotation, isExternalInstance) {
         }, 100);
     }
     return logger;
+    function installRotationGuard(newRotation) {
+        rotationGuard = undefined;
+        if (!newRotation || newRotation.enabled === false)
+            return;
+        const maxBytes = (0, logRotation_ts_1.parseMaxSize)(newRotation.maxSize);
+        if (!maxBytes) {
+            if (newRotation.maxSize != null)
+                reportRotationProblem(`logging.rotation.maxSize: ${logRotation_ts_1.INVALID_MAX_SIZE_MSG}`);
+            return;
+        }
+        try {
+            rotationGuard = (0, logRotation_ts_1.createRotationGuard)({
+                logPath: path,
+                maxBytes,
+                rotatedLogDir: (0, logRotation_ts_1.resolveRotatedLogDir)(path, newRotation.path),
+                // From the rotation block rather than environmentManager (which logRotator still reads):
+                // environmentManager imports this module, so it cannot be reached from the write path.
+                compress: newRotation.compress,
+                getLogIdentity: () => logFDIdentity,
+                closeLogFile,
+                report: reportRotationProblem,
+                onRotated(archivePath) {
+                    // Same shape as every other line in the file: written straight to the sink, this
+                    // bypasses the prefix createLogger's logPrepend adds, and readLog parses by level.
+                    logToFile(`[${SERVICE_NAME}/${worker_threads_1.threadId}] [notify]: hdb.log rotated, old log moved to ${archivePath}`);
+                },
+            });
+        }
+        catch (error) {
+            reportRotationProblem(`log rotation is disabled for ${path}: ${error}`);
+        }
+    }
+    function reportRotationProblem(text) {
+        // Straight to stdio, never back through this sink: the sink is what rotation is failing on.
+        // Rate-limited rather than once-only, so a later, different failure is still reported.
+        if (nextRotationReport > performance.now())
+            return;
+        nextRotationReport = performance.now() + ROTATION_REPORT_INTERVAL;
+        const message = `Harper log rotation problem — ${text}`;
+        // Scripted services discard stdio. Preserve the warning in the active file on the next
+        // successful append as well, without recursing through the rotation guard.
+        rotationProblemNotice = `${new Date().toISOString()} [${SERVICE_NAME}/${worker_threads_1.threadId}] [error]: ${message}\n`;
+        writeToStdioDirectly(process.stderr, `${message}\n`);
+    }
     function logToFile(log) {
         let entry = `${new Date().toISOString()} ${log}${log.endsWith('\n') ? '' : '\n'}`;
         if (logBuffer) {
@@ -839,19 +1046,51 @@ function getFileLogger(path, rotation, isExternalInstance) {
     }
     // this is called on a timer, and will write the log buffer to the file
     function logQueuedData(entry) {
+        const payload = logBuffer ? logBuffer.join('') : entry;
+        // Released before anything can re-enter: the rotation notice is written from inside the append
+        // below, and a re-entrant flush still holding this batch would write it twice.
+        logBuffer = null;
+        if (payload === undefined)
+            return;
+        // A file that just refused a write will refuse the next one too, and every attempt costs a
+        // failed syscall plus a thrown error on whatever path is logging - which, on a full volume,
+        // is the request path at full rate. Go straight to stdio until the cooldown expires.
+        // Opened after the guard: a guard recovering by rotation closes this descriptor first.
+        const mayAppend = !(retryAppendAfter > performance.now()) && (rotationGuard?.beforeAppend() ?? true);
         openLogFile(undefined);
-        if (logFD) {
+        if (logFD && mayAppend) {
             let startTime = performance.now();
-            fs.appendFileSync(logFD, logBuffer ? logBuffer.join('') : entry);
+            try {
+                const appendPayload = rotationProblemNotice ? rotationProblemNotice + payload : payload;
+                const appendBuffer = Buffer.from(appendPayload);
+                fs.appendFileSync(logFD, appendBuffer);
+                rotationProblemNotice = undefined;
+                // Both cleared, so a volume that fills again months later reports itself again
+                retryAppendAfter = undefined;
+                loggedAppendError = false;
+                rotationGuard?.recordWrite(appendBuffer.length);
+            }
+            catch (error) {
+                retryAppendAfter = performance.now() + APPEND_RETRY_COOLDOWN;
+                // A log write must never take the process down: on an exhausted volume this throws from
+                // both inline and timer call sites, making every log statement a crash point (#847).
+                // The fallback goes through nativeStdWrite rather than console because
+                // installStdioGuard routes console output back into this same file logger when
+                // logging.file and logging.console are both on, which would recurse until the stack blew.
+                if (!loggedAppendError) {
+                    loggedAppendError = true;
+                    writeToStdioDirectly(process.stderr, `Harper cannot write to its log file: ${error}\n`);
+                }
+                writeToStdioDirectly(process.stdout, payload);
+                return;
+            }
             let endTime = performance.now();
             // determine if we are using more than about two percent of processing time for log writes recently, and if so, we
             // will start buffering
             logTimeUsage = Math.max(endTime, logTimeUsage) + (endTime - startTime) * 50;
         }
-        else if (!loggedFDError)
-            console.log(logBuffer ? logBuffer.join('') : entry);
-        if (logBuffer)
-            logBuffer = null;
+        else
+            writeToStdioDirectly(process.stdout, payload);
     }
     function closeLogFile(_unused) {
         try {
@@ -859,6 +1098,7 @@ function getFileLogger(path, rotation, isExternalInstance) {
         }
         catch { }
         logFD = null;
+        logFDIdentity = null;
         if (isExternalInstance)
             mainLogFd = null;
     }
@@ -866,14 +1106,29 @@ function getFileLogger(path, rotation, isExternalInstance) {
         if (!logFD) {
             try {
                 logFD = fs.openSync(path, 'a');
+                // Which generation this descriptor belongs to, recorded once here so the size guard's
+                // checkpoint needs a single pathname stat to tell whether the file has moved under it.
+                try {
+                    const opened = fs.fstatSync(logFD);
+                    logFDIdentity = { ino: opened.ino, dev: opened.dev };
+                }
+                catch {
+                    logFDIdentity = null;
+                }
                 if (isExternalInstance)
                     mainLogFd = logFD;
             }
             catch (error) {
                 if (error.code === 'ENOENT' && !isRetry) {
                     // if the directory doesn't exist, create it
-                    fs.mkdirpSync(pathModule.dirname(path));
-                    return openLogFile(true);
+                    try {
+                        fs.mkdirpSync(pathModule.dirname(path));
+                        return openLogFile(true);
+                    }
+                    catch (mkdirError) {
+                        // creating the log directory can fail for the same reason the log write can
+                        error = mkdirError;
+                    }
                 }
                 if (!loggedFDError) {
                     loggedFDError = true;
@@ -1906,5 +2161,6 @@ exports.default = {
     errorForLog,
     inspectForLog,
     isErrorLike,
+    updateLogger,
 };
 //# sourceMappingURL=harper_logger.js.map