@viplance/nestjs-logger 0.3.8 → 0.4.1

package/src/index.ts

@@ -1,4 +1,4 @@
-export * from "./interceptors/log.interceptor";
-export * from "./log.module";
-export * from "./types/index";
-export * from "./services/log.service";
+export * from './interceptors/log.interceptor';
+export * from './log.module';
+export * from './types/index';
+export * from './services/log.service';

package/src/interceptors/log.interceptor.ts

@@ -1,8 +1,8 @@
-import type { CallHandler, NestInterceptor } from "@nestjs/common";
-import { Inject, Injectable } from "@nestjs/common";
-import { Observable, tap } from "rxjs";
-import { LogService } from "../services/log.service";
-import { ExecutionContextHost } from "@nestjs/core/helpers/execution-context-host";
+import type { CallHandler, NestInterceptor } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
+import { Observable, tap } from 'rxjs';
+import { LogService } from '../services/log.service';
+import { ExecutionContextHost } from '@nestjs/core/helpers/execution-context-host';
 
 @Injectable()
 export class LogInterceptor implements NestInterceptor {

package/src/log.module.ts

@@ -1,19 +1,26 @@
-import { Module, Global, HttpException } from "@nestjs/common";
-import { LogService } from "./services/log.service";
-import { MemoryDbService } from "./services/memory-db.service";
-import { LogInterceptor } from "./interceptors/log.interceptor";
-import { LogModuleOptions } from "./types";
-import { TypeOrmModule } from "@nestjs/typeorm";
-import querystring from "node:querystring";
-import { ApplicationConfig } from "@nestjs/core";
-import { join } from "node:path";
-import { LogAccessGuard } from "./guards/access.guard";
+import { Module, Global, HttpException } from '@nestjs/common';
+import { LogService } from './services/log.service';
+import { MemoryDbService } from './services/memory-db.service';
+import { LogInterceptor } from './interceptors/log.interceptor';
+import { LogModuleOptions } from './types';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import querystring from 'node:querystring';
+import { ApplicationConfig } from '@nestjs/core';
+import { join } from 'node:path';
+import { LogAccessGuard } from './guards/access.guard';
+import { WsService } from './services/ws.service';
 
 @Global()
 @Module({
   imports: [TypeOrmModule],
-  providers: [ApplicationConfig, LogAccessGuard, LogService, MemoryDbService],
-  exports: [TypeOrmModule, LogService, MemoryDbService],
+  providers: [
+    ApplicationConfig,
+    LogAccessGuard,
+    LogService,
+    MemoryDbService,
+    WsService,
+  ],
+  exports: [TypeOrmModule, LogService, MemoryDbService, WsService],
 })
 export class LogModule {
   public static async init(
@@ -23,6 +30,7 @@ export class LogModule {
     app.resolve(LogService);
 
     const logService: LogService = await app.resolve(LogService);
+    const wsService: WsService = await app.resolve(WsService);
     const logAccessGuard: LogAccessGuard = await app.get(LogAccessGuard);
 
     if (options) {
@@ -32,14 +40,34 @@ export class LogModule {
     app.useGlobalInterceptors(new LogInterceptor(logService)); // intercept all errors
 
     if (options?.path) {
-      app.useStaticAssets(join(__dirname, "..", "public"), {
+      app.useStaticAssets(join(__dirname, '..', 'public'), {
         prefix: options.path,
       });
 
       const httpAdapter = app.getHttpAdapter();
 
+      // frontend settings endpoint
+      httpAdapter.get(
+        join(options.path, 'settings'),
+        async (req: any, res: any) => {
+          logAccessGuard.canActivate(req);
+
+          const result: { [key: string]: any } = {};
+
+          if (options?.websocket) {
+            result.websocket = {
+              namespace: options.websocket?.namespace,
+              port: options.websocket?.port,
+              host: options.websocket?.host || req.headers?.host.split(':')[0],
+            };
+          }
+
+          res.json(result);
+        }
+      );
+
       // get all logs endpoint
-      httpAdapter.get(join(options.path, "api"), async (req: any, res: any) => {
+      httpAdapter.get(join(options.path, 'api'), async (req: any, res: any) => {
         logAccessGuard.canActivate(req);
 
         res.json(await logService.getAll());
@@ -47,19 +75,24 @@ export class LogModule {
 
       // delete log endpoint
       httpAdapter.delete(
-        join(options.path, "api"),
+        join(options.path, 'api'),
         async (req: any, res: any) => {
           logAccessGuard.canActivate(req);
 
-          const params = querystring.parse(req.url.split("?")[1]);
+          const params = querystring.parse(req.url.split('?')[1]);
 
           if (!params.id) {
-            throw new HttpException("id is required", 400);
+            throw new HttpException('id is required', 400);
           }
 
           res.json(await logService.delete(params.id.toString()));
         }
       );
+
+      // set up WebSocket connection
+      if (options?.websocket) {
+        wsService.setupConnection(options.websocket, options.key);
+      }
     }
 
     if (options?.database) {

package/src/services/log.service.ts

@@ -1,36 +1,55 @@
-import { Injectable, LoggerService, Scope } from "@nestjs/common";
-import { MemoryDbService } from "./memory-db.service";
-import { defaultTable } from "../defaults";
-import { Context, LogModuleOptions, LogType } from "../types";
+import {
+  Injectable,
+  LoggerService,
+  OnApplicationShutdown,
+  Scope,
+} from '@nestjs/common';
+import { MemoryDbService } from './memory-db.service';
+import { defaultTable } from '../defaults';
+import { Context, LogModuleOptions, LogType } from '../types';
 import {
   DataSource,
   DataSourceOptions,
   EntityManager,
   EntitySchema,
-} from "typeorm";
-import { createLogEntity } from "../entities/log.entity";
-import { ExecutionContextHost } from "@nestjs/core/helpers/execution-context-host";
-import { setInterval } from "timers";
-import { entity2table } from "../utils/entity2table";
+} from 'typeorm';
+import { createLogEntity } from '../entities/log.entity';
+import { ExecutionContextHost } from '@nestjs/core/helpers/execution-context-host';
+import { setInterval } from 'timers';
+import { entity2table } from '../utils/entity2table';
+import { WsService } from './ws.service';
+import { Subscription } from 'rxjs';
 
 @Injectable({ scope: Scope.TRANSIENT })
-export class LogService implements LoggerService {
+export class LogService implements LoggerService, OnApplicationShutdown {
   static connection: DataSource;
   static options: LogModuleOptions;
-  static Log: EntitySchema = createLogEntity(defaultTable, "memory");
+  static Log: EntitySchema = createLogEntity(defaultTable, 'memory');
   static timer: ReturnType<typeof setInterval>;
+  static subscription: Subscription;
 
   breadcrumbs: any[] = [];
 
-  constructor(private readonly memoryDbService: MemoryDbService) {}
+  constructor(
+    private readonly memoryDbService: MemoryDbService,
+    private readonly wsService: WsService
+  ) {}
+
+  onApplicationShutdown() {
+    if (LogService.timer) {
+      clearInterval(LogService.timer);
+    }
+  }
 
   async connectDb(options: LogModuleOptions): Promise<DataSource> {
     LogService.Log = createLogEntity(
       options.database?.collection || options.database?.table || defaultTable,
-      options.database?.type || "mongodb"
+      options.database?.type || 'mongodb'
     );
 
-    this.setOptions(options);
+    if (!LogService.options) {
+      this.setOptions(options);
+    }
 
     const dataSourceOptions = {
       type: options.database?.type,
@@ -43,9 +62,7 @@ export class LogService implements LoggerService {
     LogService.connection = new DataSource(dataSourceOptions);
     await LogService.connection.initialize();
 
-    if (dataSourceOptions.type !== "mongodb") {
-      // LogService.idName = "id";
-
+    if (dataSourceOptions.type !== 'mongodb') {
       const queryRunner = LogService.connection.createQueryRunner();
 
       try {
@@ -70,6 +87,24 @@ export class LogService implements LoggerService {
 
   setOptions(options: LogModuleOptions) {
     LogService.options = options;
+
+    if (options.websocket && !LogService.subscription) {
+      LogService.subscription = this.wsService.onMessage.subscribe(
+        async (message) => {
+          switch (message.action) {
+            case 'getLogs':
+              this.wsService.sendMessage({
+                action: 'list',
+                data: await this.getAll(),
+              });
+              break;
+            case 'delete':
+              this.delete(message.data._id);
+              break;
+          }
+        }
+      );
+    }
   }
 
   addBreadcrumb(breadcrumb: any) {
@@ -124,22 +159,26 @@ export class LogService implements LoggerService {
   async getAll(): Promise<any[]> {
     return this.getConnection().find(LogService.Log, {
       select: [
-        "_id",
-        "type",
-        "message",
-        "count",
-        "createdAt",
-        "updatedAt",
-        "context",
-        "trace",
-        "breadcrumbs",
+        '_id',
+        'type',
+        'message',
+        'count',
+        'createdAt',
+        'updatedAt',
+        'context',
+        'trace',
+        'breadcrumbs',
       ],
-      order: { updatedAt: "DESC" },
+      order: { updatedAt: 'DESC' },
     });
   }
 
-  async delete(id: string) {
-    return this.getConnection().delete(LogService.Log, id);
+  async delete(_id: string) {
+    this.wsService.sendMessage({
+      action: 'delete',
+      data: { _id },
+    });
+    return this.getConnection().delete(LogService.Log, _id);
   }
 
   private async smartInsert(data: {
@@ -153,26 +192,45 @@ export class LogService implements LoggerService {
     const connection = this.getConnection();
 
     // find the same log in DB
-    const log = await connection.findOne(LogService.Log, {
-      where: {
-        type: data.type,
-        message: data.message,
-      },
-    });
+    let log;
+
+    if (LogService.options.join) {
+      log = await connection.findOne(LogService.Log, {
+        where: {
+          type: data.type,
+          message: data.message,
+        },
+      });
+    }
 
     const context = data.context ? this.parseContext(data.context) : undefined;
 
     if (log) {
-      return await connection.update(LogService.Log, log["_id"], {
+      const updatedLog = {
+        context,
+        trace: data.trace,
+        breadcrumbs: this.breadcrumbs,
+        count: log.count + 1,
+        updatedAt: currentDate,
+      };
+
+      this.wsService.sendMessage({
+        action: 'update',
+        data: { ...log, ...updatedLog },
+      });
+
+      await connection.update(LogService.Log, log['_id'], {
         context,
         trace: data.trace,
         breadcrumbs: this.breadcrumbs,
         count: log.count + 1,
         updatedAt: currentDate,
       });
+
+      return { ...log, ...updatedLog };
     }
 
-    return await connection.insert(LogService.Log, {
+    const insertedLog = {
       type: data.type,
       message: data.message,
       context,
@@ -181,7 +239,27 @@ export class LogService implements LoggerService {
       count: 1,
       createdAt: currentDate,
       updatedAt: currentDate,
+    };
+
+    const res = await connection.insert(LogService.Log, insertedLog);
+    const _id = this.getNewObjectId(res);
+
+    this.wsService.sendMessage({
+      action: 'insert',
+      data: { _id, ...insertedLog },
     });
+
+    return { _id, ...insertedLog };
+  }
+
+  private getNewObjectId(result: any): string | number {
+    if (result.identifiers) {
+      return result.identifiers[0]._id;
+    }
+
+    console.log(result);
+
+    return result._id;
   }
 
   private getConnection(): EntityManager {
@@ -225,9 +303,9 @@ export class LogService implements LoggerService {
   private async checkRecords() {
     if (LogService.options?.maxSize) {
       const latest = await this.getConnection().find(LogService.Log, {
-        order: { updatedAt: "DESC" },
+        order: { updatedAt: 'DESC' },
         take: LogService.options?.maxSize,
-        select: ["_id"],
+        select: ['_id'],
       });
 
       const latestIds = latest.map((item) => item.id);
@@ -237,7 +315,7 @@ export class LogService implements LoggerService {
         .createQueryBuilder()
         .delete()
         .from(LogService.Log)
-        .where("_id NOT IN (:...ids)", { ids: latestIds })
+        .where('_id NOT IN (:...ids)', { ids: latestIds })
         .execute();
     }
   }

package/src/services/memory-db.service.ts

@@ -1,8 +1,8 @@
 // Memory DB layer
-import { Injectable } from "@nestjs/common";
-import { createHash, randomBytes } from "crypto";
-import { defaultTable } from "../defaults";
-import { EntitySchema, FindManyOptions } from "typeorm";
+import { Injectable } from '@nestjs/common';
+import { createHash, randomBytes } from 'crypto';
+import { defaultTable } from '../defaults';
+import { EntitySchema, FindManyOptions } from 'typeorm';
 
 const tables = [defaultTable];
 
@@ -20,8 +20,8 @@ export class MemoryDbService {
     const table = this.getTableName(entity);
 
     // generate new random _id
-    const randomData = randomBytes(24).toString("hex");
-    const _id = createHash("sha256").update(randomData).digest("hex");
+    const randomData = randomBytes(24).toString('hex');
+    const _id = createHash('sha256').update(randomData).digest('hex');
 
     this.db[table].push({
       ...data,
@@ -39,7 +39,7 @@ export class MemoryDbService {
     const table = this.getTableName(entity);
     let index: number | null = null;
 
-    if (typeof condition === "string") {
+    if (typeof condition === 'string') {
       index = this.findIndex(entity, { where: { _id: condition } });
     }
 
@@ -136,8 +136,8 @@ export class MemoryDbService {
     if (
       obj1 == null ||
       obj2 == null ||
-      typeof obj1 !== "object" ||
-      typeof obj2 !== "object"
+      typeof obj1 !== 'object' ||
+      typeof obj2 !== 'object'
     ) {
       return false;
     }

package/src/services/ws.d.ts

@@ -0,0 +1 @@
+declare module 'ws';

package/src/services/ws.service.ts

@@ -0,0 +1,110 @@
+import { Injectable } from '@nestjs/common';
+import WebSocket, { WebSocketServer } from 'ws';
+import { LogModuleOptions } from '../types';
+import { Subject } from 'rxjs';
+
+@Injectable()
+export class WsService {
+  public onMessage: Subject<any> = new Subject();
+  private ws: WebSocket | null = null;
+  private connected: boolean = false;
+  private connectionTimeout: number = 500;
+  private options: LogModuleOptions['websocket'] = {
+    port: 8080,
+    host: 'localhost',
+  };
+  private key: string = '';
+
+  setupConnection(options: LogModuleOptions['websocket'], key = '') {
+    this.options = {
+      ...this.options,
+      ...options,
+    };
+    this.key = key;
+
+    // Set up Web Socket server
+    if (this.ws) {
+      return;
+    }
+
+    const wsServer = new WebSocketServer({
+      retryCount: 1,
+      reconnectInterval: 1,
+      handshakeTimeout: this.connectionTimeout,
+      port: this.options?.port,
+    });
+
+    console.log(
+      `Logs WebSocket server is listening on port ${this.options.port}`
+    );
+
+    wsServer.on('error', this.handleError);
+    wsServer.on('open', () => this.handleOpenConnection());
+    wsServer.on('ping', () => this.ping(this.ws));
+    wsServer.on('close', () => this.closeConnection(this.ws));
+    wsServer.on('message', this.handleMessage);
+    wsServer.on('connection', (connection: WebSocket) => {
+      this.ws = connection;
+      connection.onmessage = this.handleMessage;
+    });
+  }
+
+  sendMessage(message: any) {
+    this.ws?.send(JSON.stringify(message));
+  }
+
+  private handleError = () => {
+    const serverUrl = this.getServerUrl();
+    console.error(`Server ${serverUrl} is not available.`);
+
+    setTimeout(this.setupConnection, this.connectionTimeout);
+  };
+
+  private closeConnection = (connection: any) => {
+    clearTimeout(connection.pingTimeout);
+
+    if (this.connected) {
+      console.log('Connection has been closed by server.');
+      this.connected = false;
+      this.handleError();
+    }
+  };
+
+  private ping = (connection: any) => {
+    console.log('Ping remote server.');
+    clearTimeout(connection.pingTimeout);
+
+    connection.pingTimeout = setTimeout(() => {
+      connection.terminate();
+    }, 30000 + this.connectionTimeout);
+  };
+
+  private handleMessage = (message: any) => {
+    try {
+      const data = JSON.parse((message.data || message).toString());
+
+      if (this.key !== '' && data.key !== this.key) {
+        throw new Error('WebSocket unauthorized');
+      }
+
+      if (this.options)
+        if (data.action) {
+          this.onMessage.next(data);
+        }
+    } catch (err) {
+      console.error(err);
+    }
+  };
+
+  private getServerUrl = (): string => {
+    return `${this.options?.secure ? 'wss' : 'ws'}://${this.options?.host}:${
+      this.options?.port
+    }`;
+  };
+
+  private handleOpenConnection = async () => {
+    this.connected = true;
+    const serverUrl = this.getServerUrl();
+    console.log(`${serverUrl} has been connected.`);
+  };
+}

package/src/types/index.ts

@@ -1,3 +1,3 @@
-export * from "./context.type";
-export * from "./log.type";
-export * from "./options.type";
+export * from './context.type';
+export * from './log.type';
+export * from './options.type';

package/src/types/log.type.ts

@@ -1,7 +1,7 @@
 export enum LogType {
-  LOG = "log",
-  ERROR = "error",
-  WARN = "warn",
-  DEBUG = "debug",
-  VERBOSE = "verbose",
+  LOG = 'log',
+  ERROR = 'error',
+  WARN = 'warn',
+  DEBUG = 'debug',
+  VERBOSE = 'verbose',
 }

package/src/types/options.type.ts

@@ -3,6 +3,7 @@ import { DataSourceOptions } from "typeorm";
 export type LogModuleOptions = {
   path?: string;
   key?: string; // access key
+  join?: boolean; // merge the message duplicates
   maxRecords?: number; // max log records
   maxAge?: number; // in days
   maxSize?: number; // in megabytes
@@ -12,4 +13,10 @@ export type LogModuleOptions = {
     table?: string;
     collection?: string;
   };
+  websocket?: {
+    port?: number;
+    namespace?: string;
+    host?: string;
+    secure?: boolean;
+  };
 };

package/src/utils/entity2table.ts

@@ -1,5 +1,5 @@
-import { EntitySchema, Table } from "typeorm";
-import { defaultTable } from "../defaults";
+import { EntitySchema, Table } from 'typeorm';
+import { defaultTable } from '../defaults';
 
 export function entity2table(entity: EntitySchema): Table {
   return new Table({
@@ -9,7 +9,7 @@ export function entity2table(entity: EntitySchema): Table {
       type: resolveColumnType(col?.type),
       isPrimary: !!col?.primary,
       isGenerated: !!col?.generated,
-      generationStrategy: col?.generated ? "increment" : undefined,
+      generationStrategy: col?.generated ? 'increment' : undefined,
       isUnique: !!col?.unique,
       isNullable: !!col?.nullable,
       default: col?.default,
@@ -20,14 +20,14 @@ export function entity2table(entity: EntitySchema): Table {
 function resolveColumnType(type: any): string {
   switch (type) {
     case String:
-      return "text";
+      return 'text';
     case Number:
-      return "int";
+      return 'int';
     case Date:
-      return "timestamp";
+      return 'timestamp';
     case Boolean:
-      return "boolean";
+      return 'boolean';
     default:
-      return "text";
+      return 'text';
   }
 }