Support all native log levels

Author: curusarn

packages/bunyan/src/bunyan.test.ts

@@ -65,6 +65,10 @@ async function testLevel(
 }
 
 describe("Bunyan tests", () => {
+  it("should log at the 'trace' level", async done => {
+    return testLevel("trace", LogLevel.Trace, done);
+  });
+
   it("should log at the 'debug' level", async done => {
     return testLevel("debug", LogLevel.Debug, done);
   });
@@ -82,16 +86,18 @@ describe("Bunyan tests", () => {
   });
 
   it("should log at the 'fatal' level", async done => {
-    return testLevel("fatal", LogLevel.Error, done);
+    return testLevel("fatal", LogLevel.Fatal, done);
   });
 
   it("should log using number levels", async done => {
     // Fixtures
     const levels: LevelTest[] = [
-      [25, LogLevel.Debug, "debug"],
-      [35, LogLevel.Info, "info"],
-      [45, LogLevel.Warn, "warn"],
-      [55, LogLevel.Error, "error"]
+      [10, LogLevel.Trace, "trace"],
+      [20, LogLevel.Debug, "debug"],
+      [30, LogLevel.Info, "info"],
+      [40, LogLevel.Warn, "warn"],
+      [50, LogLevel.Error, "error"],
+      [60, LogLevel.Fatal, "fatal"]
     ];
 
     const logtail = new Logtail("test", {

packages/bunyan/src/bunyan.ts

@@ -47,13 +47,7 @@ export class LogtailStream extends Writable {
       .forEach(key => (meta[key] = log[key]));
 
     // Determine the log level
-    let level: LogLevel;
-
-    try {
-      level = getLogLevel(log.level);
-    } catch (_) {
-      return next();
-    }
+    const level = getLogLevel(log.level);
 
     // Log to Logtail
     void this._logtail.log(log.msg, level, meta, stackContextHint as StackContextHint);

packages/bunyan/src/helpers.ts

@@ -8,12 +8,11 @@ export function getLogLevel(level: number | string): LogLevel {
   // Are we dealing with a string log level?
   if (typeof level === "string") {
     switch (level.toLowerCase()) {
-      // Trace is ignored
-      case "trace":
-        throw new Error();
+      // Fatal
+      case "fatal":
+        return LogLevel.Fatal;
 
       // Error
-      case "fatal":
       case "error":
         return LogLevel.Error;
 
@@ -24,11 +23,16 @@ export function getLogLevel(level: number | string): LogLevel {
       // Debug
       case "debug":
         return LogLevel.Debug;
+
+      // Trace
+      case "trace":
+        return LogLevel.Trace;
+
     }
   } else if (typeof level === "number") {
-    // If level <=, consider it 'tracing' and move on
+    // Trace
     if (level <= 10) {
-      throw new Error();
+      return LogLevel.Trace;
     }
 
     // Debug
@@ -46,8 +50,13 @@ export function getLogLevel(level: number | string): LogLevel {
       return LogLevel.Warn;
     }
 
-    // Everything above this level is considered an error
-    return LogLevel.Error;
+    // Error
+    if (level <= 50) {
+      return LogLevel.Error;
+    }
+
+    // Everything above this level is considered fatal
+    return LogLevel.Fatal;
   }
 
   // By default, return info

packages/pino/src/helpers.ts

@@ -5,10 +5,9 @@ import { LogLevel } from "@logtail/types";
  * @param level number - Pino log level
  */
 export function getLogLevel(level: number): LogLevel {
-
-  // TODO: Trace 10
+  // Trace 10
   if (level <= 10) {
-    return LogLevel.Debug;
+    return LogLevel.Trace;
   }
 
   // Debug
@@ -26,7 +25,10 @@ export function getLogLevel(level: number): LogLevel {
     return LogLevel.Warn;
   }
 
-  // Everything above this level is considered an error
-  // TODO: Fatal 60 (Error 50)
-  return LogLevel.Error;
+  // Error
+  if (level <= 50) {
+    return LogLevel.Error;
+  }
+  // Everything above this level is considered fatal
+  return LogLevel.Fatal;
 }

packages/types/src/types.ts

@@ -47,10 +47,18 @@ export interface ILogtailOptions {
 }
 
 export enum LogLevel {
-  Debug = "debug",
-  Info = "info",
+  // core log levels - available as functions
+  Error = "error",
   Warn = "warn",
-  Error = "error"
+  Info = "info",
+  Debug = "debug",
+
+  // extra log levels - recognized when passed from logging frameworks
+  Fatal = "fatal",
+  Http = "http",
+  Verbose = "verbose",
+  Silly = "silly",
+  Trace = "trace",
 }
 
 /**

packages/winston/src/helpers.ts

@@ -0,0 +1,47 @@
+import {LogLevel} from "@logtail/types";
+
+/**
+ * Return a Logtail `LogLevel` based on the Winston level
+ * @param level string - Winston log level
+ */
+export function getLogLevel(level: string): LogLevel {
+    switch (level.toLowerCase()) {
+        // Fatal
+        case "fatal":
+            return LogLevel.Fatal;
+
+        // Error
+        case "error":
+            return LogLevel.Error;
+
+        // Warn
+        case "warn":
+            return LogLevel.Warn;
+
+        // Info
+        case "info":
+            return LogLevel.Info;
+
+        // Http
+        case "http":
+            return LogLevel.Http;
+
+        // Verbose
+        case "verbose":
+            return LogLevel.Verbose;
+
+        // Debug
+        case "debug":
+            return LogLevel.Debug;
+
+        // Silly
+        case "silly":
+            return LogLevel.Silly;
+
+        // Trace
+        case "trace":
+            return LogLevel.Trace;
+    }
+    // By default, return info
+    return LogLevel.Info;
+}

packages/winston/src/winston.test.ts

@@ -11,8 +11,9 @@ const message = "Something to do with something";
  * Test a Winston level vs. Logtail level
  * @param level - Winston log level
  * @param logLevel LogLevel - Logtail log level
+ * @param levels Use custom log levels
  */
-async function testLevel(level: string, logLevel: LogLevel) {
+async function testLevel(level: string, logLevel: LogLevel, levels?: {[key:string]: number}) {
   // Sample log
   const log: LogEntry = {
     level,
@@ -31,7 +32,9 @@ async function testLevel(level: string, logLevel: LogLevel) {
   // Create a Winston logger
   const logger = winston.createLogger({
     level,
-    transports: [new LogtailTransport(logtail)]
+    transports: [new LogtailTransport(logtail)],
+    // use custom levels if passed
+    levels: levels || winston.config.npm.levels,
   });
 
   // Log it!
@@ -45,29 +48,27 @@ async function testLevel(level: string, logLevel: LogLevel) {
   // Message should match
   expect(logs[0].message).toBe(log.message);
 
-  // Log level should be 'info'
+  // Log level should be 'logLevel'
   expect(logs[0].level).toBe(logLevel);
 }
 
 describe("Winston logging tests", () => {
-  it("should log at the 'debug' level", async () => {
-    return testLevel("debug", LogLevel.Debug);
-  });
-
-  it("should log at the 'info' level", async () => {
-    return testLevel("info", LogLevel.Info);
-  });
-
-  it("should log at the 'warn' level", async () => {
-    return testLevel("warn", LogLevel.Warn);
-  });
-
-  it("should log at the 'error' level", async () => {
-    return testLevel("error", LogLevel.Error);
-  });
+  const levels: { [key:string]: LogLevel } = {
+    "silly": LogLevel.Silly,
+    "debug": LogLevel.Debug,
+    "http": LogLevel.Http,
+    "verbose": LogLevel.Verbose,
+    "warn": LogLevel.Warn,
+    "error": LogLevel.Error,
+  };
+  for (const key in levels) {
+    it(`should log at the '${key}' level`, async () => {
+      return testLevel(key, levels[key]);
+    });
+  }
 
   it("should default to 'info' level when using custom logging", async () => {
-    return testLevel("silly", LogLevel.Info);
+    return testLevel("xyz", LogLevel.Info, { xyz: 42 });
   });
 
   it("should sync multiple logs", async done => {

packages/winston/src/winston.ts

@@ -3,6 +3,7 @@ import Transport from "winston-transport";
 
 import { Logtail } from "@logtail/node";
 import {LogLevel, StackContextHint} from "@logtail/types";
+import {getLogLevel} from "./helpers";
 
 const stackContextHint = { fileName: "node_modules/winston", methodNames: [ "log", "error", "warn", "info", "http", "verbose", "debug", "silly" ] };
 
@@ -20,25 +21,7 @@ export class LogtailTransport extends Transport {
     const { level, message, ...meta } = info;
 
     // Determine the log level
-    let logLevel: LogLevel;
-
-    switch (level) {
-      case "debug":
-        logLevel = LogLevel.Debug;
-        break;
-
-      case "warn":
-        logLevel = LogLevel.Warn;
-        break;
-
-      case "error":
-        logLevel = LogLevel.Error;
-        break;
-
-      // All other log levels use `Info` by default
-      default:
-        logLevel = LogLevel.Info;
-    }
+    const logLevel = getLogLevel(level);
 
     // Log out to Logtail
     void this._logtail.log(message, logLevel, meta, stackContextHint as StackContextHint);