@emartech/json-logger 5.0.0 → 6.0.0

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
 
@@ -12,10 +11,13 @@ npm install @emartech/json-logger
 
 ### Usage
 
+#### Script
+
 ```javascript
 process.env.DEBUG = 'redis';
-const mongoLogger = require('@emartech/json-logger')('mongo');
-const redisLogger = require('@emartech/json-logger')('redis');
+const { createLogger } = require('@emartech/json-logger');
+const mongoLogger = createLogger('mongo');
+const redisLogger = createLogger('redis');
 
 redisLogger.info('connected', { domain: 'yahoo' });
 // {"name":"redis","action":"connected","level":30,"time":"2016-08-15T08:50:23.566Z","domain":"yahoo"}
@@ -27,6 +29,47 @@ redisLogger.fromError('query', new Error('Unauthorized'), { problem: 'missmatch'
 // {"name":"redis","action":"query","level":50,"time":"2016-08-15T08:50:23.569Z","error_name":"Error","error_stack":"Error: Unauthorized\n    at Object.<anonymous> (/home/blacksonic/workspace/bunyan-debug/example.js:15:32)\n    at Module._compile (module.js:541:32)\n    at Object.Module._extensions..js (module.js:550:10)\n    at Module.load (module.js:458:32)\n    at tryModuleLoad (module.js:417:12)\n    at Function.Module._load (module.js:409:3)\n    at Module.runMain (module.js:575:10)\n    at run (bootstrap_node.js:352:7)\n    at startup (bootstrap_node.js:144:9)\n    at bootstrap_node.js:467:3","error_message":"Unauthorized","problem":"missmatch"}
 ```
 
+#### Class
+
+```javascript
+const { createLogger } = require('@emartech/json-logger');
+const logger = createLogger('Exporter');
+
+class Exporter {
+  export() {
+    mongoLogger.info('export', { customer_id: 123 });
+  }
+}
+```
+
+```typescript
+import { createLogger } from '@emartech/json-logger';
+const logger = createLogger('Exporter');
+
+class Exporter {
+  export() {
+    mongoLogger.info('export', { customer_id: 123 });
+  }
+}
+```
+
+#### Tests
+
+```javascript
+import { Logger } from '@emartech/json-logger';
+
+describe('Exporter', () => {
+  it('should log', () => {
+    jest.spyOn(Logger.prototype, 'info').mockReturnValue();
+    const exporter = new Exporter();
+    
+    exporter.export();
+
+    expect(Logger.prototype.info).toHaveBeenCalledWith('export', { customer_id: 123 });
+  })
+});
+```
+
 More examples can be found in the `examples` directory.
 
 ### API
@@ -40,11 +83,12 @@ Disabled instances output no logs.
 
 ```javascript
 process.env.DEBUG = 'redis,mysql';
+const { createLogger } = require('@emartech/json-logger');
 
-const mongoLogger = require('@emartech/json-logger')('mongo');
+const mongoLogger = createLogger('mongo');
 // mongo instance will be disabled
 
-const redisLogger = require('@emartech/json-logger')('redis');
+const redisLogger = createLogger('redis');
 // redis instance will be enabled
 ```
 
@@ -53,7 +97,8 @@ const redisLogger = require('@emartech/json-logger')('redis');
 Prints the provided data to the console in JSON format.
 
 ```javascript
-const redisLogger = require('@emartech/json-logger')('redis');
+const { createLogger } = require('@emartech/json-logger');
+const redisLogger = createLogger('redis');
 
 redisLogger.info('connected', { domain: 'yahoo' });
 // {"name":"redis","action":"connected","level":30,"time":"2016-08-15T08:50:23.566Z","domain":"yahoo"}
@@ -93,7 +138,8 @@ The displayed line contains the stack trace, the name and the message of the err
 The log level defaults to error.
 
 ```javascript
-const redisLogger = require('@emartech/json-logger')('redis');
+const { createLogger } = require('@emartech/json-logger');
+const redisLogger = createLogger('redis');
 
 redisLogger.fromError('query', new Error('Unauthorized'), { problem: 'missmatch' });
 // {"name":"redis","action":"query","level":50,"time":"2016-08-15T08:50:23.569Z","error_name":"Error","error_stack":"Error: Unauthorized\n    at Object.<anonymous> (/home/blacksonic/workspace/bunyan-debug/example.js:15:32)\n    at Module._compile (module.js:541:32)\n    at Object.Module._extensions..js (module.js:550:10)\n    at Module.load (module.js:458:32)\n    at tryModuleLoad (module.js:417:12)\n    at Function.Module._load (module.js:409:3)\n    at Module.runMain (module.js:575:10)\n    at run (bootstrap_node.js:352:7)\n    at startup (bootstrap_node.js:144:9)\n    at bootstrap_node.js:467:3","error_message":"Unauthorized","problem":"missmatch"}
@@ -110,7 +156,8 @@ but also logs the elapsed time in milliseconds from the creation of the instance
 The elapsed time will be logged into the `duration` field.
 
 ```javascript
-const redisLogger = require('@emartech/json-logger')('redis');
+const { createLogger } = require('@emartech/json-logger');
+const redisLogger = createLogger('redis');
 
 const timer = redisLogger.timer();
 
@@ -128,9 +175,9 @@ With transformers we can alter the data to be logged before passing to the forma
 It is a perfect place to add the name of the machine is running on or the request id associated with the current thread stored on a continuation local storage. 
 
 ```javascript
-const Logger = require('@emartech/json-logger');
+const { createLogger } = require('@emartech/json-logger');
 
-Logger.configure({
+createLogger.configure({
   formatter: JSON.stringify,
   output: console.log,
   transformers: []
@@ -161,11 +208,11 @@ For automating
 
 ```javascript
 const Koa = require('koa');
-const logFactory = require('@emartech/json-logger');
+const { createLogger } = require('@emartech/json-logger');
 const clsAdapter = require('@emartech/cls-adapter');
-const logger = logFactory('redis');
+const logger = createLogger('redis');
 
-logFactory.configure({
+createLogger.configure({
   transformers: [
     clsAdapter.addContextStorageToInput()
   ]

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,13 @@
+import { Logger, LoggerConfig } from './logger/logger';
+export { Logger, LoggerConfig } from './logger/logger';
+export { Timer } from './timer/timer';
+export declare function createLogger(namespace: string): Logger;
+export declare namespace createLogger {
+    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;
+    };
+}

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = 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; } });
+var timer_1 = require("./timer/timer");
+Object.defineProperty(exports, "Timer", { enumerable: true, get: function () { return timer_1.Timer; } });
+const enabled_1 = require("./enabled/enabled");
+const formatter_1 = require("./formatter");
+function createLogger(namespace) {
+    return new logger_1.Logger(namespace, (0, enabled_1.isNamespaceEnabled)(createLogger.getNamespaces(), namespace));
+}
+exports.createLogger = createLogger;
+createLogger.getNamespaces = function () {
+    return process.env.DEBUG || '';
+};
+createLogger.configure = function (options) {
+    logger_1.Logger.configure(options);
+};
+createLogger.formatter = formatter_1.formatter;

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: unknown, data?: unknown): void;
+    warnFromError(action: string, error: unknown, 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: unknown, data?: unknown): void;
+    warnFromError(action: string, error: unknown, 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": "6.0.0",
   "description": "Tiny and fast json logger with namespace support",
   "main": "dist/index.js",
   "scripts": {