Metalog decomposition: Logger, Formatter, Console

.github/workflows/test.yml

@@ -14,8 +14,19 @@ jobs:
           - 18
         os:
           - ubuntu-latest
-          - windows-latest
-          - macos-latest
+          # - windows-latest
+          # - macos-latest
+
+    services:
+      redis:
+        image: redis
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 6379:6379
 
     steps:
       - uses: actions/checkout@v2
@@ -31,3 +42,6 @@ jobs:
             ${{ runner.os }}-node-
       - run: npm ci
       - run: npm test
+        env:
+          REDIS_HOST: '0.0.0.0'
+          REDIS_PORT: 6379

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## [Unreleased][unreleased]
 
+- Decompose metalog.js in to 4 files by destiny
+- Implement interface and DI container for external loggers
+- Replace old Logger with new Logger - facade for multiple loggers
+
 ## [3.1.9][] - 2022-07-07
 
 - Package maintenance

lib/console.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const readline = require('readline');
+const util = require('util');
+
+const INDENT = 2;
+
+class Console {
+  #write;
+  #groupIndent;
+  #counters;
+  #times;
+
+  constructor(write) {
+    this.#write = write;
+    this.#groupIndent = 0;
+    this.#counters = new Map();
+    this.#times = new Map();
+  }
+
+  assert(assertion, ...args) {
+    try {
+      console.assert(assertion, ...args);
+    } catch (err) {
+      this.#write('error', this.#groupIndent, err.stack);
+    }
+  }
+
+  clear() {
+    readline.cursorTo(process.stdout, 0, 0);
+    readline.clearScreenDown(process.stdout);
+  }
+
+  count(label = 'default') {
+    let counter = this.#counters.get(label) || 0;
+    counter++;
+    this.#counters.set(label, counter);
+    this.#write('debug', this.#groupIndent, `${label}: ${counter}`);
+  }
+
+  countReset(label = 'default') {
+    this.#counters.delete(label);
+  }
+
+  debug(...args) {
+    this.#write('debug', this.#groupIndent, ...args);
+  }
+
+  dir(...args) {
+    this.#write('debug', this.#groupIndent, ...args);
+  }
+
+  trace(...args) {
+    const msg = util.format(...args);
+    const err = new Error(msg);
+    this.#write('debug', this.#groupIndent, `Trace${err.stack}`);
+  }
+
+  info(...args) {
+    this.#write('info', this.#groupIndent, ...args);
+  }
+
+  log(...args) {
+    this.#write('log', this.#groupIndent, ...args);
+  }
+
+  warn(...args) {
+    this.#write('warn', this.#groupIndent, ...args);
+  }
+
+  error(...args) {
+    this.#write('error', this.#groupIndent, ...args);
+  }
+
+  group(...args) {
+    if (args.length !== 0) this.log(...args);
+    this.#groupIndent += INDENT;
+  }
+
+  groupCollapsed(...args) {
+    this.group(...args);
+  }
+
+  groupEnd() {
+    if (this.#groupIndent.length === 0) return;
+    this.#groupIndent -= INDENT;
+  }
+
+  table(tabularData) {
+    this.#write('log', 0, JSON.stringify(tabularData));
+  }
+
+  time(label = 'default') {
+    this.#times.set(label, process.hrtime());
+  }
+
+  timeEnd(label = 'default') {
+    const startTime = this.#times.get(label);
+    const totalTime = process.hrtime(startTime);
+    const totalTimeMs = totalTime[0] * 1e3 + totalTime[1] / 1e6;
+    this.timeLog(label, `${label}: ${totalTimeMs}ms`);
+    this.#times.delete(label);
+  }
+
+  timeLog(label, ...args) {
+    const startTime = this.#times.get(label);
+    if (startTime === undefined) {
+      const msg = `Warning: No such label '${label}'`;
+      this.#write('warn', this.#groupIndent, msg);
+      return;
+    }
+    this.#write('debug', this.#groupIndent, ...args);
+  }
+}
+
+module.exports = { Console };

lib/formatter.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const util = require('util');
+const concolor = require('concolor');
+const metautil = require('metautil');
+
+const STACK_AT = '  at ';
+const TYPE_LENGTH = 6;
+const LINE_SEPARATOR = ';';
+const DATE_LEN = 'YYYY-MM-DD'.length;
+const TIME_START = DATE_LEN + 1;
+const TIME_END = TIME_START + 'HH:MM:SS'.length;
+
+const TYPE_COLOR = concolor({
+  log: 'b,black/white',
+  info: 'b,white/blue',
+  warn: 'b,black/yellow',
+  debug: 'b,white/green',
+  error: 'b,yellow/red',
+});
+
+const TEXT_COLOR = concolor({
+  log: 'white',
+  info: 'white',
+  warn: 'b,yellow',
+  debug: 'b,green',
+  error: 'red',
+});
+
+const isError = (val) => val?.constructor?.name?.endsWith('Error');
+
+class Formatter {
+  #home;
+  #workerId;
+
+  constructor(home, workerId) {
+    this.#home = home;
+    this.#workerId = workerId;
+  }
+
+  pretty(type, indent, ...args) {
+    const dateTime = new Date().toISOString();
+    const message = this.format(type, indent, ...args);
+    const normalColor = TEXT_COLOR[type];
+    const markColor = TYPE_COLOR[type];
+    const time = normalColor(dateTime.substring(TIME_START, TIME_END));
+    const id = normalColor(this.#workerId);
+    const mark = markColor(' ' + type.padEnd(TYPE_LENGTH));
+    const msg = normalColor(message);
+    return `${time}  ${id}  ${mark}  ${msg}`;
+  }
+
+  file(type, indent, ...args) {
+    const dateTime = new Date().toISOString();
+    const message = this.format(type, indent, ...args);
+    const msg = metautil.replace(message, '\n', LINE_SEPARATOR);
+    return `${dateTime} [${type}] ${msg}`;
+  }
+
+  json(type, indent, ...args) {
+    const timestamp = new Date().toISOString();
+    const { workerId } = this;
+    const log = { timestamp, workerId, level: type, message: null };
+    const first = args.shift();
+    if (isError(first)) {
+      log.err = this.expandError(first);
+    } else if (typeof first === 'object') {
+      Object.assign(log, first);
+      if (isError(log.err)) log.err = this.expandError(log.err);
+      if (isError(log.error)) log.error = this.expandError(log.error);
+    }
+    log.message = util.format(...args);
+    return JSON.stringify(log);
+  }
+
+  format(type, indent, ...args) {
+    const normalize = type === 'error' || type === 'debug';
+    const s = `${' '.repeat(indent)}${util.format(...args)}`;
+    return normalize ? this.normalizeStack(s) : s;
+  }
+
+  normalizeStack(stack) {
+    if (!stack) return 'no data to log';
+    let res = metautil.replace(stack, STACK_AT, '');
+    if (this.#home) res = metautil.replace(res, this.#home, '');
+    return res;
+  }
+
+  expandError(err) {
+    return {
+      ...err,
+      message: err.message,
+      stack: this.normalizeStack(err.stack),
+    };
+  }
+}
+
+module.exports = { Formatter };