@emartech/json-logger 7.2.0 → 7.2.1

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: Partial<LoggerConfig>): void;
-    static _validate(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,14 +10,14 @@ 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) {
+    static validate(options) {
         Object.keys(options).forEach((key) => {
             if (!allowedKeys.includes(key)) {
                 throw new Error('Only the following keys are allowed: formatter, output');
@@ -25,32 +25,44 @@ class Logger {
         });
     }
     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);
+        this.log('fatal', action, data);
     }
-    _log(level, action, data) {
-        if (!this._enabled) {
+    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);
+    }
+    log(level, action, data) {
+        if (!this.enabled) {
             return;
         }
         let dataToLog = Object.assign({
-            name: this._namespace,
+            name: this.namespace,
             action: action,
             level: config_1.config.levels[level].number,
             time: new Date().toISOString(),
@@ -60,44 +72,32 @@ class Logger {
         });
         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) {
+    shortenStackTrace(stack) {
         if (!stack) {
             return;
         }
         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;
     }
-    _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 {};
         }
@@ -106,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,
         };
     }
 }

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

@@ -60,5 +60,5 @@
     "url": "https://github.com/emartech/json-logger-js/issues"
   },
   "homepage": "https://github.com/emartech/json-logger-js#readme",
-  "version": "7.2.0"
+  "version": "7.2.1"
 }