@punks/backend-core 0.0.49 → 0.0.51

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/index.d.ts

@@ -1 +1,2 @@
 export { Log } from "./service";
+export * from "./concrete";

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/esm/index.js

@@ -1,6 +1,7 @@
 import { readdirSync, statSync, existsSync, mkdirSync } from 'fs';
 import path, { join } from 'path';
 import require$$1 from 'stream';
+import * as winston from 'winston';
 
 var LogLevel;
 (function (LogLevel) {
@@ -28406,141 +28407,160 @@ 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) {
+        this.getEnabledInstances(LogLevel.Debug).forEach((x) => x.provider.debug(this.loggerName, message, this.serializeMeta(x.options, meta)));
+    }
+    info(message, meta) {
+        this.getEnabledInstances(LogLevel.Info).forEach((x) => x.provider.info(this.loggerName, message, this.serializeMeta(x.options, meta)));
+    }
+    warn(message, meta) {
+        this.getEnabledInstances(LogLevel.Warn).forEach((x) => x.provider.warn(this.loggerName, message, this.serializeMeta(x.options, meta)));
+    }
+    error(message, meta) {
+        this.getEnabledInstances(LogLevel.Error).forEach((x) => x.provider.error(this.loggerName, message, this.serializeMeta(x.options, meta)));
+    }
+    fatal(message, meta) {
+        this.getEnabledInstances(LogLevel.Fatal).forEach((x) => x.provider.fatal(this.loggerName, message, this.serializeMeta(x.options, meta)));
+    }
+    exception(message, error, meta) {
+        this.getEnabledInstances(LogLevel.Error).forEach((x) => x.provider.exception(this.loggerName, message, error, this.serializeMeta(x.options, meta)));
+    }
+    getEnabledInstances(level) {
+        return this.container.instances.filter((x) => x.options.enabled && x.options.level <= level);
+    }
+    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 serializedMeta ? JSON.parse(serializedMeta) : undefined;
+        }
+    }
+}
+class Log {
+    static configure(instance) {
+        this.container.instances.push(instance);
+    }
+    static getLogger(loggerName) {
+        return new InternalLogger(loggerName, this.container);
+    }
+}
+Log.container = {
+    instances: [],
+};
+
+class ConsoleLogger {
+    debug(loggerName, message, meta) {
         if (meta) {
-            console.log(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`, meta);
+            console.log(`${loggerName ? `[${loggerName}] ` : ""}${message}`, meta);
         }
         else {
-            console.log(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`);
+            console.log(`${loggerName ? `[${loggerName}] ` : ""}${message}`);
         }
     }
-    info(message, meta) {
+    info(loggerName, message, meta) {
         if (meta) {
-            console.info(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`, meta);
+            console.info(`${loggerName ? `[${loggerName}] ` : ""}${message}`, meta);
         }
         else {
-            console.info(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`);
+            console.info(`${loggerName ? `[${loggerName}] ` : ""}${message}`);
         }
     }
-    warn(message, meta) {
+    warn(loggerName, message, meta) {
         if (meta) {
-            console.warn(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`, meta);
+            console.warn(`${loggerName ? `[${loggerName}] ` : ""}${message}`, meta);
         }
         else {
-            console.warn(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`);
+            console.warn(`${loggerName ? `[${loggerName}] ` : ""}${message}`);
         }
     }
-    error(message, meta) {
+    error(loggerName, message, meta) {
         if (meta) {
-            console.error(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`, meta);
+            console.error(`${loggerName ? `[${loggerName}] ` : ""}${message}`, meta);
         }
         else {
-            console.error(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`);
+            console.error(`${loggerName ? `[${loggerName}] ` : ""}${message}`);
         }
     }
-    fatal(message, meta) {
+    fatal(loggerName, message, meta) {
         if (meta) {
-            console.error(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`, meta);
+            console.error(`${loggerName ? `[${loggerName}] ` : ""}${message}`, meta);
         }
         else {
-            console.error(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`);
+            console.error(`${loggerName ? `[${loggerName}] ` : ""}${message}`);
         }
     }
-    exception(message, error, meta) {
+    exception(loggerName, message, error, meta) {
         if (meta) {
-            console.error(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`, error, meta);
+            console.error(`${loggerName ? `[${loggerName}] ` : ""}${message}`, error, meta);
         }
         else {
-            console.error(`${this.loggerName ? `[${this.loggerName}] ` : ""}${message}`, error);
+            console.error(`${loggerName ? `[${loggerName}] ` : ""}${message}`, error);
         }
     }
 }
 
-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));
-        }
-    }
-    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));
-        }
+const createHttpTransportOptions = (settings) => ({
+    host: "http-intake.logs.datadoghq.eu",
+    path: `/v1/input/${settings.apiKey}?ddsource=nodejs&service=${settings.service}`,
+    ssl: true,
+});
+const createLoggerInstance = (settings) => {
+    const logger = winston.createLogger({
+        level: "debug",
+        format: winston.format.combine(winston.format.timestamp({
+            format: "YYYY-MM-DD HH:mm:ss",
+        }), winston.format.errors({ stack: true }), winston.format.splat(), winston.format.json()),
+        defaultMeta: {
+            service: settings.service,
+            app: settings.appName,
+            role: settings.roleName,
+            environment: settings.environmentName,
+        },
+        transports: [
+            new winston.transports.Http(createHttpTransportOptions(settings)),
+        ],
+    });
+    logger.exceptions.handle(new winston.transports.Http(createHttpTransportOptions(settings)));
+    return logger;
+};
+const formatMessage = (loggerName, message) => `${loggerName ? `[${loggerName}] ` : ""}${message}`;
+class DatadogLogger {
+    constructor(settings) {
+        this.settings = settings;
+        this.logger = createLoggerInstance(this.settings);
     }
-    serializeMeta(meta) {
-        const serializedMeta = meta
-            ? jsonSerialize(meta, {
-                prettify: true,
-                stripBinaryData: true,
-            })
-            : undefined;
-        switch (this.options.serialization) {
-            case MetaSerializationType.JSON:
-                return serializedMeta;
-            case MetaSerializationType.None:
-            default:
-                return serializedMeta ? JSON.parse(serializedMeta) : undefined;
-        }
+    debug(loggerName, message, meta) {
+        this.logger.debug(formatMessage(loggerName, message), meta);
     }
-}
-const getLogger = ({ options, loggerName, }) => {
-    return new InternalLogger(options, new DefaultLogger(loggerName));
-};
-class Log {
-    static setSerializationType(type) {
-        this.options.serialization = type;
+    info(loggerName, message, meta) {
+        this.logger.info(formatMessage(loggerName, message), meta);
     }
-    static setLevel(level) {
-        this.options.level = level;
-        this.options.level = level;
-        this.options.enabled = true;
+    warn(loggerName, message, meta) {
+        this.logger.warn(formatMessage(loggerName, message), meta);
     }
-    static enable() {
-        this.options.enabled = true;
+    error(loggerName, message, meta) {
+        this.logger.error(formatMessage(loggerName, message), meta);
     }
-    static disable() {
-        this.options.enabled = false;
+    fatal(loggerName, message, meta) {
+        this.logger.error(formatMessage(loggerName, message), meta);
     }
-    static getLogger(loggerName) {
-        return getLogger({
-            options: this.options,
-            loggerName,
-        });
+    exception(loggerName, message, error, meta) {
+        this.logger.error(formatMessage(loggerName, message), error, meta);
     }
 }
-Log.options = {
-    enabled: true,
-    level: LogLevel.Debug,
-    serialization: MetaSerializationType.None,
-};
 
 const logMemoryUsage = () => {
     const usedMemory = process.memoryUsage();
@@ -28581,5 +28601,5 @@ const processArrayItemMove = (items, input) => {
     }));
 };
 
-export { ExcelKeyTransform, Log, LogLevel, MetaSerializationType, addTime, buildObject, buildTree, byField, byFieldDesc, camelToKebabCase, camelToSnakeCase, csvBuild, csvParse, distinct, distinctElements, ensureDirectory, ensureStartSlash, ensureTailingSlash, excelBuild, excelParse, first, flatten, getDirectoryFilePaths, getDirectoryPath, groupBy, indexes, isNullOrUndefined, iterate, joinPath, jsonDistinct, jsonSerialize, last, logMemoryUsage, mapOrThrow, mergeDeep, newUuid, notNull, notUndefined, pluralize, processArrayDifferences, processArrayItemMove, range, removeUndefinedProps, selectMany, sleep, sort, splitPath, subArrays, subtractTime, toCamelCase, toDict, toItemsDict, toItemsMap, toMap, toTitleCase, trim$1 as trim, trimEnd, trimStart };
+export { ConsoleLogger, DatadogLogger, ExcelKeyTransform, Log, LogLevel, MetaSerializationType, addTime, buildObject, buildTree, byField, byFieldDesc, camelToKebabCase, camelToSnakeCase, csvBuild, csvParse, distinct, distinctElements, ensureDirectory, ensureStartSlash, ensureTailingSlash, excelBuild, excelParse, first, flatten, getDirectoryFilePaths, getDirectoryPath, groupBy, indexes, isNullOrUndefined, iterate, joinPath, jsonDistinct, jsonSerialize, last, logMemoryUsage, mapOrThrow, mergeDeep, newUuid, notNull, notUndefined, pluralize, processArrayDifferences, processArrayItemMove, range, removeUndefinedProps, selectMany, sleep, sort, splitPath, subArrays, subtractTime, toCamelCase, toDict, toItemsDict, toItemsMap, toMap, toTitleCase, trim$1 as trim, trimEnd, trimStart };
 //# sourceMappingURL=index.js.map