@emartech/json-logger 5.0.0 → 5.0.1

package/README.md

@@ -1,8 +1,7 @@
 # @emartech/json-logger
 
 A tiny and fast logging library that outputs logs in JSON format.
-It has the same namespace based enabling/disabling mechanism as [debug]
-and has the same log levels as [bunyan].
+It has the same namespace based enabling/disabling mechanism as [debug].
 
 ### Installation
 

package/dist/config.d.ts

@@ -0,0 +1,10 @@
+interface Color {
+    number: number;
+    name: string;
+}
+export declare const config: {
+    levels: Record<string, Color>;
+    availableLevels: string[];
+    coloredNames: Record<string, string>;
+};
+export {};

package/dist/config.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const levels = {
+    trace: {
+        number: 10,
+        name: 'TRACE'
+    },
+    debug: {
+        number: 20,
+        name: 'DEBUG'
+    },
+    info: {
+        number: 30,
+        name: 'INFO'
+    },
+    warn: {
+        number: 40,
+        name: chalk_1.default.yellow('WARN')
+    },
+    error: {
+        number: 50,
+        name: chalk_1.default.red('ERROR')
+    },
+    fatal: {
+        number: 60,
+        name: chalk_1.default.red('FATAL')
+    },
+};
+const availableLevels = Object.keys(levels);
+const coloredNames = {};
+availableLevels.forEach((levelName) => {
+    coloredNames[levels[levelName].number] = levels[levelName].name;
+});
+exports.config = { levels, availableLevels, coloredNames };

package/dist/enabled/enabled.d.ts

@@ -0,0 +1 @@
+export declare function isNamespaceEnabled(availableNamespace: string, namespace: string): boolean;

package/dist/enabled/enabled.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNamespaceEnabled = void 0;
+function isNamespaceEnabled(availableNamespace, namespace) {
+    const availableNamespaces = availableNamespace.split(/[\s,]+/);
+    let enabled = false;
+    const adds = [];
+    const skips = [];
+    availableNamespaces.forEach(function (name) {
+        if (!name) {
+            return;
+        }
+        name = name.replace(/\*/g, '.*?');
+        if (name[0] === '-') {
+            skips.push(new RegExp('^' + name.substr(1) + '$'));
+        }
+        else {
+            adds.push(new RegExp('^' + name + '$'));
+        }
+    });
+    adds.forEach(function (addRegexp) {
+        if (addRegexp.test(namespace)) {
+            enabled = true;
+        }
+    });
+    skips.forEach(function (addRegexp) {
+        if (addRegexp.test(namespace)) {
+            enabled = false;
+        }
+    });
+    return enabled;
+}
+exports.isNamespaceEnabled = isNamespaceEnabled;

package/dist/formatter/debug.d.ts

@@ -0,0 +1,6 @@
+interface Log {
+    name: string;
+    level: string;
+}
+export declare function debugFormatter(log: Log): string;
+export {};

package/dist/formatter/debug.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugFormatter = void 0;
+const color_name_1 = require("../output/color-name/color-name");
+const stringify_level_1 = require("../output/stringify-level/stringify-level");
+const format_time_1 = require("../output/format-time/format-time");
+const format_body_1 = require("../output/format-body/format-body");
+const formatTime = new format_time_1.FormatTime();
+function debugFormatter(log) {
+    return [
+        color_name_1.ColorName.addColor(log.name),
+        (0, stringify_level_1.stringifyLevel)(log.level),
+        formatTime.elapsedTime(),
+        (0, format_body_1.formatBody)(log)
+    ].join(' ');
+}
+exports.debugFormatter = debugFormatter;
+;

package/dist/formatter/index.d.ts

@@ -0,0 +1,8 @@
+import { jsonFormatter } from './json';
+import { logentriesFormatter } from './logentries';
+import { debugFormatter } from './debug';
+export declare const formatter: {
+    json: typeof jsonFormatter;
+    debug: typeof debugFormatter;
+    logentries: typeof logentriesFormatter;
+};

package/dist/formatter/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatter = void 0;
+const json_1 = require("./json");
+const logentries_1 = require("./logentries");
+const debug_1 = require("./debug");
+exports.formatter = {
+    json: json_1.jsonFormatter,
+    debug: debug_1.debugFormatter,
+    logentries: logentries_1.logentriesFormatter
+};

package/dist/formatter/json.d.ts

@@ -0,0 +1 @@
+export declare function jsonFormatter(log: unknown): string;

package/dist/formatter/json.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonFormatter = void 0;
+function jsonFormatter(log) {
+    return JSON.stringify(log);
+}
+exports.jsonFormatter = jsonFormatter;

package/dist/formatter/logentries.d.ts

@@ -0,0 +1 @@
+export declare function logentriesFormatter(data: Record<string, unknown>): string;

package/dist/formatter/logentries.js

@@ -0,0 +1,24 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logentriesFormatter = void 0;
+const isNumeric = (value) => !isNaN(parseFloat(value)) && isFinite(value);
+const isString = (value) => typeof value === 'string' || value instanceof String;
+const convertToTag = (value, key) => {
+    if (isString(value)) {
+        value = JSON.stringify(value);
+    }
+    else if (isNumeric(value)) {
+        value = value.toString();
+    }
+    else {
+        value = '"' + JSON.stringify(value) + '"';
+    }
+    return key + '=' + value;
+};
+function logentriesFormatter(data) {
+    return Object
+        .keys(data)
+        .map(key => convertToTag(data[key], key))
+        .join(' ');
+}
+exports.logentriesFormatter = logentriesFormatter;

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { Logger, LoggerConfig } from './logger/logger';
+export { Logger, LoggerConfig } from './logger/logger';
+export { Timer } from './timer/timer';
+export declare function logFactory(namespace: string): Logger;
+export declare namespace logFactory {
+    var Logger: typeof import("./logger/logger").Logger;
+    var Timer: typeof import("./timer/timer").Timer;
+    var getNamespaces: () => string;
+    var configure: (options: LoggerConfig) => void;
+    var formatter: {
+        json: typeof import("./formatter/json").jsonFormatter;
+        debug: typeof import("./formatter/debug").debugFormatter;
+        logentries: typeof import("./formatter/logentries").logentriesFormatter;
+    };
+}
+export default logFactory;

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logFactory = exports.Timer = exports.Logger = void 0;
+const logger_1 = require("./logger/logger");
+var logger_2 = require("./logger/logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_2.Logger; } });
+const timer_1 = require("./timer/timer");
+var timer_2 = require("./timer/timer");
+Object.defineProperty(exports, "Timer", { enumerable: true, get: function () { return timer_2.Timer; } });
+const enabled_1 = require("./enabled/enabled");
+const formatter_1 = require("./formatter");
+function logFactory(namespace) {
+    return new logger_1.Logger(namespace, (0, enabled_1.isNamespaceEnabled)(logFactory.getNamespaces(), namespace));
+}
+exports.logFactory = logFactory;
+logFactory.Logger = logger_1.Logger;
+logFactory.Timer = timer_1.Timer;
+logFactory.getNamespaces = function () {
+    return process.env.DEBUG || '';
+};
+logFactory.configure = function (options) {
+    logger_1.Logger.configure(options);
+};
+logFactory.formatter = formatter_1.formatter;
+exports.default = logFactory;
+module.exports = logFactory;

package/dist/logger/logger.d.ts

@@ -0,0 +1,55 @@
+import { Timer } from '../timer/timer';
+interface AxiosError extends Error {
+    isAxiosError: boolean;
+    config: {
+        method: string;
+        url: string;
+    };
+    response?: {
+        status: number;
+        statusText: string;
+        data: string;
+    };
+}
+export interface LoggerConfig {
+    formatter: Function;
+    output: Function;
+    transformers: Function[];
+}
+export declare class Logger {
+    _namespace: string;
+    _enabled: boolean;
+    constructor(namespace: string, enabled: boolean);
+    static configure(options: LoggerConfig): void;
+    static _validate(options: LoggerConfig): void;
+    static config: LoggerConfig;
+    isEnabled(): boolean;
+    trace(action: string, data?: unknown): void;
+    debug(action: string, data?: unknown): void;
+    info(action: string, data?: unknown): void;
+    warn(action: string, data?: unknown): void;
+    error(action: string, data?: unknown): void;
+    fatal(action: string, data?: unknown): void;
+    _log(level: string, action: string, data: unknown): void;
+    customError(severity: string, action: string, error: Error, data?: unknown): void;
+    fromError(action: string, error: Error, data?: unknown): void;
+    warnFromError(action: string, error: Error, data?: unknown): void;
+    timer(): Timer;
+    _shortenStackTrace(stack: string): string | undefined;
+    _shortenData(data: unknown): string | undefined;
+    _getErrorDetails(error: Error): {};
+    _getAxiosErrorDetails(error: AxiosError): {
+        request_method?: undefined;
+        request_url?: undefined;
+        response_status?: undefined;
+        response_status_text?: undefined;
+        response_data?: undefined;
+    } | {
+        request_method: string;
+        request_url: string;
+        response_status: number | undefined;
+        response_status_text: string | undefined;
+        response_data: string | undefined;
+    };
+}
+export {};

package/dist/logger/logger.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const config_1 = require("../config");
+const STACK_TRACE_LIMIT = 3000;
+const DATA_LIMIT = 3000;
+const timer_1 = require("../timer/timer");
+const json_1 = require("../formatter/json");
+const console_1 = require("../output/console");
+const allowedKeys = ['output', 'formatter', 'transformers'];
+class Logger {
+    constructor(namespace, enabled) {
+        this._namespace = namespace;
+        this._enabled = enabled;
+    }
+    static configure(options) {
+        this._validate(options);
+        Object.assign(Logger.config, options);
+    }
+    static _validate(options) {
+        Object.keys(options).forEach(key => {
+            if (!allowedKeys.includes(key)) {
+                throw new Error('Only the following keys are allowed: formatter, output');
+            }
+        });
+    }
+    isEnabled() {
+        return this._enabled;
+    }
+    trace(action, data = {}) {
+        this._log('trace', action, data);
+    }
+    debug(action, data = {}) {
+        this._log('debug', action, data);
+    }
+    info(action, data = {}) {
+        this._log('info', action, data);
+    }
+    warn(action, data = {}) {
+        this._log('warn', action, data);
+    }
+    error(action, data = {}) {
+        this._log('error', action, data);
+    }
+    fatal(action, data = {}) {
+        this._log('fatal', action, data);
+    }
+    _log(level, action, data) {
+        if (!this._enabled) {
+            return;
+        }
+        let dataToLog = Object.assign({
+            name: this._namespace,
+            action: action,
+            level: config_1.config.levels[level].number,
+            time: new Date().toISOString()
+        }, data);
+        Logger.config.transformers.forEach((transform) => {
+            dataToLog = transform(dataToLog);
+        });
+        Logger.config.output(Logger.config.formatter(dataToLog));
+    }
+    customError(severity, action, error, data = {}) {
+        this._log(severity, action, Object.assign(this._getErrorDetails(error), data));
+    }
+    fromError(action, error, data = {}) {
+        this.customError('error', action, error, data);
+    }
+    warnFromError(action, error, data = {}) {
+        this.customError('warn', action, error, data);
+    }
+    timer() {
+        return new timer_1.Timer(this);
+    }
+    _shortenStackTrace(stack) {
+        if (!stack) {
+            return;
+        }
+        return stack.length > STACK_TRACE_LIMIT
+            ? stack.substring(0, STACK_TRACE_LIMIT) + ' ...'
+            : stack;
+    }
+    _shortenData(data) {
+        if (typeof data === 'undefined') {
+            return;
+        }
+        const stringifiedData = typeof data === 'object' ? JSON.stringify(data) : data;
+        return stringifiedData.length > DATA_LIMIT
+            ? stringifiedData.substring(0, DATA_LIMIT) + ' ...'
+            : stringifiedData;
+    }
+    _getErrorDetails(error) {
+        if (!(error instanceof Object)) {
+            return {};
+        }
+        const baseDetails = {
+            error_name: error.name,
+            error_stack: this._shortenStackTrace(error.stack || ''),
+            error_message: error.message,
+            error_data: this._shortenData(error.data)
+        };
+        return Object.assign(baseDetails, this._getAxiosErrorDetails(error));
+    }
+    _getAxiosErrorDetails(error) {
+        if (!error.isAxiosError)
+            return {};
+        return {
+            request_method: error.config.method,
+            request_url: error.config.url,
+            response_status: error.response ? error.response.status : undefined,
+            response_status_text: error.response ? error.response.statusText : undefined,
+            response_data: error.response ? this._shortenData(error.response.data) : undefined
+        };
+    }
+}
+exports.Logger = Logger;
+Logger.config = {
+    formatter: json_1.jsonFormatter,
+    output: console_1.consoleOutput,
+    transformers: []
+};

package/dist/output/color-name/color-name.d.ts

@@ -0,0 +1,11 @@
+interface Color {
+    color: number;
+}
+export declare class ColorName {
+    static counter: number;
+    static colors: string[];
+    static names: Record<string, Color>;
+    static addColor(name: string): any;
+    static reset(): void;
+}
+export {};

package/dist/output/color-name/color-name.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorName = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const colors = ['cyan', 'magenta', 'grey', 'blue', 'green', 'yellow', 'white', 'red'];
+class ColorName {
+    static addColor(name) {
+        if (!this.names[name]) {
+            this.names[name] = { color: this.counter % colors.length };
+            this.counter++;
+        }
+        const color = colors[this.names[name].color];
+        // @ts-ignore
+        return chalk_1.default[color](name);
+    }
+    static reset() {
+        this.counter = 0;
+        this.names = {};
+    }
+}
+exports.ColorName = ColorName;
+ColorName.counter = 0;
+ColorName.colors = colors;
+ColorName.names = {};

package/dist/output/console.d.ts

@@ -0,0 +1 @@
+export declare function consoleOutput(formattedLog: unknown): void;

package/dist/output/console.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consoleOutput = void 0;
+function consoleOutput(formattedLog) {
+    console.log(formattedLog);
+}
+exports.consoleOutput = consoleOutput;

package/dist/output/format-body/format-body.d.ts

@@ -0,0 +1 @@
+export declare function formatBody(logBody: any): string;

package/dist/output/format-body/format-body.js

@@ -0,0 +1,23 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBody = void 0;
+function formatBody(logBody) {
+    const log = Object.assign({}, logBody);
+    delete log.name;
+    delete log.level;
+    delete log.v;
+    delete log.pid;
+    delete log.hostname;
+    delete log.time;
+    if (!log.msg) {
+        delete log.msg;
+    }
+    const keys = Object.keys(log);
+    return keys
+        .sort()
+        .map(function (key) {
+        return key + '=' + JSON.stringify(log[key]);
+    })
+        .join(' ');
+}
+exports.formatBody = formatBody;

package/dist/output/format-time/format-time.d.ts

@@ -0,0 +1,5 @@
+export declare class FormatTime {
+    lastLog: number;
+    elapsedTime(): string;
+    getCurrentTime(): number;
+}

package/dist/output/format-time/format-time.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatTime = void 0;
+class FormatTime {
+    constructor() {
+        this.lastLog = 0;
+    }
+    elapsedTime() {
+        const current = this.getCurrentTime();
+        let elapsed = 0;
+        if (this.lastLog) {
+            elapsed = current - this.lastLog;
+        }
+        this.lastLog = current;
+        return '+' + elapsed + 'ms';
+    }
+    getCurrentTime() {
+        return new Date().getTime();
+    }
+}
+exports.FormatTime = FormatTime;

package/dist/output/stringify-level/stringify-level.d.ts

@@ -0,0 +1 @@
+export declare function stringifyLevel(level: string): string;

package/dist/output/stringify-level/stringify-level.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyLevel = void 0;
+const config_1 = require("../../config");
+function stringifyLevel(level) {
+    return config_1.config.coloredNames[level];
+}
+exports.stringifyLevel = stringifyLevel;

package/dist/timer/timer.d.ts

@@ -0,0 +1,15 @@
+import { Logger } from '../logger/logger';
+export declare class Timer {
+    _logger: Logger;
+    _start: number;
+    constructor(logger: Logger);
+    trace(action: string, data?: unknown): void;
+    debug(action: string, data?: unknown): void;
+    info(action: string, data?: unknown): void;
+    warn(action: string, data?: unknown): void;
+    error(action: string, data?: unknown): void;
+    fatal(action: string, data?: unknown): void;
+    fromError(action: string, error: Error, data?: unknown): void;
+    warnFromError(action: string, error: Error, data?: unknown): void;
+    _duration(): number;
+}

package/dist/timer/timer.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timer = void 0;
+class Timer {
+    constructor(logger) {
+        this._logger = logger;
+        this._start = new Date().getTime();
+    }
+    trace(action, data = {}) {
+        this._logger.trace(action, Object.assign({ duration: this._duration() }, data));
+    }
+    debug(action, data = {}) {
+        this._logger.debug(action, Object.assign({ duration: this._duration() }, data));
+    }
+    info(action, data = {}) {
+        this._logger.info(action, Object.assign({ duration: this._duration() }, data));
+    }
+    warn(action, data = {}) {
+        this._logger.warn(action, Object.assign({ duration: this._duration() }, data));
+    }
+    error(action, data = {}) {
+        this._logger.error(action, Object.assign({ duration: this._duration() }, data));
+    }
+    fatal(action, data = {}) {
+        this._logger.fatal(action, Object.assign({ duration: this._duration() }, data));
+    }
+    fromError(action, error, data = {}) {
+        this._logger.fromError(action, error, Object.assign({ duration: this._duration() }, data));
+    }
+    warnFromError(action, error, data = {}) {
+        this._logger.warnFromError(action, error, Object.assign({ duration: this._duration() }, data));
+    }
+    _duration() {
+        const end = new Date().getTime();
+        return end - this._start;
+    }
+}
+exports.Timer = Timer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emartech/json-logger",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "Tiny and fast json logger with namespace support",
   "main": "dist/index.js",
   "scripts": {