@bitblit/ratchet-common 6.0.145-alpha → 6.0.147-alpha

package/src/logger/logger-instance.ts

@@ -0,0 +1,269 @@
+import { LogMessage } from './log-message.js';
+import { LoggerOptions } from './logger-options.js';
+import { LoggerRingBuffer } from './logger-ring-buffer.js';
+import { LoggerLevelName } from './logger-level-name.js';
+import { LoggerUtil } from './logger-util.js';
+import { LogMessageFormatter } from './log-message-formatter.js';
+import { LogMessageFormatType } from './log-message-format-type.js';
+import { ClassicSingleLineLogMessageFormatter } from './classic-single-line-log-message-formatter.js';
+import { NoneLogMessageFormatter } from './none-log-message-formatter.js';
+import { StructuredJsonLogMessageFormatter } from './structured-json-log-message-formatter.js';
+import { LogMessageBuilder } from './log-message-builder.js';
+import { LogMessageProcessor } from './log-message-processor.js';
+import { StringRatchet } from '../lang/string-ratchet.js';
+import { LoggerMeta } from './logger-meta.js';
+import { SingleLineNoLevelLogMessageFormatter } from './single-line-no-level-log-message-formatter.js';
+
+export class LoggerInstance {
+  private _guid: number = Math.floor(Math.random() * 1_000_000);
+  private _loggerMeta: LoggerMeta;
+
+  private _ringBuffer: LoggerRingBuffer;
+  private _formatter: LogMessageFormatter;
+  private _level: LoggerLevelName;
+  private _handlerFunctionMap: Map<LoggerLevelName, (...any) => void>;
+  private _options: LoggerOptions;
+
+  constructor(
+    private loggerInstanceName = 'default',
+    inOptions: LoggerOptions,
+  ) {
+    this.options = inOptions; // MUST use the setter here
+  }
+
+  public levelIsEnabled(level: LoggerLevelName): boolean {
+    return LoggerUtil.levelIsEnabled(level, this._level);
+  }
+
+  public addPreProcessor(proc: LogMessageProcessor): LogMessageProcessor[] {
+    if (proc) {
+      this._options.preProcessors = this._options.preProcessors || [];
+      this._options.preProcessors.push(proc);
+    }
+    return Object.assign([], this._options.preProcessors);
+  }
+
+  public get ringBuffer(): LoggerRingBuffer {
+    return this._ringBuffer;
+  }
+
+  public dumpConfigurationIntoLog(): void {
+    this.error('ERROR enabled');
+    this.warn('WARN enabled');
+    this.info('INFO enabled');
+    this.verbose('VERBOSE enabled');
+    this.debug('DEBUG enabled');
+    this.silly('SILLY enabled');
+  }
+
+  public dumpOptionsIntoLog(): void {
+    this.info('Guid: %s Options: %j', this._guid, this.options);
+    if (this?.options?.preProcessors?.length) {
+      const labels: string[] = this.options.preProcessors.map((p) => StringRatchet.trimToNull(p.label()) || 'Unlabelled');
+      this.info('Preprocessors: %j', labels);
+    }
+  }
+
+  public get guid(): number {
+    return this._guid;
+  }
+
+  // This will always clear the buffer
+  public changeRingBufferSize(newSize: number): void {
+    this._ringBuffer = null;
+    if (newSize) {
+      this._ringBuffer = new LoggerRingBuffer(newSize);
+      this._options.ringBufferSize = newSize;
+    }
+  }
+
+  public updateTracePrefix(newValue: string): void {
+    this._options.trace = newValue;
+  }
+
+  public get options(): LoggerOptions {
+    return Object.assign({}, this._options);
+  }
+
+  public set options(newOpts: LoggerOptions) {
+    this._options = Object.assign({}, newOpts);
+    if (this._options.ringBufferSize) {
+      this._ringBuffer = new LoggerRingBuffer(this._options.ringBufferSize);
+    }
+    // Setup the formatter
+    switch (this._options.formatType) {
+      case LogMessageFormatType.None:
+        this._formatter = new NoneLogMessageFormatter();
+        break;
+      case LogMessageFormatType.StructuredJson:
+        this._formatter = new StructuredJsonLogMessageFormatter();
+        break;
+      case LogMessageFormatType.SingleLineNoLevel:
+        this._formatter = new SingleLineNoLevelLogMessageFormatter();
+        break;
+      default:
+        this._formatter = new ClassicSingleLineLogMessageFormatter();
+        break;
+    }
+    this._level = this._options.initialLevel;
+    this._handlerFunctionMap = LoggerUtil.handlerFunctionMap(this._options.outputFunction);
+
+    const oldId: string = this._loggerMeta ? this._loggerMeta.loggerInstanceId : null;
+    this._loggerMeta = {
+      options: this._options,
+      loggerInstanceName: this.loggerInstanceName,
+      loggerInstanceId: oldId || StringRatchet.createRandomHexString(8),
+    };
+  }
+
+  public get level(): LoggerLevelName {
+    return this._level;
+  }
+
+  public set level(newLevel: LoggerLevelName) {
+    if (!newLevel) {
+      throw new Error('Cannot set level to null/undefined');
+    }
+    this._level = newLevel;
+  }
+
+  public consoleLogPassThru(level: LoggerLevelName, ...input: any[]): void {
+    if (LoggerUtil.levelIsEnabled(level, this._level)) {
+      let passThruPrefix: string = this._options.trace || '';
+      passThruPrefix += '[' + level + '] ';
+      input.unshift(passThruPrefix);
+      const fn: (...any) => void = this._handlerFunctionMap.get(level) || LoggerUtil.defaultHandlerFunction;
+      fn(...input);
+    }
+  }
+
+  public createLogMessage(level: LoggerLevelName, params: Record<string, string>, format: string, ...input: any[]): LogMessage {
+    const rval: LogMessage = {
+      lvl: level,
+      timestamp: Date.now(),
+      messageSource: format,
+      subsVars: input,
+      params: params,
+    };
+    return rval;
+  }
+
+  public formatMessage(msg: LogMessage): string {
+    const rval: string = msg ? this._formatter.formatMessage(msg, this._loggerMeta) : null;
+    return rval;
+  }
+
+  public formatMessages(msgs: LogMessage[]): string[] {
+    const rval: string[] = (msgs || []).map((m) => this.formatMessage(m)).filter((m) => !!m);
+    return rval;
+  }
+
+  public recordMessageBuilder(msgBuild: LogMessageBuilder): string {
+    return this.recordMessage(msgBuild.toMessage());
+  }
+
+  public recordMessage(inMsg: LogMessage): string {
+    let rval: string = null;
+    if (LoggerUtil.levelIsEnabled(inMsg.lvl, this._level)) {
+      let msg: LogMessage = Object.assign({}, inMsg);
+      // If there are any preprocessors, run them
+      if (this._options.preProcessors?.length) {
+        for (const proc of this._options.preProcessors) {
+          msg = proc.process(msg);
+        }
+      }
+      // Now, generate the actual string to log
+      rval = this.formatMessage(msg);
+      if (rval) {
+        const fn: (...any) => void = this._handlerFunctionMap.get(msg.lvl) || LoggerUtil.defaultHandlerFunction;
+        fn(rval);
+        if (this._ringBuffer) {
+          this._ringBuffer.addToRingBuffer(msg);
+        }
+      }
+    } else {
+      // Do nothing, not enabled
+    }
+    return rval;
+  }
+
+  public error(format: string, ...input: any[]): string {
+    const msg: LogMessage = this.createLogMessage(LoggerLevelName.error, {}, format, ...input);
+    return this.recordMessage(msg);
+  }
+
+  public errorP(...input: any[]): void {
+    this.consoleLogPassThru(LoggerLevelName.error, ...input);
+  }
+
+  public warn(format: string, ...input: any[]): string {
+    const msg: LogMessage = this.createLogMessage(LoggerLevelName.warn, {}, format, ...input);
+    return this.recordMessage(msg);
+  }
+
+  public warnP(...input: any[]): void {
+    this.consoleLogPassThru(LoggerLevelName.warn, ...input);
+  }
+
+  public info(format: string, ...input: any[]): string {
+    const msg: LogMessage = this.createLogMessage(LoggerLevelName.info, {}, format, ...input);
+    return this.recordMessage(msg);
+  }
+
+  public infoP(...input: any[]): void {
+    this.consoleLogPassThru(LoggerLevelName.info, ...input);
+  }
+
+  public verbose(format: string, ...input: any[]): string {
+    const msg: LogMessage = this.createLogMessage(LoggerLevelName.verbose, {}, format, ...input);
+    return this.recordMessage(msg);
+  }
+
+  public verboseP(...input: any[]): void {
+    this.consoleLogPassThru(LoggerLevelName.verbose, ...input);
+  }
+
+  public debug(format: string, ...input: any[]): string {
+    const msg: LogMessage = this.createLogMessage(LoggerLevelName.debug, {}, format, ...input);
+    return this.recordMessage(msg);
+  }
+
+  public debugP(...input: any[]): void {
+    // This is here because old versions of Node do not support console.debug
+    this.consoleLogPassThru(LoggerLevelName.debug, ...input);
+  }
+
+  public silly(format: string, ...input: any[]): string {
+    const msg: LogMessage = this.createLogMessage(LoggerLevelName.silly, {}, format, ...input);
+    return this.recordMessage(msg);
+  }
+
+  public sillyP(...input: any[]): void {
+    this.consoleLogPassThru(LoggerLevelName.silly, ...input);
+  }
+
+  public logByLevel(level: LoggerLevelName, format: string, ...input: any[]): void {
+    const msg: LogMessage = this.createLogMessage(level, {}, format, ...input);
+    this.recordMessage(msg);
+  }
+
+  public importMessages(msgs: LogMessage[], prefixIn = '', addTimestamp = true): void {
+    const prefix: string = prefixIn || '';
+    if (msgs && msgs.length > 0) {
+      this.silly('Received import data : %d msgs', msgs.length);
+
+      // Pump messages
+      msgs.forEach((m) => {
+        if (m.messageSource) {
+          let mOut: string = prefix;
+          if (addTimestamp) {
+            const ts: string = String(new Date()).substring(15, 24);
+            mOut += ' (' + ts + ') : ';
+            mOut += m.messageSource;
+          }
+          this.logByLevel(m.lvl, mOut);
+        }
+      });
+    }
+  }
+}

package/src/logger/logger-level-name.ts

@@ -0,0 +1,11 @@
+// NOTE: This is a psuedo-enum to fix some issues with Typescript enums.  See: https://exploringjs.com/tackling-ts/ch_enum-alternatives.html for details
+
+export const LoggerLevelName = {
+  error: 'error',
+  warn: 'warn',
+  info: 'info',
+  verbose: 'verbose',
+  debug: 'debug',
+  silly: 'silly',
+} as const;
+export type LoggerLevelName = (typeof LoggerLevelName)[keyof typeof LoggerLevelName];

package/src/logger/logger-meta.ts

@@ -0,0 +1,7 @@
+import { LoggerOptions } from './logger-options.js';
+
+export interface LoggerMeta {
+  options: LoggerOptions;
+  loggerInstanceName: string;
+  loggerInstanceId: string;
+}

package/src/logger/logger-options.ts

@@ -0,0 +1,14 @@
+import { LogMessageFormatType } from './log-message-format-type.js';
+import { LoggerLevelName } from './logger-level-name.js';
+import { LogMessageProcessor } from './log-message-processor.js';
+import { LoggerOutputFunction } from './logger-output-function.js';
+
+export interface LoggerOptions {
+  initialLevel?: LoggerLevelName;
+  formatType?: LogMessageFormatType;
+  trace?: string;
+  globalVars?: Record<string, string | number | boolean>;
+  outputFunction?: LoggerOutputFunction;
+  ringBufferSize?: number;
+  preProcessors?: LogMessageProcessor[];
+}

package/src/logger/logger-output-function.ts

@@ -0,0 +1,10 @@
+// NOTE: This is a psuedo-enum to fix some issues with Typescript enums.  See: https://exploringjs.com/tackling-ts/ch_enum-alternatives.html for details
+
+export const LoggerOutputFunction = {
+  Console: 'Console',
+  ConsoleNoDebug: 'ConsoleNoDebug',
+  StdOut: 'StdOut',
+  Disabled: 'Disabled',
+};
+
+export type LoggerOutputFunction = (typeof LoggerOutputFunction)[keyof typeof LoggerOutputFunction];

package/src/logger/logger-ring-buffer.ts

@@ -0,0 +1,89 @@
+import { LogMessage } from './log-message.js';
+import { LogSnapshot } from './log-snapshot.js';
+import { LoggerLevelName } from './logger-level-name.js';
+
+export class LoggerRingBuffer {
+  private _lastLogMessage: LogMessage = { messageSource: 'No message yet', timestamp: new Date().getTime(), lvl: LoggerLevelName.info };
+
+  private _buffer: LogMessage[] = [];
+  private _bufferIdx = 0;
+  private _lastSnapshotIdx = 0;
+  private _bufferSize: number;
+
+  constructor(size: number) {
+    if (!size) {
+      throw new Error('Cannot create ring buffer of size 0');
+    }
+    this._bufferSize = size;
+  }
+
+  public get currentIndex(): number {
+    return this._bufferIdx;
+  }
+
+  public get lastSnapshotIdx(): number {
+    return this._lastSnapshotIdx;
+  }
+
+  public set bufferSize(newSize: number) {
+    if (!newSize) {
+      throw new Error('Cannot create ring buffer of size 0');
+    }
+    this._bufferSize = newSize;
+    this.clearRingBuffer();
+  }
+
+  public getMessages(inStartFrom: number = null, clear = false, reverseSort = false): LogMessage[] {
+    let rval: LogMessage[] = null;
+    if (this._bufferIdx < this._bufferSize) {
+      const start: number = inStartFrom == null ? 0 : inStartFrom;
+      rval = this._buffer.slice(start, this._bufferIdx); // Use slice to get a copy (should use below too)
+    } else {
+      rval = [];
+
+      const firstIdx = this._bufferIdx - this._bufferSize;
+      const startFrom = inStartFrom ? Math.max(inStartFrom, firstIdx) : firstIdx;
+
+      for (let i = startFrom; i < this._bufferIdx; i++) {
+        rval.push(this._buffer[i % this._bufferSize]);
+      }
+    }
+
+    if (clear) {
+      this.clearRingBuffer();
+    }
+
+    if (reverseSort) {
+      rval = rval.reverse();
+    }
+
+    return rval;
+  }
+
+  public takeSnapshot(): LogSnapshot {
+    const trailingEdge = Math.max(0, this._bufferIdx - this._bufferSize);
+    const rval: LogSnapshot = {
+      messages: this.getMessages(this._lastSnapshotIdx),
+      logMessagesTruncated: Math.max(0, trailingEdge - this._lastSnapshotIdx),
+    } as LogSnapshot;
+
+    this._lastSnapshotIdx = this._bufferIdx;
+    return rval;
+  }
+
+  public getLastLogMessage(): LogMessage {
+    return Object.assign({}, this._lastLogMessage);
+  }
+
+  private clearRingBuffer() {
+    this._buffer = [];
+    this._bufferIdx = 0;
+    this._lastSnapshotIdx = 0;
+  }
+
+  public addToRingBuffer(newMsg: LogMessage): void {
+    this._lastLogMessage = newMsg;
+    this._buffer[this._bufferIdx % this._bufferSize] = newMsg;
+    this._bufferIdx++; // advance
+  }
+}

package/src/logger/logger-util.spec.ts

@@ -0,0 +1,11 @@
+import { LoggerUtil } from './logger-util.js';
+import { LoggerLevelName } from './logger-level-name.js';
+import { describe, expect, test } from 'vitest';
+
+describe('#checkLevel', function () {
+  test('should check that level logging works', function () {
+    expect(LoggerUtil.levelIsEnabled(LoggerLevelName.info, LoggerLevelName.warn)).toEqual(false);
+    expect(LoggerUtil.levelIsEnabled(LoggerLevelName.warn, LoggerLevelName.info)).toEqual(true);
+    expect(LoggerUtil.levelIsEnabled(LoggerLevelName.warn, LoggerLevelName.warn)).toEqual(true);
+  });
+});

package/src/logger/logger-util.ts

@@ -0,0 +1,68 @@
+import { LoggerLevelName } from './logger-level-name.js';
+import { LoggerOutputFunction } from './logger-output-function.js';
+
+export class LoggerUtil {
+  private static LOG_LEVELS_IN_ORDER: LoggerLevelName[] = [
+    LoggerLevelName.error,
+    LoggerLevelName.warn,
+    LoggerLevelName.info,
+    LoggerLevelName.verbose,
+    LoggerLevelName.debug,
+    LoggerLevelName.silly,
+  ];
+
+  public static handlerFunctionMap(outputFn: LoggerOutputFunction = LoggerOutputFunction.Console): Map<LoggerLevelName, (...any) => void> {
+    const output: Map<LoggerLevelName, (...any) => void> = new Map<LoggerLevelName, (...any) => void>();
+    if (outputFn === LoggerOutputFunction.Disabled) {
+      // Disables ALL logger functionality
+      const disabled: (...any) => void = (_chunk, _cb) => {
+        /*do nothing*/
+      };
+      output.set(LoggerLevelName.error, disabled);
+      output.set(LoggerLevelName.warn, disabled);
+      output.set(LoggerLevelName.info, disabled);
+      output.set(LoggerLevelName.verbose, disabled);
+      output.set(LoggerLevelName.debug, disabled);
+      output.set(LoggerLevelName.silly, disabled);
+    } else if (outputFn === LoggerOutputFunction.StdOut) {
+      if (!process?.stdout?.write) {
+        throw new Error('Cannot use standard out - process.stdout.write not found');
+      }
+      // Have to do this because process.stdout.write refers to 'this'
+      // See: https://github.com/nodejs/node-v0.x-archive/issues/7980
+      const myStdOut: (...any) => void = (chunk, cb) => process.stdout.write(chunk, 'utf-8', cb);
+      output.set(LoggerLevelName.error, myStdOut);
+      output.set(LoggerLevelName.warn, myStdOut);
+      output.set(LoggerLevelName.info, myStdOut);
+      output.set(LoggerLevelName.verbose, myStdOut);
+      output.set(LoggerLevelName.debug, myStdOut);
+      output.set(LoggerLevelName.silly, myStdOut);
+    } else {
+      output.set(LoggerLevelName.error, console.error);
+      output.set(LoggerLevelName.warn, console.warn);
+      output.set(LoggerLevelName.info, console.info);
+      output.set(LoggerLevelName.verbose, outputFn === LoggerOutputFunction.ConsoleNoDebug ? console.log : console.debug);
+      output.set(LoggerLevelName.debug, outputFn === LoggerOutputFunction.ConsoleNoDebug ? console.log : console.debug);
+      output.set(LoggerLevelName.silly, outputFn === LoggerOutputFunction.ConsoleNoDebug ? console.log : console.debug);
+    }
+    return output;
+  }
+
+  public static defaultHandlerFunction(): (...any) => void {
+    return console.info;
+  }
+
+  public static levelIsEnabled(targetLevel: LoggerLevelName, currentEnabled: LoggerLevelName): boolean {
+    const idxTarget: number = LoggerUtil.loggerLevelIndex(targetLevel);
+    const lvl: number = LoggerUtil.loggerLevelIndex(currentEnabled);
+    return idxTarget > -1 && lvl > -1 && lvl >= idxTarget;
+  }
+
+  public static loggerLevelIndex(targetLevel: LoggerLevelName): number {
+    return LoggerUtil.LOG_LEVELS_IN_ORDER.indexOf(targetLevel);
+  }
+
+  public static indexToLevel(idx: number): LoggerLevelName {
+    return idx >= 0 && idx < LoggerUtil.LOG_LEVELS_IN_ORDER.length ? LoggerUtil.LOG_LEVELS_IN_ORDER[idx] : null;
+  }
+}

package/src/logger/logger.spec.ts

@@ -0,0 +1,177 @@
+import { Logger } from './logger.js';
+import { LogSnapshot } from './log-snapshot.js';
+import { LogMessage } from './log-message.js';
+import { LoggerLevelName } from './logger-level-name.js';
+import { LogMessageProcessor } from './log-message-processor.js';
+import { StringRatchet } from '../lang/string-ratchet.js';
+import { LogMessageBuilder } from './log-message-builder.js';
+import { LogMessageFormatType } from './log-message-format-type.js';
+import { LoggerOutputFunction } from './logger-output-function.js';
+import { describe, expect, test } from 'vitest';
+
+describe('#setLevel', function () {
+  test('should change the level to debug then info then debug', function () {
+    Logger.dumpConfigurationIntoLog();
+    //console.log("Start Level : "+Logger.getLevel());
+    expect(Logger.getLevel()).toEqual(LoggerLevelName.info);
+    // Should start at default level
+    Logger.setLevel(LoggerLevelName.debug);
+    expect(Logger.getLevel()).toEqual(LoggerLevelName.debug);
+    Logger.setLevel(LoggerLevelName.info);
+    expect(Logger.getLevel()).toEqual(LoggerLevelName.info);
+    //Logger.debug("This should NOT get written, as I am at info level");
+    //Logger.info("This should get written, as I am at info level");
+    //Logger.logByLevel('info', "Write at info level");
+    //Logger.info("Write also at info level");
+    Logger.setLevel(LoggerLevelName.debug);
+    expect(Logger.getLevel()).toEqual(LoggerLevelName.debug);
+  });
+});
+
+describe('#takeSnapshot', function () {
+  test('should advance the pointer correctly after a snapshot', function () {
+    Logger.changeRingBufferSize(5);
+    expect(Logger.getRingBuffer().currentIndex).toEqual(0);
+
+    Logger.info('m1');
+    Logger.info('m2');
+    Logger.info('m3');
+
+    const snap1: LogSnapshot = Logger.takeSnapshot();
+    Logger.info('m4');
+    Logger.info('m5');
+    const snap2: LogSnapshot = Logger.takeSnapshot();
+
+    Logger.info('m6');
+    Logger.info('m7');
+    Logger.info('m8');
+
+    const snap3: LogSnapshot = Logger.takeSnapshot();
+
+    expect(snap1.messages.length).toEqual(3);
+    expect(snap2.messages.length).toEqual(2);
+    expect(snap3.messages.length).toEqual(3);
+
+    expect(Logger.getRingBuffer().currentIndex).toEqual(8);
+  });
+});
+
+describe('#testTracePrefix', function () {
+  test('should apply a trace prefix correctly', function () {
+    Logger.updateTracePrefix('::TRACE::');
+    Logger.changeRingBufferSize(3);
+    Logger.info('m1');
+    Logger.info('m2');
+    const snap1: LogSnapshot = Logger.takeSnapshot();
+    const snap1String: string[] = Logger.formatMessages(snap1.messages);
+
+    expect(snap1String.length).toBeGreaterThan(0);
+    snap1String.forEach((m) => {
+      expect(m.indexOf('::TRACE::')).toBeGreaterThan(-1);
+    });
+
+    Logger.updateTracePrefix(null);
+    Logger.info('m1');
+    Logger.info('m2');
+    const snap2: LogSnapshot = Logger.takeSnapshot();
+
+    expect(snap2.messages.length).toBeGreaterThan(0);
+    snap2.messages.forEach((m) => {
+      expect(m.messageSource.indexOf('::TRACE::')).toEqual(-1);
+    });
+  });
+});
+
+describe('#testLastMessage', function () {
+  test('should return the last message', function () {
+    Logger.info('m1');
+    Logger.info('m2');
+
+    const last: LogMessage = Logger.getLastLogMessage();
+    expect(last).toBeTruthy();
+    expect(last.lvl).toEqual(LoggerLevelName.info);
+    expect(last.messageSource.endsWith('m2')).toBeTruthy();
+  });
+});
+
+describe('#testPassThruFunctions', function () {
+  test('should pass through values', function () {
+    Logger.setLevel(LoggerLevelName.debug);
+
+    Logger.error('Test %s', 'tVal');
+    Logger.errorP('TestP %s', 'tVal');
+    Logger.errorP('TestP 2', 27, { some: 'Object' });
+
+    Logger.warn('Test %s', 'tVal');
+    Logger.warnP('TestP %s', 'tVal');
+
+    Logger.info('Test %s', 'tVal');
+    Logger.infoP('TestP %s', 'tVal');
+
+    Logger.debug('Test %s', 'tVal');
+    Logger.debugP('TestP %s', 'tVal');
+
+    // These shouldnt run
+    Logger.verbose('Test %s', 'tVal');
+    Logger.verboseP('TestP %s', 'tVal');
+
+    Logger.silly('Test %s', 'tVal');
+    Logger.sillyP('TestP %s', 'tVal');
+
+    Logger.setLevel(LoggerLevelName.debug);
+  });
+});
+
+describe('#testFormatter', function () {
+  test('should format values', function () {
+    const msg: LogMessage = {
+      lvl: LoggerLevelName.info,
+      timestamp: Date.now(),
+      messageSource: 'Test %d %d',
+      subsVars: [1, 2],
+      params: {},
+    };
+    Logger.info('Test %d %d', 3, 4);
+    const msgS: string = Logger.formatMessages([msg])[0];
+    expect(msgS).toEqual('[info] Test 1 2');
+  });
+});
+
+describe('#testPreProcessor', function () {
+  test('should perform a preprocess', function () {
+    const preProc: LogMessageProcessor = {
+      process(msg: LogMessage): LogMessage {
+        msg.messageSource = 'Preprocess';
+        return msg;
+      },
+    };
+
+    const output: string = Logger.getLogger(StringRatchet.createRandomHexString(4), { preProcessors: [preProc] }).info(
+      'This is a test %s',
+      'bob',
+    );
+    expect(output).toEqual('[info] Preprocess bob');
+  });
+});
+
+describe('#testBuilder', function () {
+  test('should use a builder', function () {
+    const output: string = Logger.getLogger(StringRatchet.createRandomHexString(4)).recordMessageBuilder(
+      new LogMessageBuilder(LoggerLevelName.warn, 'This is a test %s').subVars(['bob']),
+    );
+    expect(output).toEqual('[warn] This is a test bob');
+  });
+});
+
+describe('#testStructured', function () {
+  test('should use a structured logger', function () {
+    const output: string = Logger.getLogger(StringRatchet.createRandomHexString(4), {
+      formatType: LogMessageFormatType.StructuredJson,
+      outputFunction: LoggerOutputFunction.StdOut,
+    }).recordMessageBuilder(new LogMessageBuilder(LoggerLevelName.warn, 'This is a test %s').subVars(['bob']).p('a', 27));
+    const parsed: any = JSON.parse(output);
+    expect(parsed.msg).toEqual('This is a test bob');
+    expect(parsed.logLevel).toEqual('warn');
+    expect(parsed.a).toEqual(27);
+  });
+});