@emartech/json-logger 8.1.0 → 9.0.0

package/dist/config.js

@@ -4,28 +4,28 @@ exports.config = void 0;
 const levels = {
     trace: {
         number: 10,
-        name: 'TRACE'
+        name: 'TRACE',
     },
     debug: {
         number: 20,
-        name: 'DEBUG'
+        name: 'DEBUG',
     },
     info: {
         number: 30,
-        name: 'INFO'
+        name: 'INFO',
     },
     warn: {
         number: 40,
-        name: 'WARN'
+        name: 'WARN',
     },
     error: {
         number: 50,
-        name: 'ERROR'
+        name: 'ERROR',
     },
     fatal: {
         number: 60,
-        name: 'FATAL'
-    }
+        name: 'FATAL',
+    },
 };
 const availableLevels = Object.keys(levels);
 exports.config = { levels, availableLevels };

package/dist/enabled/enabled.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/enabled/enabled.spec.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enabled_1 = require("./enabled");
+const chai_1 = require("chai");
+describe('isNamespaceAvailable', () => {
+    it('should enable when variables only contain one', () => {
+        (0, chai_1.expect)((0, enabled_1.isNamespaceEnabled)('mongo', 'mongo')).to.eql(true);
+    });
+    it('should disable when not in availables', () => {
+        (0, chai_1.expect)((0, enabled_1.isNamespaceEnabled)('mongo', 'redis')).to.eql(false);
+    });
+    it('should enable when part of available and available contains *', () => {
+        (0, chai_1.expect)((0, enabled_1.isNamespaceEnabled)('mongo*', 'mongolab')).to.eql(true);
+    });
+    it('should allow multiple available namespaces', () => {
+        const availableNamespaces = 'mongo,redis';
+        (0, chai_1.expect)((0, enabled_1.isNamespaceEnabled)(availableNamespaces, 'mongo')).to.eql(true);
+        (0, chai_1.expect)((0, enabled_1.isNamespaceEnabled)(availableNamespaces, 'redis')).to.eql(true);
+    });
+    it('should disable names starting with -', () => {
+        (0, chai_1.expect)((0, enabled_1.isNamespaceEnabled)('mongo*,-*lab', 'mongolab')).to.eql(false);
+    });
+    it('should not work with empty strings', () => {
+        (0, chai_1.expect)((0, enabled_1.isNamespaceEnabled)('', '')).to.eql(false);
+    });
+    it('should enable everything for star', () => {
+        (0, chai_1.expect)((0, enabled_1.isNamespaceEnabled)('*', 'mongo')).to.eql(true);
+    });
+});

package/dist/formatter/json.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/formatter/json.spec.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const json_1 = require("./json");
+describe('json formatter', () => {
+    it('should stringify object to json', () => {
+        (0, chai_1.expect)((0, json_1.jsonFormatter)({ name: 'debugger' })).to.eql('{"name":"debugger"}');
+    });
+});

package/dist/formatter/logentries.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/formatter/logentries.spec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const logentries_1 = require("./logentries");
+describe('logentries formatter', () => {
+    it('should stringify single field to key value pairs', () => {
+        (0, chai_1.expect)((0, logentries_1.logentriesFormatter)({ name: 'debugger' })).to.eql('name="debugger"');
+    });
+    it('should stringify multiple fields separated', () => {
+        (0, chai_1.expect)((0, logentries_1.logentriesFormatter)({ name: 'debugger', namespace: 'it' })).to.eql('name="debugger" namespace="it"');
+    });
+    it('should not print numbers as string', () => {
+        (0, chai_1.expect)((0, logentries_1.logentriesFormatter)({ name: 'debugger', duration: 10, percent: 1.5 })).to.eql('name="debugger" duration=10 percent=1.5');
+    });
+    it('should json stringify nested objects', () => {
+        (0, chai_1.expect)((0, logentries_1.logentriesFormatter)({ name: 'debugger', nested: { inner: 10 } })).to.eql('name="debugger" nested="{"inner":10}"');
+    });
+});

package/dist/index.js

@@ -1,19 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLogger = exports.Timer = exports.Logger = void 0;
+exports.Timer = exports.Logger = void 0;
+exports.createLogger = createLogger;
+const enabled_1 = require("./enabled/enabled");
+const formatter_1 = require("./formatter");
 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");
+// eslint-disable-next-line func-style
 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 || '';
+    return process.env.DEBUG ?? '';
 };
 createLogger.configure = function (options) {
     logger_1.Logger.configure(options);

package/dist/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.spec.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const index_1 = require("./index");
+describe('createLogger', function () {
+    beforeEach(function () {
+        process.env.DEBUG = 'mongo';
+    });
+    afterEach(function () {
+        process.env.DEBUG = '';
+    });
+    it('should return an enabled log instance when env variable is set to same', function () {
+        const logger = (0, index_1.createLogger)('mongo');
+        (0, chai_1.expect)(logger).to.be.an.instanceOf(index_1.Logger);
+        (0, chai_1.expect)(logger.isEnabled()).to.be.true;
+    });
+    it('should return a disabled log instance when different', function () {
+        const logger = (0, index_1.createLogger)('redis');
+        (0, chai_1.expect)(logger).to.be.an.instanceOf(index_1.Logger);
+        (0, chai_1.expect)(logger.isEnabled()).to.be.false;
+    });
+});

package/dist/logger/logger.js

@@ -10,6 +10,8 @@ const console_1 = require("../output/console");
 const lodash_1 = require("lodash");
 const allowedKeys = ['output', 'formatter', 'transformers', 'outputFormat'];
 class Logger {
+    namespace;
+    enabled;
     constructor(namespace, enabled) {
         this.namespace = namespace;
         this.enabled = enabled;
@@ -25,6 +27,12 @@ class Logger {
             }
         });
     }
+    static config = {
+        formatter: json_1.jsonFormatter,
+        output: console_1.consoleOutput,
+        transformers: [],
+        outputFormat: 'ecs',
+    };
     isEnabled() {
         return this.enabled;
     }
@@ -163,9 +171,3 @@ class Logger {
     }
 }
 exports.Logger = Logger;
-Logger.config = {
-    formatter: json_1.jsonFormatter,
-    output: console_1.consoleOutput,
-    transformers: [],
-    outputFormat: 'ecs',
-};

package/dist/logger/logger.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/logger/logger.spec.js

@@ -0,0 +1,322 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = require("axios");
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const json_1 = require("../formatter/json");
+const console_1 = require("../output/console");
+const logger_1 = require("./logger");
+describe('Logger', () => {
+    let logger;
+    let clock;
+    let outputStub;
+    beforeEach(() => {
+        logger = new logger_1.Logger('mongo', true);
+        outputStub = sinon_1.default.stub(logger_1.Logger.config, 'output');
+        clock = sinon_1.default.useFakeTimers();
+    });
+    afterEach(() => {
+        logger_1.Logger.configure({
+            formatter: json_1.jsonFormatter,
+            output: console_1.consoleOutput,
+            transformers: [],
+            outputFormat: 'ecs',
+        });
+        clock.restore();
+    });
+    it('should call log info method when enabled (legacy format)', () => {
+        logger_1.Logger.configure({ outputFormat: 'legacy' });
+        logger.info('wedidit', { details: 'forever' });
+        const logArguments = JSON.parse(outputStub.args[0][0]);
+        (0, chai_1.expect)(logArguments.name).to.eql('mongo');
+        (0, chai_1.expect)(logArguments.action).to.eql('wedidit');
+        (0, chai_1.expect)(logArguments.level).to.eql(30);
+        (0, chai_1.expect)(logArguments.details).to.eql('forever');
+    });
+    it('should call log info method when enabled (ecs format)', () => {
+        logger_1.Logger.configure({ outputFormat: 'ecs' });
+        logger.info('wedidit', { details: 'forever' });
+        const logArguments = JSON.parse(outputStub.args[0][0]);
+        (0, chai_1.expect)(logArguments.event.action).to.eql('wedidit');
+        (0, chai_1.expect)(logArguments.log.logger).to.eql('mongo');
+        (0, chai_1.expect)(logArguments.log.level).to.eql(30);
+        (0, chai_1.expect)(logArguments.details).to.eql('forever');
+    });
+    it('should not overwrite fields in ecs base log', () => {
+        logger.info('wedidit', { event: { duration: 245 }, log: { ter: 'abc' } });
+        const logArguments = JSON.parse(outputStub.args[0][0]);
+        (0, chai_1.expect)(logArguments.event.action).to.eql('wedidit');
+        (0, chai_1.expect)(logArguments.event.duration).to.eql(245);
+        (0, chai_1.expect)(logArguments.log.logger).to.eql('mongo');
+        (0, chai_1.expect)(logArguments.log.level).to.eql(30);
+        (0, chai_1.expect)(logArguments.log.ter).to.eql('abc');
+    });
+    it('should be callable without the data object', () => {
+        logger.info('wedidit');
+        const logArguments = JSON.parse(outputStub.args[0][0]);
+        (0, chai_1.expect)(logArguments.event.action).to.eql('wedidit');
+        (0, chai_1.expect)(logArguments.log.logger).to.eql('mongo');
+        (0, chai_1.expect)(logArguments.log.level).to.eql(30);
+    });
+    it('should not call log info method when disabled', () => {
+        logger = new logger_1.Logger('mongo', false);
+        logger.info('hi');
+        (0, chai_1.expect)(logger_1.Logger.config.output).not.to.have.been.called;
+    });
+    it('should not call log info method when disabled (timer)', () => {
+        logger = new logger_1.Logger('mongo', false);
+        const timer = logger.timer();
+        const infoStub = sinon_1.default.stub(logger, 'info');
+        clock.tick(100);
+        timer.info('hi');
+        (0, chai_1.expect)(infoStub).to.have.been.calledWith('hi', { event: { duration: 100 } });
+    });
+    it('should log error with action (legacy format)', () => {
+        logger_1.Logger.configure({ outputFormat: 'legacy' });
+        const error = new Error('failed');
+        error.data = { test: 'data' };
+        logger.fromError('hi', error, { details: 'here' });
+        const logArguments = JSON.parse(outputStub.args[0][0]);
+        (0, chai_1.expect)(logArguments.name).to.eql('mongo');
+        (0, chai_1.expect)(logArguments.action).to.eql('hi');
+        (0, chai_1.expect)(logArguments.level).to.eql(50);
+        (0, chai_1.expect)(logArguments.details).to.eql('here');
+        (0, chai_1.expect)(logArguments.error_name).to.eql(error.name);
+        (0, chai_1.expect)(logArguments.error_stack).to.eql(error.stack);
+        (0, chai_1.expect)(logArguments.error_message).to.eql(error.message);
+        (0, chai_1.expect)(logArguments.error_data).to.eql(JSON.stringify(error.data));
+    });
+    it('should log error with action (ecs format)', () => {
+        logger_1.Logger.configure({ outputFormat: 'ecs' });
+        const error = new Error('failed');
+        error.data = { test: 'data' };
+        logger.fromError('hi', error, { details: 'here' });
+        const logArguments = JSON.parse(outputStub.args[0][0]);
+        (0, chai_1.expect)(logArguments.event.action).to.eql('hi');
+        (0, chai_1.expect)(logArguments.log.logger).to.eql('mongo');
+        (0, chai_1.expect)(logArguments.log.level).to.eql(50);
+        (0, chai_1.expect)(logArguments.details).to.eql('here');
+        (0, chai_1.expect)(logArguments.error.type).to.eql(error.name);
+        (0, chai_1.expect)(logArguments.error.stack_trace).to.eql(error.stack);
+        (0, chai_1.expect)(logArguments.error.message).to.eql(error.message);
+        (0, chai_1.expect)(logArguments.error.context).to.eql(JSON.stringify(error.data));
+    });
+    it('should not overwrite ecs error fields with custom data', () => {
+        const error = new Error('failed');
+        error.data = { test: 'data' };
+        logger.fromError('hi', error, { error: { bajvan: true } });
+        const logArguments = JSON.parse(outputStub.args[0][0]);
+        (0, chai_1.expect)(logArguments.error).to.eql({
+            type: error.name,
+            stack_trace: error.stack,
+            message: error.message,
+            context: JSON.stringify(error.data),
+            bajvan: true,
+        });
+    });
+    it('should log error as warning with action', () => {
+        const error = new Error('failed');
+        error.data = { test: 'data' };
+        logger.warnFromError('hi', error, { details: 'here' });
+        const logArguments = JSON.parse(outputStub.args[0][0]);
+        (0, chai_1.expect)(logArguments.event.action).to.eql('hi');
+        (0, chai_1.expect)(logArguments.log.logger).to.eql('mongo');
+        (0, chai_1.expect)(logArguments.log.level).to.eql(40);
+        (0, chai_1.expect)(logArguments.details).to.eql('here');
+        (0, chai_1.expect)(logArguments.error.type).to.eql(error.name);
+        (0, chai_1.expect)(logArguments.error.stack_trace).to.eql(error.stack);
+        (0, chai_1.expect)(logArguments.error.message).to.eql(error.message);
+        (0, chai_1.expect)(logArguments.error.context).to.eql(JSON.stringify(error.data));
+    });
+    it('should not log error data when it is undefined', () => {
+        const error = new Error('failed');
+        logger.warnFromError('hi', error, { details: 'here' });
+        const logArguments = JSON.parse(outputStub.args[0][0]);
+        (0, chai_1.expect)(logArguments.error).to.not.have.any.keys('context');
+    });
+    it('should log only 3000 character of data', () => {
+        const error = new Error('failed');
+        error.data = 'exactlyTen'.repeat(400);
+        logger.warnFromError('hi', error, { details: 'here' });
+        const logArguments = JSON.parse(outputStub.args[0][0]);
+        (0, chai_1.expect)(logArguments.error.context.length).to.eql(3004);
+    });
+    it('should log request/response details for Axios-like error objects (legacy format)', () => {
+        logger_1.Logger.configure({ outputFormat: 'legacy' });
+        const error = new axios_1.AxiosError('Request failed with status code 500');
+        error.response = {
+            status: 500,
+            statusText: 'Something horrible happened',
+            data: { useful_detail: 'important info' },
+            headers: {},
+            config: { headers: {} },
+        };
+        error.config = {
+            url: 'http://amazinghost.com/beautiful-path',
+            method: 'get',
+            headers: {},
+        };
+        logger.fromError('hi', error, { details: 'here' });
+        const logArguments = JSON.parse(outputStub.args[0][0]);
+        (0, chai_1.expect)(logArguments.name).to.eql('mongo');
+        (0, chai_1.expect)(logArguments.action).to.eql('hi');
+        (0, chai_1.expect)(logArguments.level).to.eql(50);
+        (0, chai_1.expect)(logArguments.error_name).to.eql(error.name);
+        (0, chai_1.expect)(logArguments.error_stack).to.eql(error.stack);
+        (0, chai_1.expect)(logArguments.error_message).to.eql(error.message);
+        (0, chai_1.expect)(logArguments.request_method).to.eql(error.config.method);
+        (0, chai_1.expect)(logArguments.request_url).to.eql(error.config.url);
+        (0, chai_1.expect)(logArguments.response_status).to.eql(error.response.status);
+        (0, chai_1.expect)(logArguments.response_status_text).to.eql(error.response.statusText);
+        (0, chai_1.expect)(logArguments.response_data).to.eql(JSON.stringify(error.response.data));
+    });
+    it('should log request/response details for Axios-like error objects (ecs format)', () => {
+        logger_1.Logger.configure({ outputFormat: 'ecs' });
+        const error = new axios_1.AxiosError('Request failed with status code 500');
+        error.response = {
+            status: 500,
+            statusText: 'Something horrible happened',
+            data: { useful_detail: 'important info' },
+            headers: {},
+            config: { headers: {} },
+        };
+        error.config = {
+            url: 'http://amazinghost.com/beautiful-path',
+            method: 'get',
+            headers: {},
+        };
+        error.code = 'ECONNREINVENTED';
+        logger.fromError('hi', error, { details: 'here' });
+        const logArguments = JSON.parse(outputStub.args[0][0]);
+        (0, chai_1.expect)(logArguments.log.logger).to.eql('mongo');
+        (0, chai_1.expect)(logArguments.event.action).to.eql('hi');
+        (0, chai_1.expect)(logArguments.log.level).to.eql(50);
+        (0, chai_1.expect)(logArguments.error.code).to.eql(error.code);
+        (0, chai_1.expect)(logArguments.error.type).to.eql(error.name);
+        (0, chai_1.expect)(logArguments.error.stack_trace).to.eql(error.stack);
+        (0, chai_1.expect)(logArguments.error.message).to.eql(error.message);
+        (0, chai_1.expect)(logArguments.http.request.method).to.eql(error.config?.method);
+        (0, chai_1.expect)(logArguments.url.full).to.eql(error.config?.url);
+        (0, chai_1.expect)(logArguments.http.response.status_code).to.eql(error.response?.status);
+        (0, chai_1.expect)(logArguments.http.response.body.content).to.eql(JSON.stringify(error.response?.data));
+    });
+    describe('#customError', () => {
+        it('should log error as the given severity with action', () => {
+            const error = new Error('failed');
+            error.data = { test: 'data' };
+            logger.customError('info', 'hi', error, { details: 'here' });
+            const logArguments = JSON.parse(outputStub.args[0][0]);
+            (0, chai_1.expect)(logArguments.event.action).to.eql('hi');
+            (0, chai_1.expect)(logArguments.log.logger).to.eql('mongo');
+            (0, chai_1.expect)(logArguments.log.level).to.eql(30);
+            (0, chai_1.expect)(logArguments.details).to.eql('here');
+            (0, chai_1.expect)(logArguments.error.type).to.eql(error.name);
+            (0, chai_1.expect)(logArguments.error.stack_trace).to.eql(error.stack);
+            (0, chai_1.expect)(logArguments.error.message).to.eql(error.message);
+            (0, chai_1.expect)(logArguments.error.context).to.eql(JSON.stringify(error.data));
+        });
+        it('should not log error data when it is undefined', () => {
+            const error = new Error('failed');
+            logger.customError('warn', 'hi', error, { details: 'here' });
+            const logArguments = JSON.parse(outputStub.args[0][0]);
+            (0, chai_1.expect)(logArguments.error).to.not.have.any.keys('context');
+        });
+        it('should not log error code when it is undefined in the AxiosError object', () => {
+            const error = new axios_1.AxiosError('failed');
+            logger.customError('warn', 'hi', error, { details: 'here' });
+            const logArguments = JSON.parse(outputStub.args[0][0]);
+            (0, chai_1.expect)(logArguments.error).to.not.have.any.keys('code');
+        });
+        it('should log only 3000 character of data', () => {
+            const error = new Error('failed');
+            error.data = 'exactlyTen'.repeat(400);
+            logger.customError('error', 'hi', error, { details: 'here' });
+            const logArguments = JSON.parse(outputStub.args[0][0]);
+            (0, chai_1.expect)(logArguments.error.context.length).to.eql(3004);
+        });
+        describe('when not an Error instance is passed as error', () => {
+            [
+                { type: 'custom object', value: {} },
+                { type: 'string', value: 'error' },
+                { type: 'null', value: null },
+                { type: 'number', value: 12 },
+                { type: 'bool', value: true },
+            ].forEach(({ type, value }) => {
+                it(`should not throw error when ${type} is passed as error`, () => {
+                    (0, chai_1.expect)(() => logger.customError('error', 'hi', value, { details: 'here' })).to.not.throw();
+                });
+            });
+            it('should log error properties from custom error object', () => {
+                const errorObject = { name: 'Error', message: 'My custom error', stack: 'Stack', data: { value: 1 } };
+                logger.customError('error', 'hi', errorObject, { details: 'here' });
+                const logArguments = JSON.parse(outputStub.args[0][0]);
+                (0, chai_1.expect)(logArguments.error.type).to.eql(errorObject.name);
+                (0, chai_1.expect)(logArguments.error.stack_trace).to.eql(errorObject.stack);
+                (0, chai_1.expect)(logArguments.error.message).to.eql(errorObject.message);
+                (0, chai_1.expect)(logArguments.error.context).to.eql(JSON.stringify(errorObject.data));
+            });
+            it('should not log additional or missing error properties from custom error object', () => {
+                const errorObject = { color: 'color', value: 'value' };
+                // @ts-expect-error TS2345
+                logger.customError('error', 'hi', errorObject, { details: 'here' });
+                const logArguments = JSON.parse(outputStub.args[0][0]);
+                (0, chai_1.expect)(logArguments).to.not.have.any.keys('error_name', 'error_stack', 'error_message', 'error_data');
+                (0, chai_1.expect)(logArguments).to.not.have.any.keys('color', 'value');
+            });
+        });
+    });
+    describe('#configure', () => {
+        it('should change format method', () => {
+            const formattedOutput = '{"my":"method"}';
+            const formatterStub = sinon_1.default.stub();
+            formatterStub.returns(formattedOutput);
+            logger_1.Logger.configure({
+                formatter: formatterStub,
+            });
+            logger.info('hi');
+            (0, chai_1.expect)(formatterStub).to.have.been.called;
+            (0, chai_1.expect)(logger_1.Logger.config.output).to.have.been.calledWith(formattedOutput);
+        });
+        it('should change output method', () => {
+            const outputStub = sinon_1.default.stub();
+            logger_1.Logger.configure({
+                output: outputStub,
+            });
+            logger.info('hi');
+            (0, chai_1.expect)(outputStub).to.have.been.called;
+        });
+        it('should change output format', () => {
+            logger_1.Logger.configure({
+                outputFormat: 'legacy',
+            });
+            logger.info('hi');
+            const logArguments = JSON.parse(outputStub.args[0][0]);
+            (0, chai_1.expect)(logArguments.action).to.eql('hi');
+            (0, chai_1.expect)(logArguments.event).to.be.undefined;
+        });
+        it('should throw error on invalid config', () => {
+            try {
+                logger_1.Logger.configure({
+                    // @ts-expect-error TS2345
+                    invalid: true,
+                });
+                throw new Error('should throw');
+            }
+            catch (e) {
+                (0, chai_1.expect)(e.message).to.eql('Only the following keys are allowed: output,formatter,transformers,outputFormat');
+            }
+        });
+        it('should modify logged data based on transformers', () => {
+            logger_1.Logger.configure({
+                transformers: [(log) => Object.assign({ debug: true }, log)],
+            });
+            logger.info('hi');
+            const logArguments = JSON.parse(outputStub.args[0][0]);
+            (0, chai_1.expect)(logArguments.event.action).to.eql('hi');
+            (0, chai_1.expect)(logArguments.debug).to.eql(true);
+        });
+    });
+});

package/dist/setup.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/setup.spec.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sinon_1 = __importDefault(require("sinon"));
+const chai_1 = __importDefault(require("chai"));
+const sinon_chai_1 = __importDefault(require("sinon-chai"));
+chai_1.default.use(sinon_chai_1.default);
+afterEach(() => {
+    sinon_1.default.restore();
+});

package/dist/timer/timer.js

@@ -4,6 +4,8 @@ exports.Timer = void 0;
 const logger_1 = require("../logger/logger");
 const lodash_1 = require("lodash");
 class Timer {
+    start;
+    logger;
     constructor(logger) {
         this.logger = logger;
         this.start = new Date().getTime();

package/dist/timer/timer.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/timer/timer.spec.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = require("sinon");
+const logger_1 = require("../logger/logger");
+const timer_1 = require("./timer");
+describe('Timer', () => {
+    let clock;
+    beforeEach(() => {
+        clock = (0, sinon_1.useFakeTimers)();
+    });
+    afterEach(() => {
+        clock.restore();
+        logger_1.Logger.configure({ outputFormat: 'ecs' });
+    });
+    describe('legacy format', () => {
+        beforeEach(() => {
+            logger_1.Logger.configure({ outputFormat: 'legacy' });
+        });
+        it('should log elapsed time (legacy format)', () => {
+            const logger = new logger_1.Logger('test', false);
+            const infoStub = (0, sinon_1.stub)(logger, 'info');
+            const timer = new timer_1.Timer(logger);
+            clock.tick(100);
+            timer.info('time', { customer_id: 10 });
+            (0, chai_1.expect)(infoStub).to.have.been.calledWith('time', { customer_id: 10, duration: 100 });
+        });
+        it('should log elapsed time with error', () => {
+            const logger = new logger_1.Logger('test', false);
+            const errorStub = (0, sinon_1.stub)(logger, 'fromError');
+            const timer = new timer_1.Timer(logger);
+            const error = new Error('intended');
+            clock.tick(100);
+            timer.fromError('time', error, { customer_id: 10 });
+            (0, chai_1.expect)(errorStub).to.have.been.calledWith('time', error, { customer_id: 10, duration: 100 });
+        });
+        it('should log elapsed time with error', () => {
+            const logger = new logger_1.Logger('test', false);
+            const errorStub = (0, sinon_1.stub)(logger, 'warnFromError');
+            const timer = new timer_1.Timer(logger);
+            const error = new Error('intended');
+            clock.tick(100);
+            timer.warnFromError('time', error, { customer_id: 10 });
+            (0, chai_1.expect)(errorStub).to.have.been.calledWith('time', error, { customer_id: 10, duration: 100 });
+        });
+    });
+    describe('ecs format', () => {
+        it('should log elapsed time (legacy format)', () => {
+            const logger = new logger_1.Logger('test', false);
+            const infoStub = (0, sinon_1.stub)(logger, 'info');
+            const timer = new timer_1.Timer(logger);
+            clock.tick(100);
+            timer.info('time', { customer_id: 10 });
+            (0, chai_1.expect)(infoStub).to.have.been.calledWith('time', { customer_id: 10, event: { duration: 100 } });
+        });
+        it('should log elapsed time with error', () => {
+            const logger = new logger_1.Logger('test', false);
+            const errorStub = (0, sinon_1.stub)(logger, 'fromError');
+            const timer = new timer_1.Timer(logger);
+            const error = new Error('intended');
+            clock.tick(100);
+            timer.fromError('time', error, { customer_id: 10 });
+            (0, chai_1.expect)(errorStub).to.have.been.calledWith('time', error, { customer_id: 10, event: { duration: 100 } });
+        });
+        it('should log elapsed time with error', () => {
+            const logger = new logger_1.Logger('test', false);
+            const errorStub = (0, sinon_1.stub)(logger, 'warnFromError');
+            const timer = new timer_1.Timer(logger);
+            const error = new Error('intended');
+            clock.tick(100);
+            timer.warnFromError('time', error, { customer_id: 10 });
+            (0, chai_1.expect)(errorStub).to.have.been.calledWith('time', error, { customer_id: 10, event: { duration: 100 } });
+        });
+        it('should not overwrite ecs fields', () => {
+            const logger = new logger_1.Logger('test', false);
+            const logStub = (0, sinon_1.stub)(logger, 'warn');
+            const timer = new timer_1.Timer(logger);
+            clock.tick(100);
+            timer.warn('time', { event: { majomkutya: 1 } });
+            (0, chai_1.expect)(logStub).to.have.been.calledWith('time', { event: { duration: 100, majomkutya: 1 } });
+        });
+    });
+});

package/package.json

@@ -2,11 +2,15 @@
   "name": "@emartech/json-logger",
   "description": "Tiny and fast json logger with namespace support",
   "main": "dist/index.js",
+  "files": [
+    "dist",
+    "!**.spec.*"
+  ],
   "scripts": {
     "test": "mocha --require ts-node/register --extension ts ./src --recursive",
     "test:watch": "mocha --require ts-node/register --extension ts ./src --recursive --watch",
-    "lint": "eslint ./src/**/*.ts",
-    "lint:fix": "eslint ./src/**/*.ts --fix",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
     "build": "rm -rf dist && tsc --project ./tsconfig.json",
     "release": "CI=true semantic-release",
     "example-js": "DEBUG=* node examples/index-js.js",
@@ -32,35 +36,35 @@
     "json"
   ],
   "engines": {
-    "node": ">=14"
+    "node": ">=20"
   },
   "dependencies": {
     "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@types/chai": "4.3.3",
-    "@types/lodash": "4.14.198",
-    "@types/mocha": "10.0.0",
-    "@types/node": "18.7.23",
-    "@types/sinon": "10.0.13",
-    "@types/sinon-chai": "3.2.8",
-    "@typescript-eslint/eslint-plugin": "5.38.1",
-    "@typescript-eslint/parser": "5.38.1",
-    "axios": "0.30.0",
-    "chai": "4.3.6",
-    "eslint": "8.24.0",
+    "@types/chai": "4.3.20",
+    "@types/lodash": "4.17.20",
+    "@types/mocha": "10.0.10",
+    "@types/node": "20.19.22",
+    "@types/sinon": "17.0.4",
+    "@types/sinon-chai": "3.2.12",
+    "@typescript-eslint/eslint-plugin": "6.21.0",
+    "@typescript-eslint/parser": "6.21.0",
+    "axios": "1.11.0",
+    "chai": "4.5.0",
+    "eslint": "8.57.1",
     "eslint-config-emarsys": "5.1.0",
-    "eslint-config-prettier": "8.5.0",
-    "eslint-plugin-no-only-tests": "3.0.0",
-    "eslint-plugin-prettier": "4.2.1",
-    "eslint-plugin-security": "1.5.0",
-    "mocha": "10.0.0",
-    "prettier": "2.7.1",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-no-only-tests": "3.3.0",
+    "eslint-plugin-prettier": "5.5.4",
+    "eslint-plugin-security": "2.1.1",
+    "mocha": "10.8.2",
+    "prettier": "3.6.2",
     "semantic-release": "19.0.5",
-    "sinon": "14.0.0",
+    "sinon": "21.0.0",
     "sinon-chai": "3.7.0",
-    "ts-node": "10.9.1",
-    "typescript": "4.8.4"
+    "ts-node": "10.9.2",
+    "typescript": "5.9.3"
   },
-  "version": "8.1.0"
+  "version": "9.0.0"
 }

package/.nvmrc

@@ -1 +0,0 @@
-14.20.0

package/renovate.json

@@ -1,34 +0,0 @@
-{
-  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": [
-    "config:best-practices",
-    ":enableVulnerabilityAlerts",
-    ":pinOnlyDevDependencies",
-    ":semanticCommits",
-    ":separateMultipleMajorReleases",
-    "group:allNonMajor"
-  ],
-  "dependencyDashboardLabels": ["dependencies"],
-  "labels": ["dependencies"],
-  "lockFileMaintenance": {
-    "enabled": true,
-    "schedule": ["on the 1-7 day on Sunday"]
-  },
-  "packageRules": [
-    {
-      "groupName": "axios",
-      "matchPackageNames": ["axios"],
-      "matchUpdateTypes": ["minor"]
-    },
-    {
-      "groupName": "typescript",
-      "matchPackageNames": ["typescript"],
-      "matchUpdateTypes": ["minor"]
-    },
-    {
-      "matchPackageNames": ["axios", "typescript"],
-      "separateMultipleMinor": true
-    }
-  ],
-  "schedule": ["on the 1-7 day on Sunday"]
-}

package/repo-info.json

@@ -1,7 +0,0 @@
-{
-   "is_in_production": true,
-   "is_scannable": true,
-   "is_critical": false,
-   "contact": "guild-javascript@emarsys.com",
-   "hosted": null
-}

package/tsconfig.json

@@ -1,105 +0,0 @@
-{
-  "exclude": ["dist", "node_modules"],
-  "include": ["src/**/*.ts"],
-  "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig to read more about this file */
-
-    /* Projects */
-    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
-    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
-    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
-    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
-    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
-    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
-
-    /* Language and Environment */
-    "target": "es2020",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
-    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
-    "experimentalDecorators": true,                     /* Enable experimental support for TC39 stage 2 draft decorators. */
-    "emitDecoratorMetadata": true,                      /* Emit design-type metadata for decorated declarations in source files. */
-    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
-    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
-    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
-    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
-    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
-    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
-    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
-
-    /* Modules */
-    "module": "commonjs",                                /* Specify what module code is generated. */
-    "rootDir": "./src",                                  /* Specify the root folder within your source files. */
-    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
-    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
-    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
-    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
-    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
-    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
-    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
-    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files. */
-    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
-
-    /* JavaScript Support */
-    "allowJs": false,                                     /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
-    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
-    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
-
-    /* Emit */
-    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
-    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
-    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
-    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
-    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
-    "outDir": "./dist",                                  /* Specify an output folder for all emitted files. */
-    // "removeComments": true,                           /* Disable emitting comments. */
-    "noEmit": false,                                     /* Disable emitting files from a compilation. */
-    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
-    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
-    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
-    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
-    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
-    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
-    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
-    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
-    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
-    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
-    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
-    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
-    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
-    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
-    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
-
-    /* Interop Constraints */
-    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
-    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
-    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
-    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
-
-    /* Type Checking */
-    "strict": true,                                      /* Enable all strict type-checking options. */
-    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
-    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
-    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
-    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
-    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
-    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
-    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
-    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
-    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
-    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
-    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
-    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
-    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
-    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
-    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
-    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
-    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
-    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
-
-    /* Completeness */
-    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
-  }
-}