@infineit/winston-logger 1.0.4 → 1.0.6

package/package.json

@@ -1,26 +1,25 @@
 {
-    "name": "@infineit/winston-logger",
-    "version": "1.0.4",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "scripts": {
-      "build": "tsc -p tsconfig.lib.json && npm run copy-package-json",
-      "copy-package-json": "cp package.json ../../dist/libs/nestjs/"
-    },
-    "dependencies": {
-      "morgan": "^1.10.0",
-      "nestjs-cls": "^3.6.0",
-      "reflect-metadata": "^0.1.13",
-      "rxjs": "^7.2.0",
-      "uuid": "^9.0.1",
-      "winston": "^3.11.0",
-      "winston-daily-rotate-file": "^4.7.1",
-      "winston-slack-webhook-transport": "^2.3.2"
-    },
-    "devDependencies": {
-      "@types/morgan": "^1.9.7",
-      "@types/uuid": "^9.0.6",
-      "@types/winston": "^2.4.4"
-    }
+  "name": "@infineit/winston-logger",
+  "version": "1.0.6",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.lib.json && npm run copy-package-json",
+    "copy-package-json": "cp package.json ../../dist/libs/nestjs/"
+  },
+  "dependencies": {
+    "morgan": "^1.10.0",
+    "nestjs-cls": "^3.6.0",
+    "reflect-metadata": "^0.1.13",
+    "rxjs": "^7.2.0",
+    "uuid": "^9.0.1",
+    "winston": "^3.11.0",
+    "winston-daily-rotate-file": "^4.7.1",
+    "winston-slack-webhook-transport": "^2.3.2"
+  },
+  "devDependencies": {
+    "@types/morgan": "^1.9.7",
+    "@types/uuid": "^9.0.6",
+    "@types/winston": "^2.4.4"
   }
-  
+}

package/src/config/domain/services/configService.ts

@@ -0,0 +1,57 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService as NestConfigService } from '@nestjs/config';
+
+@Injectable()
+export class ConfigService {
+  constructor(private configService: NestConfigService) {}
+
+  get isProduction(): boolean {
+    return this.environment.nodeEnv === 'production';
+  }
+
+  get isDevelopment(): boolean {
+    return this.environment.nodeEnv === 'development';
+  }
+
+  get isTest(): boolean {
+    return this.environment.nodeEnv === 'test';
+  }
+
+  get slackWebhookUrl(): string {
+    return this.environment.slack_webhook;
+  }
+
+  private get environment(): any {
+    return this.configService.getOrThrow('logger', {
+      infer: true,
+    });
+  }
+}
+
+// import { Injectable } from '@nestjs/common';
+// import { ConfigService as NestConfigService } from '@nestjs/config';
+
+// @Injectable()
+// export class ConfigService {
+//   constructor(private configService: NestConfigService) {}
+
+//   get isProduction(): boolean {
+//     return this.environment === 'production';
+//   }
+
+//   get isDevelopment(): boolean {
+//     return this.environment === 'development';
+//   }
+
+//   get isTest(): boolean {
+//     return this.environment === 'test';
+//   }
+
+//   get slackWebhookUrl(): string {
+//     return this.configService.get<string>('SLACK_INC_WEBHOOK_URL');
+//   }
+
+//   private get environment(): string {
+//     return this.configService.get<string>('NODE_ENV');
+//   }
+// }

package/src/config/infrastructure/nestjs/configModule.ts

@@ -0,0 +1,16 @@
+import { Global, Module } from '@nestjs/common';
+import { ConfigModule as NestConfigModule } from '@nestjs/config';
+import { ConfigService } from '@infineit/winston-logger/config/domain/services/configService';
+
+@Global()
+@Module({
+  imports: [
+    NestConfigModule.forRoot({
+      isGlobal: true,
+    }),
+  ],
+  controllers: [],
+  providers: [ConfigService],
+  exports: [ConfigService],
+})
+export class ConfigModule {}

package/src/context/domain/interfaces/contextStorageService.ts

@@ -0,0 +1,8 @@
+export const ContextStorageServiceKey = Symbol();
+
+export default interface ContextStorageService {
+  setContextId(contextId: string): void;
+  getContextId(): string;
+  get<T>(key: string): T | undefined;
+  set<T>(key: string, value: T): void;
+}

package/src/context/infrastructure/nestjs/contextModule.ts

@@ -0,0 +1,29 @@
+import { Global, Module } from '@nestjs/common';
+import { v4 } from 'uuid';
+import { ClsModule } from 'nestjs-cls';
+
+import { ContextStorageServiceKey } from '@infineit/winston-logger/context/domain/interfaces/contextStorageService';
+import NestjsClsContextStorageService from '@infineit/winston-logger/context/infrastructure/nestjs-cls/nestjsClsContextStorageService';
+
+@Global()
+@Module({
+  imports: [
+    ClsModule.forRoot({
+      global: true,
+      middleware: {
+        mount: true,
+        generateId: true,
+        idGenerator: (req: Request) => req.headers['x-correlation-id'] ?? v4(),
+      },
+    }),
+  ],
+  controllers: [],
+  providers: [
+    {
+      provide: ContextStorageServiceKey,
+      useClass: NestjsClsContextStorageService,
+    },
+  ],
+  exports: [ContextStorageServiceKey],
+})
+export class ContextModule {}

package/src/context/infrastructure/nestjs-cls/nestjsClsContextStorageService.ts

@@ -0,0 +1,26 @@
+import ContextStorageService from '@infineit/winston-logger/context/domain/interfaces/contextStorageService';
+import { CLS_ID, ClsService } from 'nestjs-cls';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export default class NestjsClsContextStorageService
+  implements ContextStorageService
+{
+  constructor(private readonly cls: ClsService) {}
+
+  public get<T>(key: string): T | undefined {
+    return this.cls.get(key);
+  }
+
+  public setContextId(id: string) {
+    this.cls.set(CLS_ID, id);
+  }
+
+  public getContextId(): string | undefined {
+    return this.cls.getId();
+  }
+
+  public set<T>(key: string, value: T): void {
+    this.cls.set(key, value);
+  }
+}

package/src/logger/domain/log.ts

@@ -0,0 +1,25 @@
+export enum LogLevel {
+  Emergency = 'emergency', // One or more systems are unusable.
+  Fatal = 'fatal', // A person must take an action immediately
+  Error = 'error', // Error events are likely to cause problems
+  Warn = 'warn', // Warning events might cause problems in the future and deserve eyes
+  Info = 'info', // Routine information, such as ongoing status or performance
+  Debug = 'debug', // Debug or trace information
+}
+
+export interface Log {
+  timestamp: number; // Unix timestamp
+  level: LogLevel; // Log level
+  message: string; // Log message
+  data: LogData; // Log data
+}
+
+export interface LogData {
+  organisation?: string; // Organization or project name
+  context?: string; // Bounded Context name
+  app?: string; // Application or Microservice name
+  sourceClass?: string; // Classname of the source
+  correlationId?: string; // Correlation ID
+  error?: Error; // Error object
+  props?: NodeJS.Dict<any>; // Additional custom properties
+}

package/src/logger/domain/logger.ts

@@ -0,0 +1,20 @@
+import { LogData, LogLevel } from '@infineit/winston-logger/logger/domain/log';
+
+export const LoggerBaseKey = Symbol();
+export const LoggerKey = Symbol();
+
+export default interface Logger {
+  log(
+    level: LogLevel,
+    message: string | Error,
+    data?: LogData,
+    profile?: string,
+  ): void;
+  debug(message: string, data?: LogData, profile?: string): void;
+  info(message: string, data?: LogData, profile?: string): void;
+  warn(message: string | Error, data?: LogData, profile?: string): void;
+  error(message: string | Error, data?: LogData, profile?: string): void;
+  fatal(message: string | Error, data?: LogData, profile?: string): void;
+  emergency(message: string | Error, data?: LogData, profile?: string): void;
+  startProfile(id: string): void;
+}

package/src/logger/domain/loggerService.ts

@@ -0,0 +1,90 @@
+import { Inject, Injectable, Scope } from '@nestjs/common';
+import { INQUIRER } from '@nestjs/core';
+import Logger, {
+  LoggerBaseKey,
+} from '@infineit/winston-logger/logger/domain/logger';
+import { LogData, LogLevel } from '@infineit/winston-logger/logger/domain/log';
+import { ConfigService } from '@nestjs/config';
+import ContextStorageService, {
+  ContextStorageServiceKey,
+} from '@infineit/winston-logger/context/domain/interfaces/contextStorageService';
+
+@Injectable({ scope: Scope.TRANSIENT })
+export default class LoggerService implements Logger {
+  private sourceClass: string;
+  private organisation: string;
+  private context: string;
+  private app: string;
+
+  public constructor(
+    @Inject(LoggerBaseKey) private logger: Logger,
+    configService: ConfigService,
+    @Inject(INQUIRER) parentClass: object,
+    @Inject(ContextStorageServiceKey)
+    private contextStorageService: ContextStorageService,
+  ) {
+    // Set the source class from the parent class
+    this.sourceClass = parentClass?.constructor?.name;
+
+    const config = configService.getOrThrow('logger', {
+      infer: true,
+    }) as any;
+
+    // Set the organization, context and app from the environment variables
+    // this.organisation = configService.get<string>('ORGANIZATION');
+    // this.context = configService.get<string>('CONTEXT');
+    // this.app = configService.get<string>('APP');
+    this.organisation = config.organisation;
+    this.context = config.context;
+    this.app = config.app;
+  }
+
+  public log(
+    level: LogLevel,
+    message: string | Error,
+    data?: LogData,
+    profile?: string,
+  ) {
+    return this.logger.log(level, message, this.getLogData(data), profile);
+  }
+
+  public debug(message: string, data?: LogData, profile?: string) {
+    return this.logger.debug(message, this.getLogData(data), profile);
+  }
+
+  public info(message: string, data?: LogData, profile?: string) {
+    return this.logger.info(message, this.getLogData(data), profile);
+  }
+
+  public warn(message: string | Error, data?: LogData, profile?: string) {
+    return this.logger.warn(message, this.getLogData(data), profile);
+  }
+
+  public error(message: string | Error, data?: LogData, profile?: string) {
+    return this.logger.error(message, this.getLogData(data), profile);
+  }
+
+  public fatal(message: string | Error, data?: LogData, profile?: string) {
+    return this.logger.fatal(message, this.getLogData(data), profile);
+  }
+
+  public emergency(message: string | Error, data?: LogData, profile?: string) {
+    return this.logger.emergency(message, this.getLogData(data), profile);
+  }
+
+  private getLogData(data?: LogData): LogData {
+    return {
+      ...data,
+      organisation: data?.organisation || this.organisation,
+      context: data?.context || this.context,
+      app: data?.app || this.app,
+      sourceClass: data?.sourceClass || this.sourceClass,
+      correlationId:
+        data?.correlationId || this.contextStorageService.getContextId(),
+    };
+  }
+
+  public startProfile(id: string) {
+    this.logger.startProfile(id);
+  }
+}

package/src/logger/infrastructure/nestjs/loggerModule.ts

@@ -0,0 +1,88 @@
+import {
+  Global,
+  Inject,
+  MiddlewareConsumer,
+  Module,
+  NestModule,
+} from '@nestjs/common';
+
+import WinstonLogger, {
+  WinstonLoggerTransportsKey,
+} from '@infineit/winston-logger/logger/infrastructure/winston/winstonLogger';
+import Logger, {
+  LoggerBaseKey,
+  LoggerKey,
+} from '@infineit/winston-logger/logger/domain/logger';
+import NestjsLoggerServiceAdapter from '@infineit/winston-logger/logger/infrastructure/nestjs/nestjsLoggerServiceAdapter';
+import SlackTransport from '@infineit/winston-logger/logger/infrastructure/winston/transports/slackTransport';
+import ConsoleTransport from '@infineit/winston-logger/logger/infrastructure/winston/transports/consoleTransport';
+import morgan from 'morgan';
+import FileTransport from '@infineit/winston-logger/logger/infrastructure/winston/transports/fileTransport';
+import { ConfigService } from '@infineit/winston-logger/config/domain/services/configService';
+import LoggerService from '@infineit/winston-logger/logger/domain/loggerService';
+
+@Global()
+@Module({
+  imports: [],
+  controllers: [],
+  providers: [
+    {
+      provide: LoggerBaseKey,
+      useClass: WinstonLogger,
+    },
+    {
+      provide: LoggerKey,
+      useClass: LoggerService,
+    },
+    {
+      provide: NestjsLoggerServiceAdapter,
+      useFactory: (logger: Logger) => new NestjsLoggerServiceAdapter(logger),
+      inject: [LoggerKey],
+    },
+
+    {
+      provide: WinstonLoggerTransportsKey,
+      useFactory: (configService: ConfigService) => {
+        const transports = [];
+
+        transports.push(ConsoleTransport.createColorize());
+
+        transports.push(FileTransport.create());
+
+        if (configService.isProduction) {
+          if (configService.slackWebhookUrl) {
+            transports.push(
+              SlackTransport.create(configService.slackWebhookUrl),
+            );
+          }
+        }
+
+        return transports;
+      },
+      inject: [ConfigService],
+    },
+  ],
+  exports: [LoggerKey, NestjsLoggerServiceAdapter],
+})
+export class LoggerModule implements NestModule {
+  public constructor(
+    @Inject(LoggerKey) private logger: Logger,
+    private configService: ConfigService,
+  ) {}
+
+  public configure(consumer: MiddlewareConsumer): void {
+    consumer
+      .apply(
+        morgan(this.configService.isProduction ? 'combined' : 'dev', {
+          stream: {
+            write: (message: string) => {
+              this.logger.debug(message, {
+                sourceClass: 'RequestLogger',
+              });
+            },
+          },
+        }),
+      )
+      .forRoutes('*');
+  }
+}

package/src/logger/infrastructure/nestjs/nestjsLoggerServiceAdapter.ts

@@ -0,0 +1,38 @@
+import { ConsoleLogger } from '@nestjs/common';
+import Logger from '@infineit/winston-logger/logger/domain/logger';
+import { LoggerService } from '@nestjs/common/services/logger.service';
+
+export default class NestjsLoggerServiceAdapter
+  extends ConsoleLogger
+  implements LoggerService
+{
+  public constructor(private logger: Logger) {
+    super();
+  }
+
+  public log(message: any, ...optionalParams: any[]) {
+    return this.logger.info(message, this.getLogData(optionalParams));
+  }
+
+  public error(message: any, ...optionalParams: any[]) {
+    return this.logger.error(message, this.getLogData(optionalParams));
+  }
+
+  public warn(message: any, ...optionalParams: any[]) {
+    return this.logger.warn(message, this.getLogData(optionalParams));
+  }
+
+  public debug(message: any, ...optionalParams: any[]) {
+    return this.logger.debug(message, this.getLogData(optionalParams));
+  }
+
+  public verbose(message: any, ...optionalParams: any[]) {
+    return this.logger.info(message, this.getLogData(optionalParams));
+  }
+
+  private getLogData(...optionalParams: any[]) {
+    return {
+      sourceClass: optionalParams[0] ? optionalParams[0] : undefined,
+    };
+  }
+}

package/src/logger/infrastructure/winston/transports/consoleTransport.ts

@@ -0,0 +1,70 @@
+import * as winston from 'winston';
+import { LogLevel } from '@infineit/winston-logger/logger/domain/log';
+
+enum LogColors {
+  red = '\x1b[31m',
+  green = '\x1b[32m',
+  yellow = '\x1b[33m',
+  blue = '\x1b[34m',
+  magenta = '\x1b[35m',
+  cyan = '\x1b[36m',
+  pink = '\x1b[38;5;206m',
+}
+
+export default class ConsoleTransport {
+  public static createColorize() {
+    return new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.printf((log) => {
+          const color = this.mapLogLevelColor(log.level as LogLevel);
+          const prefix = `${log.data.label ? `[${log.data.label}]` : ''}`;
+          return `${this.colorize(color, prefix + '  -')} ${log.timestamp}    ${
+            log.data.correlationId
+              ? `(${this.colorize(LogColors.cyan, log.data.correlationId)})`
+              : ''
+          } ${this.colorize(color, log.level.toUpperCase())} ${
+            log.data.sourceClass
+              ? `${this.colorize(LogColors.cyan, `[${log.data.sourceClass}]`)}`
+              : ''
+          } ${this.colorize(
+            color,
+            log.message + ' - ' + (log.data.error ? log.data.error : ''),
+          )}${
+            log.data.durationMs !== undefined
+              ? this.colorize(color, ' +' + log.data.durationMs + 'ms')
+              : ''
+          }${
+            log.data.stack ? this.colorize(color, `  - ${log.data.stack}`) : ''
+          }${
+            log.data.props
+              ? `\n  - Props: ${JSON.stringify(log.data.props, null, 4)}`
+              : ''
+          }`;
+        }),
+      ),
+    });
+  }
+
+  private static colorize(color: LogColors, message: string): string {
+    return `${color}${message}\x1b[0m`;
+  }
+
+  private static mapLogLevelColor(level: LogLevel): LogColors {
+    switch (level) {
+      case LogLevel.Debug:
+        return LogColors.blue;
+      case LogLevel.Info:
+        return LogColors.green;
+      case LogLevel.Warn:
+        return LogColors.yellow;
+      case LogLevel.Error:
+        return LogColors.red;
+      case LogLevel.Fatal:
+        return LogColors.magenta;
+      case LogLevel.Emergency:
+        return LogColors.pink;
+      default:
+        return LogColors.cyan;
+    }
+  }
+}

package/src/logger/infrastructure/winston/transports/fileTransport.ts

@@ -0,0 +1,14 @@
+import DailyRotateFile = require('winston-daily-rotate-file');
+
+export default class FileTransport {
+  public static create() {
+    return new DailyRotateFile({
+      dirname: 'logs',
+      filename: 'log-%DATE%.log',
+      datePattern: 'YYYY-MM-DD-HH',
+      zippedArchive: true,
+      maxSize: '20m',
+      maxFiles: '14d',
+    });
+  }
+}

package/src/logger/infrastructure/winston/transports/postgres-transport.ts

@@ -0,0 +1,37 @@
+/* eslint-disable prettier/prettier */
+import TransportStreamOptions from 'winston-transport';
+import TransportStream from 'winston-transport';
+import { PrismaClient } from '@prisma/client';
+
+interface PrismaTransportOptions extends TransportStreamOptions {
+    prisma: PrismaClient;
+}
+
+
+export class PrismaTransport extends TransportStream {
+    private prisma: PrismaClient;
+
+    constructor(options: PrismaTransportOptions) {
+        super(options);
+        this.prisma = options.prisma;
+    }
+
+    log(info: any, callback: () => void) {
+        setImmediate(() => this.emit('logged', info));
+
+        console.log("PRISMA A NA LOG AA AANVIYU", this.prisma)
+    
+        this.prisma.log.create({
+          data: {
+            level: info.level,
+            message: info.message,
+            meta: info.meta ? JSON.stringify(info.meta) : null,
+          },
+        }).then(() => callback())
+          .catch((err: any) => {
+            console.error('Error logging to PostgreSQL:', err);
+            callback();
+          });
+    }    
+
+}

package/src/logger/infrastructure/winston/transports/slackTransport.ts

@@ -0,0 +1,53 @@
+import SlackHook from 'winston-slack-webhook-transport';
+import { LogLevel } from '@infineit/winston-logger/logger/domain/log';
+
+export default class SlackTransport {
+  public static create(webhookUrl: string) {
+    return new SlackHook({
+      level: LogLevel.Fatal,
+      webhookUrl: webhookUrl,
+      formatter: (info) => {
+        const title =
+          '[' +
+          info.timestamp +
+          '] Fatal error registered [' +
+          info.data.label +
+          ']';
+        return {
+          text: title,
+          blocks: [
+            {
+              type: 'section',
+              fields: [
+                {
+                  type: 'mrkdwn',
+                  text: '*' + title + '*',
+                },
+              ],
+            },
+            {
+              type: 'section',
+              text: {
+                type: 'mrkdwn',
+                text: '*[' + info.data.sourceClass + ']* ' + info.message,
+              },
+            },
+          ],
+          attachments: [
+            {
+              type: 'mrkdwn',
+              text:
+                info.data && info.data.error
+                  ? '*Stack:* ' + info.data.error.stack
+                  : undefined,
+            },
+            {
+              type: 'mrkdwn',
+              text: '*Payload:* ' + JSON.stringify(info, null, 4),
+            },
+          ],
+        };
+      },
+    });
+  }
+}