@punks/backend-core 0.0.48 → 0.0.50

package/dist/cjs/types/abstractions/logging.d.ts

@@ -10,12 +10,12 @@ export declare enum MetaSerializationType {
     JSON = 1
 }
 export interface ILoggerProvider {
-    debug(message: string, meta?: any): void;
-    info(message: string, meta?: any): void;
-    warn(message: string, meta?: any): void;
-    error(message: string, meta?: any): void;
-    fatal(message: string, meta?: any): void;
-    exception(message: string, error: Error, meta?: any): void;
+    debug(loggerName: string, message: string, meta?: any): void;
+    info(loggerName: string, message: string, meta?: any): void;
+    warn(loggerName: string, message: string, meta?: any): void;
+    error(loggerName: string, message: string, meta?: any): void;
+    fatal(loggerName: string, message: string, meta?: any): void;
+    exception(loggerName: string, message: string, error: Error, meta?: any): void;
 }
 export interface ILogger {
     debug(message: string, meta?: any): void;

package/dist/cjs/types/logging/concrete/consoleLogger.d.ts

@@ -0,0 +1,9 @@
+import { ILoggerProvider } from "../../abstractions";
+export declare class ConsoleLogger implements ILoggerProvider {
+    debug(loggerName: string, message: string, meta?: any): void;
+    info(loggerName: string, message: string, meta?: any): void;
+    warn(loggerName: string, message: string, meta?: any): void;
+    error(loggerName: string, message: string, meta?: any): void;
+    fatal(loggerName: string, message: string, meta?: any): void;
+    exception(loggerName: string, message: string, error: Error, meta?: any): void;
+}

package/dist/cjs/types/logging/concrete/datadogLogger.d.ts

@@ -0,0 +1,19 @@
+import { ILoggerProvider } from "../../abstractions";
+export type DatadogLoggingSettings = {
+    service: string;
+    apiKey: string;
+    appName: string;
+    roleName: string;
+    environmentName: string;
+};
+export declare class DatadogLogger implements ILoggerProvider {
+    private readonly settings;
+    private readonly logger;
+    constructor(settings: DatadogLoggingSettings);
+    debug(loggerName: string, message: string, meta?: any): void;
+    info(loggerName: string, message: string, meta?: any): void;
+    warn(loggerName: string, message: string, meta?: any): void;
+    error(loggerName: string, message: string, meta?: any): void;
+    fatal(loggerName: string, message: string, meta?: any): void;
+    exception(loggerName: string, message: string, error: Error, meta?: any): void;
+}

package/dist/cjs/types/logging/concrete/index.d.ts

@@ -0,0 +1,2 @@
+export { ConsoleLogger } from "./consoleLogger";
+export { DatadogLogger } from "./datadogLogger";

package/dist/cjs/types/logging/service.d.ts

@@ -1,9 +1,17 @@
-import { ILogger, LogLevel, MetaSerializationType } from "../abstractions";
+import { ILogger, ILoggerProvider, LogLevel, MetaSerializationType } from "../abstractions";
+export type LoggerInstance = {
+    options: LoggerOptions;
+    provider: ILoggerProvider;
+};
+type LoggerOptions = {
+    enabled: boolean;
+    level: LogLevel;
+    loggerName?: string;
+    serialization: MetaSerializationType;
+};
 export declare class Log {
-    private static readonly options;
-    static setSerializationType(type: MetaSerializationType): void;
-    static setLevel(level: LogLevel): void;
-    static enable(): void;
-    static disable(): void;
+    private static readonly container;
+    static configure(instance: LoggerInstance): void;
     static getLogger(loggerName: string): ILogger;
 }
+export {};

package/dist/cjs/types/utils/objects/index.d.ts

@@ -8,6 +8,7 @@ export declare const buildObject: <T>(...props: {
 }[]) => T;
 export declare const mergeDeep: <T>(a: any, b: any) => T;
 export declare const jsonSerialize: (obj: any, options?: {
+    removeNonSerializableObjects?: boolean;
     removeCircularReferences?: boolean;
     stripBinaryData?: boolean;
     maxStringsLength?: number;

package/dist/esm/index.js

@@ -287,9 +287,22 @@ const mergeDeep = (a, b) => {
     }
     return c;
 };
+const isSerializable = (obj) => {
+    try {
+        JSON.stringify(obj);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
 const jsonSerialize = (obj, options) => {
-    const { removeCircularReferences = true, stripBinaryData = true, prettify = false, maxStringsLength, } = options ?? {};
+    const { removeNonSerializableObjects = true, removeCircularReferences = true, stripBinaryData = true, prettify = false, maxStringsLength, } = options ?? {};
     const replacer = (key, value) => {
+        // remove non serializable objects
+        if (removeNonSerializableObjects && !isSerializable(value)) {
+            return `<non serializable property ${typeof value}>`;
+        }
         // remove circular references
         const seen = new WeakSet();
         if (removeCircularReferences &&
@@ -28393,138 +28406,58 @@ const excelParse = (file, options) => {
         .map((x) => aggregateRow(header, x, options));
 };
 
-class DefaultLogger {
-    constructor(loggerName) {
+class InternalLogger {
+    constructor(loggerName, container) {
         this.loggerName = loggerName;
+        this.container = container;
     }
     debug(message, meta) {
-        if (meta) {
-            console.log(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`, meta);
-        }
-        else {
-            console.log(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`);
-        }
+        this.getEnabledInstances(LogLevel.Debug).forEach((x) => x.provider.debug(this.loggerName, message, this.serializeMeta(x.options, meta)));
     }
     info(message, meta) {
-        if (meta) {
-            console.info(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`, meta);
-        }
-        else {
-            console.info(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`);
-        }
+        this.getEnabledInstances(LogLevel.Info).forEach((x) => x.provider.info(this.loggerName, message, this.serializeMeta(x.options, meta)));
     }
     warn(message, meta) {
-        if (meta) {
-            console.warn(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`, meta);
-        }
-        else {
-            console.warn(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`);
-        }
+        this.getEnabledInstances(LogLevel.Warn).forEach((x) => x.provider.warn(this.loggerName, message, this.serializeMeta(x.options, meta)));
     }
     error(message, meta) {
-        if (meta) {
-            console.error(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`, meta);
-        }
-        else {
-            console.error(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`);
-        }
+        this.getEnabledInstances(LogLevel.Error).forEach((x) => x.provider.error(this.loggerName, message, this.serializeMeta(x.options, meta)));
     }
     fatal(message, meta) {
-        if (meta) {
-            console.error(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`, meta);
-        }
-        else {
-            console.error(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`);
-        }
+        this.getEnabledInstances(LogLevel.Fatal).forEach((x) => x.provider.fatal(this.loggerName, message, this.serializeMeta(x.options, meta)));
     }
     exception(message, error, meta) {
-        if (meta) {
-            console.error(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`, error, meta);
-        }
-        else {
-            console.error(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`, error);
-        }
+        this.getEnabledInstances(LogLevel.Error).forEach((x) => x.provider.exception(this.loggerName, message, error, this.serializeMeta(x.options, meta)));
     }
-}
-
-class InternalLogger {
-    constructor(options, provider) {
-        this.options = options;
-        this.provider = provider;
-    }
-    debug(message, meta) {
-        if (this.options.enabled && this.options.level === LogLevel.Debug) {
-            this.provider.debug(message, this.serializeMeta(meta));
-        }
-    }
-    info(message, meta) {
-        if (this.options.enabled && this.options.level <= LogLevel.Info) {
-            this.provider.info(message, this.serializeMeta(meta));
-        }
-    }
-    warn(message, meta) {
-        if (this.options.enabled && this.options.level <= LogLevel.Warn) {
-            this.provider.warn(message, this.serializeMeta(meta));
-        }
-    }
-    error(message, meta) {
-        if (this.options.enabled && this.options.level <= LogLevel.Error) {
-            this.provider.error(message, this.serializeMeta(meta));
-        }
+    getEnabledInstances(level) {
+        return this.container.instances.filter((x) => x.options.enabled && x.options.level <= level);
     }
-    fatal(message, meta) {
-        if (this.options.enabled && this.options.level <= LogLevel.Fatal) {
-            this.provider.fatal(message, this.serializeMeta(meta));
-        }
-    }
-    exception(message, error, meta) {
-        if (this.options.enabled && this.options.level <= LogLevel.Error) {
-            this.provider.exception(message, error, this.serializeMeta(meta));
-        }
-    }
-    serializeMeta(meta) {
-        const serializedMeta = jsonSerialize(meta, {
-            prettify: true,
-            stripBinaryData: true,
-        });
-        switch (this.options.serialization) {
+    serializeMeta(options, meta) {
+        const serializedMeta = meta
+            ? jsonSerialize(meta, {
+                prettify: true,
+                stripBinaryData: true,
+            })
+            : undefined;
+        switch (options.serialization) {
             case MetaSerializationType.JSON:
                 return serializedMeta;
             case MetaSerializationType.None:
             default:
-                return JSON.parse(serializedMeta);
+                return serializedMeta ? JSON.parse(serializedMeta) : undefined;
         }
     }
 }
-const getLogger = ({ options, loggerName, }) => {
-    return new InternalLogger(options, new DefaultLogger(loggerName));
-};
 class Log {
-    static setSerializationType(type) {
-        this.options.serialization = type;
-    }
-    static setLevel(level) {
-        this.options.level = level;
-        this.options.level = level;
-        this.options.enabled = true;
-    }
-    static enable() {
-        this.options.enabled = true;
-    }
-    static disable() {
-        this.options.enabled = false;
+    static configure(instance) {
+        this.container.instances.push(instance);
     }
     static getLogger(loggerName) {
-        return getLogger({
-            options: this.options,
-            loggerName,
-        });
+        return new InternalLogger(loggerName, this.container);
     }
 }
-Log.options = {
-    enabled: true,
-    level: LogLevel.Debug,
-    serialization: MetaSerializationType.None,
+Log.container = {
+    instances: [],
 };
 
 const logMemoryUsage = () => {