@spinajs/internal-logger - npm Package Compare versions

Comparing version 2.0.45 to 2.0.46

lib/index.d.ts

 import { Bootstrapper } from "@spinajs/di";
-import { ILogEntry, LogLevel } from "@spinajs/log-common";
+import { ILogEntry, LogLevel, ILog, ILogTargetDesc, LogVariables } from "@spinajs/log-common";
 export declare class InternalLogger extends Bootstrapper {
+    protected theme: any[];
+    protected StdConsoleCallbackMap: {
+        5: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        6: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        999: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        2: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        3: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        0: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        1: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+        4: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
+    };
     bootstrap(): void;
     protected static LogBuffer: Map<string, ILogEntry[]>;
+    private static _write;
     static trace(message: string, name: string, ...args: any[]): void;
@@ -22,4 +58,43 @@ static trace(err: Error, message: string, name: string, ...args: any[]): void;
     static success(err: Error, message: string, name: string, ...args: any[]): void;
-    protected static write(err: Error | string, message: string | any[], level: LogLevel, name: string, ...args: any[]): void;
+    static write(err: Error | string, message: string | any[], level: LogLevel, name: string, vars: Record<string, unknown>, ...args: any[]): void;
+    static writeLogEntry(entry: ILogEntry): void;
     protected static writeInternal(msg: any, logName: string): void;
 }
+export declare class InternalLoggerProxy implements ILog {
+    Name: string;
+    protected variables?: Record<string, unknown>;
+    protected Parent?: ILog;
+    Targets: ILogTargetDesc[];
+    protected Variables: Record<string, any>;
+    Timers: Map<string, Date>;
+    constructor(Name: string, variables?: Record<string, unknown>, Parent?: ILog);
+    trace(message: string, ...args: any[]): void;
+    trace(err: Error, message: string, ...args: any[]): void;
+    trace(err: string | Error, message: string | any[], ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+    debug(err: Error, message: string, ...args: any[]): void;
+    debug(err: string | Error, message: string | any[], ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    info(err: Error, message: string, ...args: any[]): void;
+    info(err: string | Error, message: string | any[], ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    warn(err: Error, message: string, ...args: any[]): void;
+    warn(err: string | Error, message: string | any[], ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    error(err: Error, message: string, ...args: any[]): void;
+    error(err: string | Error, message: string | any[], ...args: any[]): void;
+    fatal(message: string, ...args: any[]): void;
+    fatal(err: Error, message: string, ...args: any[]): void;
+    fatal(err: string | Error, message: string | any[], ...args: any[]): void;
+    security(message: string, ...args: any[]): void;
+    security(err: Error, message: string, ...args: any[]): void;
+    security(err: string | Error, message: string | any[], ...args: any[]): void;
+    success(message: string, ...args: any[]): void;
+    success(err: Error, message: string, ...args: any[]): void;
+    success(err: string | Error, message: string | any[], ...args: any[]): void;
+    child(_name: string, _variables?: LogVariables): ILog;
+    write(entry: ILogEntry): Promise<PromiseSettledResult<void>[]>;
+    addVariable(name: string, value: unknown): void;
+    timeStart(name: string): void;
+    timeEnd(name: string): number;
+}

lib/index.js

@@ -31,5 +31,12 @@ "use strict";
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var InternalLogger_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InternalLogger = void 0;
+exports.InternalLoggerProxy = exports.InternalLogger = void 0;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
 const configuration_common_1 = require("@spinajs/configuration-common");
@@ -39,2 +46,3 @@ const di_1 = require("@spinajs/di");
 const _ = __importStar(require("lodash"));
+const chalk_1 = __importDefault(require("chalk"));
 /**
@@ -66,2 +74,16 @@ * This class is used only in some spinajs packages
 let InternalLogger = InternalLogger_1 = class InternalLogger extends di_1.Bootstrapper {
+    constructor() {
+        super(...arguments);
+        this.theme = [];
+        this.StdConsoleCallbackMap = {
+            [log_common_1.LogLevel.Error]: console.error,
+            [log_common_1.LogLevel.Fatal]: console.error,
+            [log_common_1.LogLevel.Security]: console.error,
+            [log_common_1.LogLevel.Info]: console.log,
+            [log_common_1.LogLevel.Success]: console.log,
+            [log_common_1.LogLevel.Trace]: console.debug,
+            [log_common_1.LogLevel.Debug]: console.debug,
+            [log_common_1.LogLevel.Warn]: console.warn,
+        };
+    }
     bootstrap() {
@@ -90,30 +112,59 @@ const write = () => {
         }
+        process.on("beforeExit", () => {
+            this.theme[log_common_1.LogLevel.Trace] = chalk_1.default.gray;
+            this.theme[log_common_1.LogLevel.Debug] = chalk_1.default.gray;
+            this.theme[log_common_1.LogLevel.Info] = chalk_1.default.white;
+            this.theme[log_common_1.LogLevel.Success] = chalk_1.default.white.bgGreen;
+            this.theme[log_common_1.LogLevel.Warn] = chalk_1.default.yellow;
+            this.theme[log_common_1.LogLevel.Error] = chalk_1.default.red;
+            this.theme[log_common_1.LogLevel.Fatal] = chalk_1.default.white.bgRed;
+            this.theme[log_common_1.LogLevel.Security] = chalk_1.default.yellow.bgRed;
+            // when application is about to exit, write all messages to console
+            // if buffer is not empty it mean, that we cannot write to normal logger
+            InternalLogger_1.LogBuffer.forEach((value, lName) => {
+                value.forEach((entry) => {
+                    this.StdConsoleCallbackMap[entry.Level](this.theme[entry.Level]((0, configuration_common_1.format)(entry.Variables, "${datetime} ${level} ${message} ${error} (" + lName + ")")));
+                });
+            });
+            InternalLogger_1.LogBuffer.clear();
+        });
     }
+    static _write(err, message, name, level, ...args) {
+        if (err instanceof Error) {
+            InternalLogger_1.write(err, message, level, name, {}, ...args);
+        }
+        else {
+            InternalLogger_1.write(null, err, level, message, {}, [name, ...args]);
+        }
+    }
     static trace(err, message, name, ...args) {
-        InternalLogger_1.write(err, message, log_common_1.LogLevel.Trace, name, ...args);
+        InternalLogger_1.write(err, message, log_common_1.LogLevel.Trace, name, {}, ...args);
     }
     static debug(err, message, name, ...args) {
-        InternalLogger_1.write(err, message, log_common_1.LogLevel.Debug, name, ...args);
+        InternalLogger_1._write(err, message, name, log_common_1.LogLevel.Debug, ...args);
     }
     static info(err, message, name, ...args) {
-        InternalLogger_1.write(err, message, log_common_1.LogLevel.Info, name, ...args);
+        InternalLogger_1._write(err, message, name, log_common_1.LogLevel.Info, ...args);
     }
     static warn(err, message, name, ...args) {
-        InternalLogger_1.write(err, message, log_common_1.LogLevel.Warn, name, ...args);
+        InternalLogger_1._write(err, message, name, log_common_1.LogLevel.Warn, ...args);
     }
     static error(err, message, name, ...args) {
-        InternalLogger_1.write(err, message, log_common_1.LogLevel.Error, name, ...args);
+        InternalLogger_1._write(err, message, name, log_common_1.LogLevel.Error, ...args);
     }
     static fatal(err, message, name, ...args) {
-        InternalLogger_1.write(err, message, log_common_1.LogLevel.Fatal, name, ...args);
+        InternalLogger_1._write(err, message, name, log_common_1.LogLevel.Fatal, ...args);
     }
     static security(err, message, name, ...args) {
-        InternalLogger_1.write(err, message, log_common_1.LogLevel.Security, name, ...args);
+        InternalLogger_1._write(err, message, name, log_common_1.LogLevel.Security, ...args);
     }
     static success(err, message, name, ...args) {
-        InternalLogger_1.write(err, message, log_common_1.LogLevel.Success, name, ...args);
+        InternalLogger_1._write(err, message, name, log_common_1.LogLevel.Success, ...args);
     }
-    static write(err, message, level, name, ...args) {
-        const msg = (0, log_common_1.createLogMessageObject)(err, message, level, name, {}, ...args);
-        const logName = name !== null && name !== void 0 ? name : message;
+    static write(err, message, level, name, vars, ...args) {
+        const msg = (0, log_common_1.createLogMessageObject)(err, message, level, name, vars, ...args);
+        InternalLogger_1.writeLogEntry(msg);
+    }
+    static writeLogEntry(entry) {
+        const logName = entry.Variables.logger;
         // when we have log system working, write directly to it
@@ -124,10 +175,10 @@ // first we must check if Configuration module is resolved
             if (di_1.DI.resolve("__log__", [logName])) {
-                writeLogEntry(msg, logName);
+                writeLogEntry(entry, logName);
             }
             else {
-                InternalLogger_1.writeInternal(msg, logName);
+                InternalLogger_1.writeInternal(entry, logName);
             }
         }
         else {
-            InternalLogger_1.writeInternal(msg, logName);
+            InternalLogger_1.writeInternal(entry, logName);
         }
@@ -149,2 +200,62 @@ }
 exports.InternalLogger = InternalLogger;
+class InternalLoggerProxy {
+    constructor(Name, variables, Parent) {
+        this.Name = Name;
+        this.variables = variables;
+        this.Parent = Parent;
+        this.Variables = {};
+        this.Timers = new Map();
+    }
+    trace(err, message, ...args) {
+        InternalLogger.trace(err, message, this.Name, ...args);
+    }
+    debug(err, message, ...args) {
+        InternalLogger.debug(err, message, this.Name, ...args);
+    }
+    info(err, message, ...args) {
+        InternalLogger.info(err, message, this.Name, ...args);
+    }
+    warn(err, message, ...args) {
+        InternalLogger.warn(err, message, this.Name, ...args);
+    }
+    error(err, message, ...args) {
+        InternalLogger.error(err, message, this.Name, ...args);
+    }
+    fatal(err, message, ...args) {
+        InternalLogger.fatal(err, message, this.Name, ...args);
+    }
+    security(err, message, ...args) {
+        InternalLogger.security(err, message, this.Name, ...args);
+    }
+    success(err, message, ...args) {
+        InternalLogger.success(err, message, this.Name, ...args);
+    }
+    child(_name, _variables) {
+        return this;
+    }
+    write(entry) {
+        Object.assign(entry.Variables, this.Variables);
+        InternalLogger.writeLogEntry(entry);
+        return Promise.allSettled([]);
+    }
+    addVariable(name, value) {
+        this.Variables[`${name}`] = value;
+    }
+    timeStart(name) {
+        if (this.Timers.has(name)) {
+            return;
+        }
+        this.Timers.set(name, new Date());
+    }
+    timeEnd(name) {
+        if (this.Timers.has(name)) {
+            const cTime = new Date();
+            const diff = cTime.getTime() - this.Timers.get(name).getTime();
+            this.Timers.delete(name);
+            return diff;
+        }
+        return 0;
+    }
+}
+exports.InternalLoggerProxy = InternalLoggerProxy;
 //# sourceMappingURL=index.js.map

package.json

 {
   "name": "@spinajs/internal-logger",
-  "version": "2.0.45",
+  "version": "2.0.46",
   "description": "internal logger used by some packages. do not use it in production environment",
@@ -17,4 +17,4 @@ "homepage": "https://github.com/spinajs/main#readme",
   "devDependencies": {
-    "@spinajs/configuration": "^2.0.45",
-    "@spinajs/log": "^2.0.45",
+    "@spinajs/configuration": "^2.0.46",
+    "@spinajs/log": "^2.0.46",
     "chai": "^4.3.7",
@@ -24,3 +24,3 @@ "sinon": "15.0.1"
   "dependencies": {
-    "@spinajs/di": "^2.0.45",
+    "@spinajs/di": "^2.0.46",
     "lodash": "^4.17.21"
@@ -46,3 +46,3 @@ },
   },
-  "gitHead": "3aa423c570eae952dc79fe6a4704c3d2ccc178be"
+  "gitHead": "bd560afd6c9a156071102cc6b4f36115b5498e9d"
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

27616

increased by80.37%

Lines of code

415

increased by81.22%

Dependency changes

• Updated@spinajs/di@^2.0.46