@emartech/json-logger 7.1.0 → 7.2.1

package/.github/workflows/dev.yml

@@ -0,0 +1,20 @@
+name: Development
+
+on:
+  push:
+    branches: [ '*', '*/*', '**', '!master', '!main' ]
+  pull_request:
+    branches: [ master, main ]
+
+jobs:
+  init:
+    name: Init
+    uses: ./.github/workflows/_init.yml
+
+  test:
+    name: Test
+    uses: ./.github/workflows/_test.yml
+    needs: [ init ]
+    with:
+      NODE_VERSION: ${{ needs.init.outputs.NODE_VERSION }}
+      NODE_CACHE_KEY: ${{ needs.init.outputs.NODE_CACHE_KEY }}

package/.github/workflows/{main.yml → release.yml}

@@ -1,4 +1,4 @@
-name: Test and Release
+name: Release
 
 on:
   push:

package/README.md

@@ -10,6 +10,7 @@ npm install @emartech/json-logger
 ```
 
 
+
 ### Usage
 
 #### Script

package/dist/enabled/enabled.d.ts

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

package/dist/enabled/enabled.js

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

package/dist/formatter/index.d.ts

@@ -1,6 +1,4 @@
-import { jsonFormatter } from './json';
-import { logentriesFormatter } from './logentries';
 export declare const formatter: {
-    json: typeof jsonFormatter;
-    logentries: typeof logentriesFormatter;
+    json: (log: unknown) => string;
+    logentries: (data: Record<string, unknown>) => string;
 };

package/dist/formatter/index.js

@@ -5,5 +5,5 @@ const json_1 = require("./json");
 const logentries_1 = require("./logentries");
 exports.formatter = {
     json: json_1.jsonFormatter,
-    logentries: logentries_1.logentriesFormatter
+    logentries: logentries_1.logentriesFormatter,
 };

package/dist/formatter/json.d.ts

@@ -1 +1 @@
-export declare function jsonFormatter(log: unknown): string;
+export declare const jsonFormatter: (log: unknown) => string;

package/dist/formatter/json.js

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

package/dist/formatter/logentries.d.ts

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

package/dist/formatter/logentries.js

@@ -15,10 +15,9 @@ const convertToTag = (value, key) => {
     }
     return key + '=' + value;
 };
-function logentriesFormatter(data) {
-    return Object
-        .keys(data)
-        .map(key => convertToTag(data[key], key))
+const logentriesFormatter = (data) => {
+    return Object.keys(data)
+        .map((key) => convertToTag(data[key], key))
         .join(' ');
-}
+};
 exports.logentriesFormatter = logentriesFormatter;

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export declare namespace createLogger {
     var getNamespaces: () => string;
     var configure: (options: LoggerConfig) => void;
     var formatter: {
-        json: typeof import("./formatter/json").jsonFormatter;
-        logentries: typeof import("./formatter/logentries").logentriesFormatter;
+        json: (log: unknown) => string;
+        logentries: (data: Record<string, unknown>) => string;
     };
 }

package/dist/logger/logger.d.ts

@@ -1,27 +1,15 @@
 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;
+    private readonly namespace;
+    private readonly enabled;
     constructor(namespace: string, enabled: boolean);
-    static configure(options: LoggerConfig): void;
-    static _validate(options: LoggerConfig): void;
+    static configure(options: Partial<LoggerConfig>): void;
+    private static validate;
     static config: LoggerConfig;
     isEnabled(): boolean;
     trace(action: string, data?: unknown): void;
@@ -30,26 +18,13 @@ export declare class Logger {
     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;
-    };
+    private log;
+    private shortenStackTrace;
+    private shortenData;
+    private getErrorDetails;
+    private getAxiosErrorDetails;
 }
-export {};

package/dist/logger/logger.js

@@ -10,58 +10,43 @@ const console_1 = require("../output/console");
 const allowedKeys = ['output', 'formatter', 'transformers'];
 class Logger {
     constructor(namespace, enabled) {
-        this._namespace = namespace;
-        this._enabled = enabled;
+        this.namespace = namespace;
+        this.enabled = enabled;
     }
     static configure(options) {
-        this._validate(options);
+        this.validate(options);
         Object.assign(Logger.config, options);
     }
-    static _validate(options) {
-        Object.keys(options).forEach(key => {
+    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;
+        return this.enabled;
     }
     trace(action, data = {}) {
-        this._log('trace', action, data);
+        this.log('trace', action, data);
     }
     debug(action, data = {}) {
-        this._log('debug', action, data);
+        this.log('debug', action, data);
     }
     info(action, data = {}) {
-        this._log('info', action, data);
+        this.log('info', action, data);
     }
     warn(action, data = {}) {
-        this._log('warn', action, data);
+        this.log('warn', action, data);
     }
     error(action, data = {}) {
-        this._log('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));
+        this.log('fatal', action, data);
     }
     customError(severity, action, error, data = {}) {
-        this._log(severity, action, Object.assign(this._getErrorDetails(error), data));
+        this.log(severity, action, Object.assign(this.getErrorDetails(error), data));
     }
     fromError(action, error, data = {}) {
         this.customError('error', action, error, data);
@@ -72,36 +57,47 @@ class Logger {
     timer() {
         return new timer_1.Timer(this);
     }
-    _shortenStackTrace(stack) {
+    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));
+    }
+    shortenStackTrace(stack) {
         if (!stack) {
             return;
         }
-        return stack.length > STACK_TRACE_LIMIT ?
-            stack.substring(0, STACK_TRACE_LIMIT) + ' ...' :
-            stack;
+        return stack.length > STACK_TRACE_LIMIT ? stack.substring(0, STACK_TRACE_LIMIT) + ' ...' : stack;
     }
-    _shortenData(data) {
+    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;
+        return stringifiedData.length > DATA_LIMIT ? stringifiedData.substring(0, DATA_LIMIT) + ' ...' : stringifiedData;
     }
-    _getErrorDetails(error) {
+    getErrorDetails(error) {
         if (!(error instanceof Object)) {
             return {};
         }
         const baseDetails = {
             error_name: error.name,
-            error_stack: this._shortenStackTrace(error.stack || ''),
+            error_stack: this.shortenStackTrace(error.stack || ''),
             error_message: error.message,
-            error_data: this._shortenData(error.data)
+            error_data: this.shortenData(error.data),
         };
-        return Object.assign(baseDetails, this._getAxiosErrorDetails(error));
+        return Object.assign(baseDetails, this.getAxiosErrorDetails(error));
     }
-    _getAxiosErrorDetails(error) {
+    getAxiosErrorDetails(error) {
         if (!error.isAxiosError) {
             return {};
         }
@@ -110,7 +106,7 @@ class Logger {
             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
+            response_data: error.response ? this.shortenData(error.response.data) : undefined,
         };
     }
 }
@@ -118,5 +114,5 @@ exports.Logger = Logger;
 Logger.config = {
     formatter: json_1.jsonFormatter,
     output: console_1.consoleOutput,
-    transformers: []
+    transformers: [],
 };

package/dist/output/console.d.ts

@@ -1 +1 @@
-export declare function consoleOutput(formattedLog: unknown): void;
+export declare const consoleOutput: (formattedLog: unknown) => void;

package/dist/output/console.js

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

package/dist/timer/timer.d.ts

@@ -1,7 +1,7 @@
 import { Logger } from '../logger/logger';
 export declare class Timer {
-    _logger: Logger;
-    _start: number;
+    private readonly start;
+    private readonly logger;
     constructor(logger: Logger);
     trace(action: string, data?: unknown): void;
     debug(action: string, data?: unknown): void;
@@ -11,5 +11,5 @@ export declare class Timer {
     fatal(action: string, data?: unknown): void;
     fromError(action: string, error: unknown, data?: unknown): void;
     warnFromError(action: string, error: unknown, data?: unknown): void;
-    _duration(): number;
+    private duration;
 }

package/dist/timer/timer.js

@@ -3,36 +3,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Timer = void 0;
 class Timer {
     constructor(logger) {
-        this._logger = logger;
-        this._start = new Date().getTime();
+        this.logger = logger;
+        this.start = new Date().getTime();
     }
     trace(action, data = {}) {
-        this._logger.trace(action, Object.assign({ duration: this._duration() }, data));
+        this.logger.trace(action, Object.assign({ duration: this.duration() }, data));
     }
     debug(action, data = {}) {
-        this._logger.debug(action, Object.assign({ duration: this._duration() }, data));
+        this.logger.debug(action, Object.assign({ duration: this.duration() }, data));
     }
     info(action, data = {}) {
-        this._logger.info(action, Object.assign({ duration: this._duration() }, data));
+        this.logger.info(action, Object.assign({ duration: this.duration() }, data));
     }
     warn(action, data = {}) {
-        this._logger.warn(action, Object.assign({ duration: this._duration() }, data));
+        this.logger.warn(action, Object.assign({ duration: this.duration() }, data));
     }
     error(action, data = {}) {
-        this._logger.error(action, Object.assign({ duration: this._duration() }, data));
+        this.logger.error(action, Object.assign({ duration: this.duration() }, data));
     }
     fatal(action, data = {}) {
-        this._logger.fatal(action, Object.assign({ duration: this._duration() }, 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));
+        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));
+        this.logger.warnFromError(action, error, Object.assign({ duration: this.duration() }, data));
     }
-    _duration() {
+    duration() {
         const end = new Date().getTime();
-        return end - this._start;
+        return end - this.start;
     }
 }
 exports.Timer = Timer;

package/package.json

@@ -3,9 +3,10 @@
   "description": "Tiny and fast json logger with namespace support",
   "main": "dist/index.js",
   "scripts": {
-    "test": "mocha --require ts-node/register ./src --recursive",
-    "test:watch": "mocha --require ts-node/register ./src --recursive --watch",
-    "lint": "eslint ./src/**/*.{ts,js}",
+    "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",
     "build": "rm -rf dist && tsc --project ./tsconfig.json",
     "release": "CI=true semantic-release",
     "example-js": "DEBUG=* node examples/index-js.js",
@@ -25,21 +26,31 @@
     "debug",
     "json"
   ],
-  "dependencies": {},
   "devDependencies": {
-    "@types/node": "18.7.14",
-    "@typescript-eslint/parser": "5.36.1",
+    "@types/chai": "4.3.3",
+    "@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.27.2",
     "chai": "4.3.6",
-    "eslint": "8.23.0",
+    "eslint": "8.24.0",
     "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",
+    "install": "0.13.0",
     "mocha": "10.0.0",
+    "npm": "8.19.2",
+    "prettier": "2.7.1",
     "semantic-release": "19.0.5",
     "sinon": "14.0.0",
     "sinon-chai": "3.7.0",
     "ts-node": "10.9.1",
-    "typescript": "4.8.3"
+    "typescript": "4.8.4"
   },
   "repository": {
     "type": "git",
@@ -49,5 +60,5 @@
     "url": "https://github.com/emartech/json-logger-js/issues"
   },
   "homepage": "https://github.com/emartech/json-logger-js#readme",
-  "version": "7.1.0"
+  "version": "7.2.1"
 }

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
-  "exclude": ["dist", "node_modules", "src/**/*.js"],
-  "include": ["src/**/*.ts", "src/**/*.js"],
+  "exclude": ["dist", "node_modules"],
+  "include": ["src/**/*.ts"],
   "compilerOptions": {
     /* Visit https://aka.ms/tsconfig to read more about this file */
 
@@ -41,7 +41,7 @@
     // "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": true,                                     /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    "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'. */
 

package/.eslintrc

@@ -1,25 +0,0 @@
-{
-  "env": {
-    "node": true,
-    "mocha": true,
-    "es6": true
-  },
-  "parser": "@typescript-eslint/parser",
-  "parserOptions": {
-    "ecmaFeatures": {
-      "impliedStrict": true
-    }
-  },
-  "globals": {
-    "expect": true
-  },
-  "rules": {
-    "security/detect-object-injection": 0,
-    "security/detect-non-literal-regexp": 0,
-    "no-unused-expressions": 0,
-    "func-style": 0
-  },
-  "extends": [
-    "emarsys"
-  ]
-}