@xrystal/core 3.17.3 → 3.17.5

package/README.md

@@ -1,14 +1,21 @@
 ##  **DOCUMENT**
 
 # LOG Schema
+     JS
      '
-          service: this.serviceName,
+          level
+          message
+          payload?
+          code?
+     '
+     KAFKA
+     '
+          service,
           level,
-
           message,
-          ...rest,
-          timestamp: new Date().toISOString(),
-
-          id: id || null,
-          env: this.environment
+          payload,
+          code,
+          timestamp: ISO String,
+          id,
+          env
      '

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Yusuf Yasir KAYGUSUZ",
   "name": "@xrystal/core",
-  "version": "3.17.3",
+  "version": "3.17.5",
   "description": "Project core for xrystal",
   "publishConfig": {
     "access": "public",

package/source/loader/logger/index.d.ts

@@ -1,12 +1,17 @@
 import winston from "winston";
 import "winston-daily-rotate-file";
 import { AsyncLocalStorage } from "node:async_hooks";
-import ConfigsService from "../configs";
-import { IService } from "../../utils";
+import { LoggerLayerEnum, IService } from "../../utils";
 interface CustomLogger extends winston.Logger {
     critical: winston.LeveledLogMethod;
     http: winston.LeveledLogMethod;
 }
+interface LogOptions {
+    level: LoggerLayerEnum;
+    message: any;
+    payload?: any;
+    code?: string | number;
+}
 export default class LoggerService implements IService {
     #private;
     static readonly storage: AsyncLocalStorage<Map<string, string>>;
@@ -14,19 +19,19 @@ export default class LoggerService implements IService {
     private kafkaProducer;
     private kafkaTopic;
     private isKafkaReady;
-    constructor({ configsService }: {
-        configsService: ConfigsService;
-    });
-    load: (config: Record<string, any>) => Promise<void>;
-    private safeReplacer;
-    private getTracingFormat;
-    private getConsoleFormat;
     winston: CustomLogger;
-    runWithId: <T>(id: string, callback: () => T) => T;
+    constructor(deps: any);
+    load: (config: Record<string, any>) => Promise<void>;
     winstonLoader: ({ loadPath, loggerLevel }: {
         loadPath: string;
         loggerLevel: string;
     }) => CustomLogger;
+    private safeReplacer;
+    private getTracingFormat;
+    private getConsoleFormat;
+    runWithId: <T>(id: string, callback: () => T) => T;
     private logToKafka;
+    log(level: LoggerLayerEnum, message: any, payload?: any, code?: string | number): void;
+    log(options: LogOptions): void;
 }
 export {};

package/source/loader/logger/index.js

@@ -37,10 +37,20 @@ export default class LoggerService {
     kafkaProducer = null;
     kafkaTopic = "";
     isKafkaReady = false;
+    winston;
     #configsService;
-    constructor({ configsService }) {
-        this.#configsService = configsService;
+    constructor(deps) {
+        if (!deps || !deps.configsService) {
+            throw new Error("LoggerService: configsService is required");
+        }
+        this.#configsService = deps.configsService;
         winston.addColors(customColors);
+        this.winston = winston.createLogger({
+            level: this.#configsService.all.systemLoggerLayer || 'info',
+            levels: customLevels,
+            format: this.getConsoleFormat(),
+            transports: [new winston.transports.Console()]
+        });
     }
     load = async (config) => {
         this.serviceName = config?.serviceName || "service";
@@ -74,45 +84,6 @@ export default class LoggerService {
             loggerLevel: config?.loggerLevel
         });
     };
-    safeReplacer = (key, value) => {
-        if (value instanceof Headers)
-            return Object.fromEntries(value.entries());
-        if (value instanceof Error)
-            return { message: value.message, stack: value.stack };
-        return value;
-    };
-    getTracingFormat = format((info) => {
-        const store = LoggerService.storage.getStore();
-        if (store && store.has("correlationId")) {
-            info.id = store.get("correlationId");
-        }
-        Object.keys(info).forEach(key => {
-            if (info[key] instanceof Headers) {
-                info[key] = Object.fromEntries(info[key].entries());
-            }
-        });
-        return info;
-    });
-    getConsoleFormat() {
-        return format.combine(this.getTracingFormat(), format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), format.colorize({ all: true }), format.printf((info) => {
-            const msg = typeof info.message === "object"
-                ? JSON.stringify(info.message, this.safeReplacer)
-                : info.message;
-            const idPart = info.id ? ` : id: ${info.id}` : "";
-            return `${info.timestamp} [${this.serviceName}] ${info.level}: ${msg}${idPart}`;
-        }));
-    }
-    winston = winston.createLogger({
-        level: "debug",
-        levels: customLevels,
-        format: this.getConsoleFormat(),
-        transports: [new winston.transports.Console()]
-    });
-    runWithId = (id, callback) => {
-        const store = new Map();
-        store.set("correlationId", id);
-        return LoggerService.storage.run(store, callback);
-    };
     winstonLoader = ({ loadPath, loggerLevel }) => {
         const { combine, timestamp, json, errors } = format;
         const tracing = this.getTracingFormat();
@@ -147,11 +118,46 @@ export default class LoggerService {
         });
         return this.winston;
     };
+    safeReplacer = (key, value) => {
+        if (value instanceof Headers)
+            return Object.fromEntries(value.entries());
+        if (value instanceof Error)
+            return { message: value.message, stack: value.stack };
+        return value;
+    };
+    getTracingFormat = format((info) => {
+        const store = LoggerService.storage.getStore();
+        if (store && store.has("correlationId")) {
+            info.id = store.get("correlationId");
+        }
+        Object.keys(info).forEach(key => {
+            if (info[key] instanceof Headers) {
+                info[key] = Object.fromEntries(info[key].entries());
+            }
+        });
+        return info;
+    });
+    getConsoleFormat() {
+        return format.combine(this.getTracingFormat(), format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), format.colorize({ all: true }), format.printf((info) => {
+            const msg = typeof info.message === "object"
+                ? JSON.stringify(info.message, this.safeReplacer)
+                : info.message;
+            const idPart = info.id ? ` : id: ${info.id}` : "";
+            const payloadPart = info.payload ? `\nPayload: ${JSON.stringify(info.payload, this.safeReplacer)}` : "";
+            const codePart = info.code ? ` [Code: ${info.code}]` : "";
+            return `${info.timestamp} [${this.serviceName}] ${info.level}${codePart}: ${msg}${idPart}${payloadPart}`;
+        }));
+    }
+    runWithId = (id, callback) => {
+        const store = new Map();
+        store.set("correlationId", id);
+        return LoggerService.storage.run(store, callback);
+    };
     async logToKafka(info) {
         if (!this.kafkaProducer || !this.isKafkaReady)
             return;
         try {
-            const { id, level, message, ...rest } = info;
+            const { id, level, message, payload, code } = info;
             await this.kafkaProducer.send({
                 topic: this.kafkaTopic,
                 messages: [{
@@ -159,7 +165,8 @@ export default class LoggerService {
                             service: this.serviceName,
                             level,
                             message,
-                            ...rest,
+                            payload,
+                            code,
                             timestamp: new Date().toISOString(),
                             id: id || null,
                             env: this.#configsService.all.env
@@ -171,4 +178,11 @@ export default class LoggerService {
             this.isKafkaReady = false;
         }
     }
+    log(arg1, arg2, arg3, arg4) {
+        const isObj = typeof arg1 === 'object' && arg1 !== null && 'level' in arg1;
+        const { level, message, payload, code } = isObj
+            ? arg1
+            : { level: arg1, message: arg2, payload: arg3, code: arg4 };
+        this.winston.log(LoggerLayerEnum[level].toLowerCase(), message, { payload, code });
+    }
 }