Merge pull request #17 from acuminous/waitForTransports

Replace logger.drain with logger.waitForTransports

CHANGELOG.md

@@ -5,6 +5,10 @@ All notable changes to this project will be documented in this file.
 The format is based on Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 and this project adheres to Semantic Versioning](https://semver.org/spec/v2.0.0.html)
 
+## Unreleased
+
+- Replace logger.drain with logger.waitForTransports, which does not block subsequent messages from being logged
+
 ## 3.1.0
 
 - Add support for asynchronous transports via logger.drain

README.md

@@ -494,12 +494,12 @@ logger.info("How blissful it is, for one who has nothing", {
 
 ### Asynchronous Transports
 
-If one or more of the transports is asynchronous and you want to ensure all messages have been written before terminating your application, you must wait for the `logger.drain` method to yield. This method takes an optional timeout specified in milliseconds. e.g.
+If one or more of the transports is asynchronous and you want to ensure all messages have been written before terminating your application, you must wait for the `logger.waitForTransports` method to yield. This method takes an optional timeout specified in milliseconds. e.g.
 
 ```js
 process.once("SIGTERM", () => {
   logger
-    .drain(1000)
+    .waitForTransports(1000)
     .then(() => {
       process.exit();
     })
@@ -510,4 +510,4 @@ process.once("SIGTERM", () => {
 });
 ```
 
-Once you have called `logger.drain` any new logged messages will be suppressed without error and calling `logger.drain` repeatedly will yield the original promise.
+Once you have called `logger.waitForTransports` any subsequent messages will be still be accepted and will prevent the promise from resolving until they have been processed. If your application logs intensively `logger.waitForTransports` could therefore block indefinitely unless you specify a timeout.

index.d.ts

@@ -29,7 +29,7 @@ export class Logger {
   error(context: Error): void;
   enable(): void;
   disable(): void;
-  drain(timeout?: number): Promise<void>;
+  waitForTransports(timeout?: number): Promise<void>;
 }
 
 export const processors: {

lib/Logger.js

@@ -15,7 +15,6 @@ module.exports = class Logger {
     this._threshold = level;
     this._disabled = false;
     this._pendingTransports = new Set();
-    this._draining = null;
 
     Level.decorate(this);
   }
@@ -29,7 +28,7 @@ module.exports = class Logger {
   }
 
   log(level, ...args) {
-    if (this._draining || this._disabled || !level.satisfies(this._threshold)) return;
+    if (this._disabled || !level.satisfies(this._threshold)) return;
 
     let message;
     let ctx = {};
@@ -45,14 +44,12 @@ module.exports = class Logger {
     this._output({ level, record });
   }
 
-  drain(timeout) {
-    if (this._draining) return this._draining;
-
-    this._draining = new Promise((resolve, reject) => {
+  waitForTransports(timeout) {
+    return new Promise((resolve, reject) => {
       const timerId =
         timeout &&
         setTimeout(() => {
-          reject(new Error("Timedout waiting for logger to drain"));
+          reject(new Error("Timedout waiting for transports to finish"));
         });
       const waitUntilDrained = () => {
         if (this._pendingTransports.size > 0) return setTimeout(waitUntilDrained, 10).unref();
@@ -61,8 +58,6 @@ module.exports = class Logger {
       };
       waitUntilDrained();
     });
-
-    return this._draining;
   }
 
   _process({ level, message, ctx }) {

test/Logger.test.js

@@ -272,7 +272,7 @@ describe("Logger", () => {
     eq(streams[Level.INFO.name].lines.length, 4);
   });
 
-  it("should wait for asynchronous transports to drain", async () => {
+  it("should wait for asynchronous transports to finish", async () => {
     const testOutputStream = new TestOutputStream();
     const transport = ({ record }) => {
       return new Promise((resolve) => {
@@ -292,7 +292,7 @@ describe("Logger", () => {
 
     eq(testOutputStream.lines.length, 0);
 
-    await logger.drain();
+    await logger.waitForTransports();
 
     eq(testOutputStream.lines.length, 1);
   });
@@ -314,7 +314,7 @@ describe("Logger", () => {
     eq(testOutputStream.lines.length, 1);
   });
 
-  it("should timeout if asynchronous transports take too long to drain", async () => {
+  it("should timeout if asynchronous transports take too long to finish", async () => {
     let resolve;
     const transport = () => {
       return new Promise((_resolve) => {
@@ -329,16 +329,16 @@ describe("Logger", () => {
     logger.info("Tripitaka rocks!");
 
     await rejects(
-      () => logger.drain(100),
+      () => logger.waitForTransports(100),
       (err) => {
-        eq(err.message, "Timedout waiting for logger to drain");
+        eq(err.message, "Timedout waiting for transports to finish");
         resolve();
         return true;
       }
     );
   });
 
-  it("should not wait when messages have already drained", async () => {
+  it("should not wait when messages have already finished", async () => {
     const testOutputStream = new TestOutputStream();
     const transport = ({ record }) => {
       return new Promise((resolve) => {
@@ -357,13 +357,13 @@ describe("Logger", () => {
     eq(testOutputStream.lines.length, 1);
 
     const before = Date.now();
-    await logger.drain();
+    await logger.waitForTransports();
     const after = Date.now();
 
     ok(after - before <= 20);
   });
 
-  it("should not wait when there were never any messages", async () => {
+  it("should not wait for transports when there were never any messages", async () => {
     const testOutputStream = new TestOutputStream();
     const transport = ({ record }) => {
       return new Promise((resolve) => {
@@ -378,13 +378,13 @@ describe("Logger", () => {
     });
 
     const before = Date.now();
-    await logger.drain();
+    await logger.waitForTransports();
     const after = Date.now();
 
     ok(after - before <= 10);
   });
 
-  it("should suppress messages logged while draining", async () => {
+  it("should continue logging while waiting for transports to finish", async () => {
     const testOutputStream = new TestOutputStream();
     const transport = ({ record }) => {
       return new Promise((resolve) => {
@@ -402,16 +402,16 @@ describe("Logger", () => {
 
     logger.info("Tripitaka rocks!");
 
-    const drained = logger.drain();
+    const pendingTransports = logger.waitForTransports();
 
     logger.info("Tripitaka sucks!");
 
-    await drained;
+    await pendingTransports;
 
-    eq(testOutputStream.lines.length, 1);
+    eq(testOutputStream.lines.length, 2);
   });
 
-  it("should tollerate repeated requests to drain", async () => {
+  it("should tollerate repeated requests to wait for transports", async () => {
     const testOutputStream = new TestOutputStream();
     const transport = ({ record }) => {
       return new Promise((resolve) => {
@@ -429,8 +429,14 @@ describe("Logger", () => {
 
     logger.info("Tripitaka rocks!");
 
-    await Promise.all(new Array(10).fill().map(() => logger.drain()));
+    const pendingTransports1 = logger.waitForTransports();
 
-    eq(testOutputStream.lines.length, 1);
+    logger.info("Tripitaka rocks!");
+
+    const pendingTransports2 = logger.waitForTransports();
+
+    await Promise.all([pendingTransports1, pendingTransports2]);
+
+    eq(testOutputStream.lines.length, 2);
   });
 });