ConsoleLogAppender logs TRACE messages with console.log

console.trace generates and prints a full stacktrace for every log
message. This is not what TRACE means in this library. The TRACE level
is intended for logs that are more verbose than you typically want to
log and should only be turned on when you are trying to trace the
detailed behavior of the logged functionality. Printing the full stack
trace with every message makes an already verbose setting exponentially
worse.

mise.toml

@@ -0,0 +1,3 @@
+[tools]
+node = "latest"
+deno = "none"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jdbernard/logging",
-  "version": "2.2.0",
+  "version": "2.3.3",
   "description": "Simple Javascript logging service.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/api-log-appender.ts

@@ -1,32 +1,32 @@
-import { LogMessage, LogLevel, flattenMessage, FlattenedLogMessage } from './log-message';
-import { LogAppender } from './log-appender';
+import { LogMessage, LogLevel, flattenMessage, FlattenedLogMessage } from './log-message'
+import { LogAppender } from './log-appender'
 
 export class ApiLogAppender implements LogAppender {
-  public batchSize = 10;
-  public minimumTimePassedInSec = 60;
-  public maximumTimePassedInSec = 120;
-  public threshold = LogLevel.ALL;
+  public batchSize = 10
+  public minimumTimePassedInSec = 60
+  public maximumTimePassedInSec = 120
+  public threshold = LogLevel.ALL
 
-  private msgBuffer: FlattenedLogMessage[] = [];
-  private lastSent = 0;
+  private msgBuffer: FlattenedLogMessage[] = []
+  private lastSent = 0
 
   constructor(
     public readonly apiEndpoint: string,
     public authToken?: string,
     threshold?: LogLevel
   ) {
-    setTimeout(this.checkPost, 1000);
+    setTimeout(this.checkPost, 1000)
     if (threshold) {
-      this.threshold = threshold;
+      this.threshold = threshold
     }
   }
 
   public appendMessage(msg: LogMessage): void {
     if (this.threshold && msg.level < this.threshold) {
-      return;
+      return
     }
 
-    this.msgBuffer.push(flattenMessage(msg));
+    this.msgBuffer.push(flattenMessage(msg))
   }
 
   private doPost() {
@@ -39,29 +39,29 @@ export class ApiLogAppender implements LogAppender {
           'Content-Type': 'application/json',
           Authorization: `Bearer ${this.authToken}`
         }
-      });
+      })
 
-      this.lastSent = Date.now();
-      this.msgBuffer = [];
+      this.lastSent = Date.now()
+      this.msgBuffer = []
     }
   }
 
   private checkPost = () => {
-    const now = Date.now();
-    const min = this.lastSent + this.minimumTimePassedInSec * 1000;
-    const max = this.lastSent + this.maximumTimePassedInSec * 1000;
+    const now = Date.now()
+    const min = this.lastSent + this.minimumTimePassedInSec * 1000
+    const max = this.lastSent + this.maximumTimePassedInSec * 1000
 
     if (
       (this.msgBuffer.length >= this.batchSize && min < now) ||
       (this.msgBuffer.length > 0 && max < now)
     ) {
-      this.doPost();
+      this.doPost()
     }
     setTimeout(
       this.checkPost,
       Math.max(10000, this.minimumTimePassedInSec * 1000)
-    );
-  };
+    )
+  }
 }
 
-export default ApiLogAppender;
+export default ApiLogAppender

src/console-log-appender.ts

@@ -3,8 +3,8 @@ import {
   LogLevel,
   LogMessage,
   LogMessageFormatter,
-} from "./log-message";
-import { LogAppender } from "./log-appender";
+} from './log-message'
+import { LogAppender } from './log-appender'
 
 /**
  * A log appender that writes log messages to the console. The behavior of the
@@ -18,66 +18,70 @@ import { LogAppender } from "./log-appender";
  * data for inspection in the browser's developer tools.
  */
 export class ConsoleLogAppender implements LogAppender {
-  public threshold = LogLevel.ALL;
-  public formatter: LogMessageFormatter = flattenMessage;
+  public threshold = LogLevel.ALL
+  public formatter: LogMessageFormatter = flattenMessage
 
   constructor(threshold?: LogLevel, formatter?: LogMessageFormatter) {
     if (threshold) {
-      this.threshold = threshold;
+      this.threshold = threshold
     }
     if (formatter) {
-      this.formatter = formatter;
+      this.formatter = formatter
     }
   }
 
   public appendMessage(msg: LogMessage): void {
     if (this.threshold && msg.level < this.threshold) {
-      return;
+      return
     }
 
-    let logMethod = console.log;
+    let logMethod = console.log
     switch (msg.level) {
       case LogLevel.ALL:
       case LogLevel.TRACE:
       case LogLevel.LOG:
-        logMethod = console.log;
-        break;
+        // console.trace generates and prints a stack trace attached to the
+        // logged message. This is not really what we want for TRACE level
+        // messages as it just makes things more verbose needlessly, so these
+        // all log to console.log
+        logMethod = console.log
+        break
       case LogLevel.DEBUG:
-        logMethod = console.debug;
-        break;
+        logMethod = console.debug
+        break
       case LogLevel.INFO:
-        logMethod = console.info;
-        break;
+        logMethod = console.info
+        break
       case LogLevel.WARN:
-        logMethod = console.warn;
-        break;
+        logMethod = console.warn
+        break
       case LogLevel.ERROR:
       case LogLevel.FATAL:
-        logMethod = console.trace;
-        break;
+        logMethod = console.error
+        break
     }
 
-    const fmtMsg = this.formatter(msg);
+    const fmtMsg = this.formatter(msg)
 
-    if (typeof fmtMsg === "string") {
+    if (typeof fmtMsg === 'string') {
       if (msg.err || msg.stacktrace) {
-        logMethod(fmtMsg, msg.err ?? msg.stacktrace);
+        logMethod(fmtMsg, msg.err ?? msg.stacktrace)
       } else {
-        logMethod(fmtMsg);
+        logMethod(fmtMsg)
       }
     } else {
-      const { message, _err, _stacktrace, ...rest } = fmtMsg;
+      const { msg: innerMsg, _err, _stacktrace, ...rest } = fmtMsg
       const summary = `${LogLevel[msg.level]} -- ${msg.scope}: ${
-        message ?? fmtMsg.method
-      }\n`;
+        innerMsg ?? fmtMsg.method
+      }\n`
 
       if (msg.err || msg.stacktrace) {
-        logMethod(summary, msg.err ?? msg.stacktrace, rest);
+        logMethod(summary, msg.err ?? msg.stacktrace, rest)
       } else {
-        logMethod(summary, rest);
+        logMethod(summary, rest)
       }
     }
   }
 }
 
-export default ConsoleLogAppender;
+export default ConsoleLogAppender

src/index.ts

@@ -1,6 +1,6 @@
-export * from './log-message';
-export * from './log-appender';
-export * from './log-service';
-export * from './console-log-appender';
-export * from './api-log-appender';
-export * from './logger';
+export * from './log-message'
+export * from './log-appender'
+export * from './log-service'
+export * from './console-log-appender'
+export * from './api-log-appender'
+export * from './logger'

src/log-appender.ts

@@ -1,8 +1,8 @@
-import { LogLevel, LogMessage } from './log-message';
+import { LogLevel, LogMessage } from './log-message'
 
 export interface LogAppender {
   threshold: LogLevel;
   appendMessage(message: LogMessage): void;
 }
 
-export default LogAppender;
+export default LogAppender

src/log-message.ts

@@ -1,4 +1,4 @@
-import { omit } from "./util";
+import { omit } from './util'
 
 export enum LogLevel {
   ALL = 0,
@@ -16,9 +16,9 @@ export function parseLogLevel(
   defaultLevel = LogLevel.INFO,
 ): LogLevel {
   if (str in LogLevel) {
-    return LogLevel[str as keyof typeof LogLevel] as LogLevel;
+    return LogLevel[str as keyof typeof LogLevel] as LogLevel
   } else {
-    return defaultLevel;
+    return defaultLevel
   }
 }
 
@@ -34,12 +34,15 @@ export interface LogMessage {
 export type FlattenedLogMessage = Record<string, unknown>;
 
 /**
- * Flatten a log message to a plain object. The *message* field can be either a
- * string or an object. In the case of an object message, the LogMessage should
- * be flattened before being emitted by an appender, promoting the object's
- * fields to the top level of the message. Fields defined on the *LogMessage*
- * interface are reserved and should not be used as keys in the message object
- * (and will be ignored if they are).
+ * Flatten a log message to a plain object in preparation for emission to an
+ * appender.
+ *
+ * In general, the *message* field can be either a string or an object. In the
+ * case of an object message, the LogMessage should be flattened before being
+ * emitted by an appender, promoting the object's fields to the top level of
+ * the message. Fields defined on the *LogMessage* interface are reserved and
+ * should not be used as keys in the message object (and will be ignored if
+ * they are).
  *
  * So, for example:
  *
@@ -48,27 +51,27 @@ export type FlattenedLogMessage = Record<string, unknown>;
  * logger.info({ foo: 'bar', baz: 'qux', ts: 'today', level: LogLevel.WARN });
  * ```
  *
- * Should result after flattening in a structured log message like:
+ * Will result in a structured log message after flattening like:
  * ```json
  * {"scope":"example","level":"INFO","foo":"bar","baz":"qux","ts":"2020-01-01T00:00:00.000Z"}
  * ```
  */
 export function flattenMessage(logMsg: LogMessage): FlattenedLogMessage {
-  if (typeof logMsg.msg === "string") {
-    return { ...logMsg, level: LogLevel[logMsg.level] };
+  if (typeof logMsg.msg === 'string') {
+    return { ...logMsg, level: LogLevel[logMsg.level] }
   } else {
-    const { msg, ...rest } = logMsg;
+    const { msg, ...rest } = logMsg
     return {
       ...omit(msg, [
-        "scope",
-        "level",
-        "stacktrace",
-        "err",
-        "ts",
+        'scope',
+        'level',
+        'stacktrace',
+        'err',
+        'ts',
       ]),
       ...rest,
       level: LogLevel[logMsg.level],
-    };
+    }
   }
 }
 export type LogMessageFormatter = (
@@ -76,11 +79,11 @@ export type LogMessageFormatter = (
 ) => string | FlattenedLogMessage;
 
 export function structuredLogMessageFormatter(msg: LogMessage): string {
-  return JSON.stringify(flattenMessage(msg));
+  return JSON.stringify(flattenMessage(msg))
 }
 
 export function simpleTextLogMessageFormatter(msg: LogMessage): string {
-  return `[${msg.scope}] - ${msg.level}: ${msg.msg}`;
+  return `[${msg.scope}] - ${msg.level}: ${msg.msg}`
 }
 
-export default LogMessage;
+export default LogMessage

src/log-service.ts

@@ -1,7 +1,7 @@
-import { LogLevel } from './log-message';
-import { Logger } from './logger';
+import { LogLevel } from './log-message'
+import { Logger } from './logger'
 
-const ROOT_LOGGER_NAME = 'ROOT';
+const ROOT_LOGGER_NAME = 'ROOT'
 
 /**
  * Service for managing loggers. A LogService instance defines
@@ -10,19 +10,19 @@ const ROOT_LOGGER_NAME = 'ROOT';
  * module.
  */
 export class LogService {
-  private loggers: Record<string, Logger>;
+  private loggers: Record<string, Logger>
 
   public get ROOT_LOGGER() {
-    return this.loggers[ROOT_LOGGER_NAME];
+    return this.loggers[ROOT_LOGGER_NAME]
   }
 
   public constructor() {
-    this.loggers = {};
+    this.loggers = {}
     this.loggers[ROOT_LOGGER_NAME] = new Logger(
       ROOT_LOGGER_NAME,
       undefined,
       LogLevel.ALL,
-    );
+    )
   }
 
   /**
@@ -55,28 +55,28 @@ export class LogService {
    */
   public getLogger(name: string, threshold?: LogLevel): Logger {
     if (this.loggers[name]) {
-      return this.loggers[name];
+      return this.loggers[name]
     }
 
-    let parentLogger: Logger;
+    let parentLogger: Logger
 
     const parentLoggerName = Object.keys(this.loggers)
       .filter((n: string) => name.startsWith(n))
       .reduce(
         (acc: string, cur: string) => (acc.length > cur.length ? acc : cur),
         '',
-      );
+      )
 
     if (parentLoggerName) {
-      parentLogger = this.loggers[parentLoggerName];
+      parentLogger = this.loggers[parentLoggerName]
     } else {
-      parentLogger = this.ROOT_LOGGER;
+      parentLogger = this.ROOT_LOGGER
     }
 
-    this.loggers[name] = parentLogger.createChildLogger(name, threshold);
-    return this.loggers[name];
+    this.loggers[name] = parentLogger.createChildLogger(name, threshold)
+    return this.loggers[name]
   }
 }
 
-export const logService = new LogService();
-export default logService;
+export const logService = new LogService()
+export default logService

src/logger.ts

@@ -1,11 +1,11 @@
-import { LogLevel, LogMessage } from './log-message';
-import { LogAppender } from './log-appender';
+import { LogLevel, LogMessage } from './log-message'
+import { LogAppender } from './log-appender'
 
 export type DeferredMsg = () => string | Record<string, unknown>;
 export type MessageType = string | DeferredMsg | Record<string, unknown>;
 
 export function isDeferredMsg(msg: MessageType): msg is DeferredMsg {
-  return typeof msg === 'function';
+  return typeof msg === 'function'
 }
 
 /**
@@ -41,7 +41,7 @@ export function isDeferredMsg(msg: MessageType): msg is DeferredMsg {
  * For more details, see *LogService#getLogger*.
  */
 export class Logger {
-  public appenders: LogAppender[] = [];
+  public appenders: LogAppender[] = []
 
   public constructor(
     public readonly name: string,
@@ -50,7 +50,7 @@ export class Logger {
   ) {}
 
   public createChildLogger(name: string, threshold?: LogLevel): Logger {
-    return new Logger(name, this, threshold);
+    return new Logger(name, this, threshold)
   }
 
   public doLog(
@@ -59,7 +59,7 @@ export class Logger {
     stacktrace?: string,
   ): void {
     if (level < this.getEffectiveThreshold()) {
-      return;
+      return
     }
 
     const logMsg: LogMessage = {
@@ -68,77 +68,77 @@ export class Logger {
       msg: '',
       stacktrace: '',
       ts: new Date(),
-    };
-
-    if (msg === undefined || msg === null) {
-      logMsg.msg = msg;
-      logMsg.stacktrace = stacktrace ?? '';
-    } else if (msg instanceof Error) {
-      const err = msg as Error;
-      logMsg.err = err;
-      logMsg.msg = `${err.name}: ${err.message}`;
-      logMsg.stacktrace = stacktrace ?? err.stack ?? '';
-    } else if (isDeferredMsg(msg)) {
-      logMsg.msg = msg();
-      logMsg.stacktrace = stacktrace == null ? '' : stacktrace;
-    } else {
-      // string | object
-      logMsg.msg = msg;
-      logMsg.stacktrace = stacktrace == null ? '' : stacktrace;
     }
 
-    this.sendToAppenders(logMsg);
+    if (msg === undefined || msg === null) {
+      logMsg.msg = msg
+      logMsg.stacktrace = stacktrace ?? ''
+    } else if (msg instanceof Error) {
+      const err = msg as Error
+      logMsg.err = err
+      logMsg.msg = `${err.name}: ${err.message}`
+      logMsg.stacktrace = stacktrace ?? err.stack ?? ''
+    } else if (isDeferredMsg(msg)) {
+      logMsg.msg = msg()
+      logMsg.stacktrace = stacktrace == null ? '' : stacktrace
+    } else {
+      // string | object
+      logMsg.msg = msg
+      logMsg.stacktrace = stacktrace == null ? '' : stacktrace
+    }
+
+    this.sendToAppenders(logMsg)
   }
 
   public trace(msg: Error | MessageType, stacktrace?: string): void {
-    this.doLog(LogLevel.TRACE, msg, stacktrace);
+    this.doLog(LogLevel.TRACE, msg, stacktrace)
   }
 
   public debug(msg: Error | MessageType, stacktrace?: string): void {
-    this.doLog(LogLevel.DEBUG, msg, stacktrace);
+    this.doLog(LogLevel.DEBUG, msg, stacktrace)
   }
 
   public log(msg: MessageType, stacktrace?: string): void {
-    this.doLog(LogLevel.LOG, msg, stacktrace);
+    this.doLog(LogLevel.LOG, msg, stacktrace)
   }
 
   public info(msg: MessageType, stacktrace?: string): void {
-    this.doLog(LogLevel.INFO, msg, stacktrace);
+    this.doLog(LogLevel.INFO, msg, stacktrace)
   }
 
   public warn(msg: MessageType, stacktrace?: string): void {
-    this.doLog(LogLevel.WARN, msg, stacktrace);
+    this.doLog(LogLevel.WARN, msg, stacktrace)
   }
 
   public error(msg: Error | MessageType, stacktrace?: string): void {
-    this.doLog(LogLevel.ERROR, msg, stacktrace);
+    this.doLog(LogLevel.ERROR, msg, stacktrace)
   }
 
   public fatal(msg: Error | MessageType, stacktrace?: string): void {
-    this.doLog(LogLevel.FATAL, msg, stacktrace);
+    this.doLog(LogLevel.FATAL, msg, stacktrace)
   }
 
   protected sendToAppenders(logMsg: LogMessage) {
     this.appenders.forEach((app) => {
-      app.appendMessage(logMsg);
-    });
+      app.appendMessage(logMsg)
+    })
 
     if (this.parentLogger) {
-      this.parentLogger.sendToAppenders(logMsg);
+      this.parentLogger.sendToAppenders(logMsg)
     }
   }
 
   protected getEffectiveThreshold(): LogLevel {
     if (this.threshold) {
-      return this.threshold;
+      return this.threshold
     }
     if (this.parentLogger) {
-      return this.parentLogger.getEffectiveThreshold();
+      return this.parentLogger.getEffectiveThreshold()
     }
 
     // should never happen (root logger should always have a threshold
-    return LogLevel.ALL;
+    return LogLevel.ALL
   }
 }
 
-export default Logger;
+export default Logger

src/util.ts

@@ -2,11 +2,11 @@ export function omit(
   obj: Record<string, unknown>,
   keys: string[],
 ): Record<string, unknown> {
-  const result: Record<string, unknown> = {};
+  const result: Record<string, unknown> = {}
   for (const key in obj) {
     if (!keys.includes(key)) {
-      result[key] = obj[key];
+      result[key] = obj[key]
     }
   }
-  return result;
+  return result
 }