@tryghost/bunyan-rotating-filestream 0.0.14 → 0.0.16

package/README.md

@@ -37,6 +37,21 @@ const log = bunyan.createLogger({
 
 Other options include `startNewFile` to always open a new file on start-up.
 
+### Flushing
+
+Writes are queued and written asynchronously, so a process that exits right
+after logging can lose the last lines. `flush()` drains everything written so
+far to disk and leaves the stream open:
+
+```js
+log.error('fatal boot error');
+await stream.flush();
+process.exit(1);
+```
+
+Use `end()` instead when shutting the stream down for good — it also drains the
+queue, but closes the file handles and stops rotation.
+
 ## Develop
 
 This is a mono repository, managed with [Nx](https://nx.dev).

package/index.js

@@ -61,6 +61,22 @@ class RotatingFileStream {
         this._queue.push(data);
     }
 
+    /**
+     * Force everything written into this stream so far out to disk, without
+     * closing it. The stream stays writable afterwards, unlike `end()`.
+     * @returns {Promise<void>}
+     */
+    async flush() {
+        if (this._closed) {
+            return;
+        }
+        await this._initialised;
+        // A rotation in progress owns the file handle - wait for it to hand
+        // the new one to the queue before draining
+        await this._rotating;
+        await this._queue.flush();
+    }
+
     async end() {
         // Block new rotations immediately - the threshold trigger has no timer
         // to shut down and can still fire while the queue drains below

package/lib/writeQueue.js

@@ -36,6 +36,28 @@ class WriteQueue extends EventEmitter {
         this._writing = this._write(currentEventCount);
     }
 
+    /**
+     * Drain everything queued so far, leaving the queue writable afterwards.
+     *
+     * Writes are asynchronous, so a process that exits right after logging
+     * (e.g. on a fatal boot error) can lose the lines still sitting in the
+     * queue. Unlike `shutdown()` this does not pause the queue, so it is safe
+     * to call at any point in the process lifetime.
+     * @returns {Promise<void>}
+     */
+    async flush() {
+        // The in-flight write owns the events it already spliced off the
+        // queue, so wait for it before queueing another write
+        await this._writing;
+
+        // A single write only takes the events present when it started, and
+        // anything pushed while it ran is not picked up until the next push
+        while (!this._paused && this._events.length) {
+            this.flushToDisk();
+            await this._writing;
+        }
+    }
+
     async pause() {
         this._paused = true;
         await this._writing;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryghost/bunyan-rotating-filestream",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "license": "MIT",
   "author": "Ghost Foundation",
   "repository": {