xcally-nest-library 0.0.32 → 0.0.34

package/package.json

@@ -1,11 +1,27 @@
 {
   "name": "xcally-nest-library",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "",
   "license": "UNLICENSED",
+  "scripts": {
+    "bump:patch": "npm version patch -m \"Bump version to %s\"",
+    "prepublishOnly": "npm run build",
+    "build": "tsc",
+    "build:watch": "rimraf dist && tsc-watch -b -v",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "prettier:check": "prettier --check ./**/*.{ts,js,json,*rc}",
+    "prettier:write": "prettier --write ./**/*.{ts,js,json,*rc}",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "lib:link": "pnpm link --global",
+    "lib:unlink": "pnpm unlink xcally-nest-libs --global"
+  },
   "dependencies": {
     "@nestjs/config": "^4.0.0",
     "class-transformer": "^0.5.1",
@@ -37,20 +53,5 @@
     "@nestjs/common": "^10.0.0 || ^11.0.0",
     "@nestjs/core": "^10.0.0 || ^11.0.0",
     "@nestjs/microservices": "^10.0.0 || ^11.0.0"
-  },
-  "scripts": {
-    "bump:patch": "npm version patch -m \"Bump version to %s\"",
-    "build": "tsc",
-    "build:watch": "rimraf dist && tsc-watch -b -v",
-    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
-    "prettier:check": "prettier --check ./**/*.{ts,js,json,*rc}",
-    "prettier:write": "prettier --write ./**/*.{ts,js,json,*rc}",
-    "start": "nest start",
-    "start:dev": "nest start --watch",
-    "start:debug": "nest start --debug --watch",
-    "start:prod": "node dist/main",
-    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
-    "lib:link": "pnpm link --global",
-    "lib:unlink": "pnpm unlink xcally-nest-libs --global"
   }
-}
+}

package/src/modules/logger/pino/constants.ts

@@ -0,0 +1 @@
+export const LOGGER_OPTIONS = 'LOGGER_OPTIONS';

package/src/modules/logger/pino/logger.module.ts

@@ -1,76 +1,100 @@
-import { Global, Module } from '@nestjs/common';
+import { DynamicModule, Global, Module } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { LoggerModule as LoggerModulePino } from 'nestjs-pino';
 import { LoggerService } from './logger.service';
+import { LOGGER_OPTIONS } from './constants';
+
+export interface LoggerModuleOptions {
+  'resource.service.name': string;
+  'resource.service.namespace': string;
+  'resource.service.version'?: string;
+  'resource.service.environment'?: string;
+  'resource.service.deployment.environment'?: string;
+  'resource.service.deployment.id'?: string;
+  'resource.service.deployment.revision'?: string;
+  autoLogging?: boolean;
+}
 
 @Global()
-@Module({
-  providers: [LoggerService],
-  exports: [LoggerService],
-  imports: [
-    LoggerModulePino.forRootAsync({
-      imports: [ConfigModule],
-      inject: [ConfigService],
-      useFactory: async (config: ConfigService) => {
-        const projectName = process.env.npm_package_name || 'default_project';
-        return {
-          pinoHttp: {
-            customLogLevel: (req, res) => {
-              if (res.statusCode >= 500) return 'error';
-              if (res.statusCode >= 400) return 'warn';
-              return 'info';
-            },
-            level: config.get('LOG_LEVEL') || 'info',
-            // customErrorMessage?: ((req: IM, res: SR, error: Error) => string) | undefined;
-            // customErrorMessage: (req, res, error) => {
-            //   return 'Auto generated error' + error?.message;
-            // },
-            // customSuccessMessage(req, res, responseTime) {
-            //   return 'Auto generated success';
-            // },
-            // autoLogging: true,
-            // level: config.get('LOG_LEVEL') || 'info',
-            // stream: pino.destination(`./logs/info.log`),
-            redact: {
-              paths: ['req.headers.cookie', 'req.headers.authorization'],
-            },
-            transport: {
-              targets: [
-                {
-                  level: 'debug',
-                  target: 'pino-pretty',
-                  options: {
-                    colorize: true,
-                  },
+export class LoggerModule {
+  static forRoot(options: LoggerModuleOptions): DynamicModule {
+    const loggerOptions = {
+      provide: LOGGER_OPTIONS,
+      useValue: options,
+    };
+
+    const providers = [LoggerService, loggerOptions];
+    const exports = [LoggerService, loggerOptions];
+    return {
+      module: LoggerModule,
+      providers,
+      exports,
+      imports: [
+        LoggerModulePino.forRootAsync({
+          imports: [ConfigModule],
+          inject: [ConfigService],
+          useFactory: async (config: ConfigService) => {
+            const projectName = process.env.npm_package_name || 'default_project';
+            return {
+              pinoHttp: {
+                customLogLevel: (req, res) => {
+                  if (res.statusCode >= 500) return 'error';
+                  if (res.statusCode >= 400) return 'warn';
+                  return 'info';
                 },
-                // {
-                //   level: 'error',
-                //   target: 'pino/file',
-                //   options: {
-                //     destination: './logs/error.log',
-                //   },
+                level: config.get('LOG_LEVEL') || 'info',
+                autoLogging: options.autoLogging || true,
+                // customErrorMessage?: ((req: IM, res: SR, error: Error) => string) | undefined;
+                // customErrorMessage: (req, res, error) => {
+                //   return 'Auto generated error' + error?.message;
+                // },
+                // customSuccessMessage(req, res, responseTime) {
+                //   return 'Auto generated success';
                 // },
-                {
-                  level: config.get('LOG_LEVEL') || 'info',
-                  target: 'pino/file',
-                  options: {
-                    destination: process.env.LOG_OUT_DIR
-                      ? process.env.LOG_OUT_DIR + `${projectName}.log`
-                      : `./logs/${projectName}.log`,
-                    mkdir: true,
-                    append: process.env.NODE_ENV !== 'production' ? false : true,
-                  },
+                // autoLogging: true,
+                // level: config.get('LOG_LEVEL') || 'info',
+                // stream: pino.destination(`./logs/info.log`),
+                redact: {
+                  paths: ['req.headers.cookie', 'req.headers.authorization'],
                 },
-              ],
-            },
-            // genReqId: () => { // Non't needed with pino instrumentation
-            //   const activeSpan = api.trace.getSpan(api.context.active());
-            //   return activeSpan.spanContext().traceId;
-            // },
+                transport: {
+                  targets: [
+                    {
+                      level: 'debug',
+                      target: 'pino-pretty',
+                      options: {
+                        colorize: true,
+                      },
+                    },
+                    // {
+                    //   level: 'error',
+                    //   target: 'pino/file',
+                    //   options: {
+                    //     destination: './logs/error.log',
+                    //   },
+                    // },
+                    {
+                      level: config.get('LOG_LEVEL') || 'info',
+                      target: 'pino/file',
+                      options: {
+                        destination: process.env.LOG_OUT_DIR
+                          ? process.env.LOG_OUT_DIR + `${projectName}.log`
+                          : `./logs/${projectName}.log`,
+                        mkdir: true,
+                        append: process.env.NODE_ENV !== 'production' ? false : true,
+                      },
+                    },
+                  ],
+                },
+                // genReqId: () => { // Non't needed with pino instrumentation
+                //   const activeSpan = api.trace.getSpan(api.context.active());
+                //   return activeSpan.spanContext().traceId;
+                // },
+              },
+            };
           },
-        };
-      },
-    }),
-  ],
-})
-export class LoggerModule {}
+        }),
+      ],
+    };
+  }
+}

package/src/modules/logger/pino/logger.service.ts

@@ -1,5 +1,7 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { PinoLogger } from 'nestjs-pino';
+import { LOGGER_OPTIONS } from './constants';
+import { LoggerModuleOptions } from './logger.module';
 /**
  * @interface LoggerMeta
  * @description Interface representing metadata for logging purposes.
@@ -12,19 +14,22 @@ interface LoggerMeta {
 }
 @Injectable()
 export class LoggerService {
-  constructor(private readonly logger: PinoLogger) {}
+  constructor(
+    @Inject(LOGGER_OPTIONS) private readonly loggerOptions: LoggerModuleOptions,
+    private readonly logger: PinoLogger,
+  ) {}
 
   debug(msg: string, meta?: LoggerMeta): void {
-    this.logger.debug({ meta }, msg);
+    this.logger.debug({ meta, ...this.loggerOptions }, msg);
   }
   warn(msg: string, meta?: LoggerMeta): void {
-    this.logger.warn({ meta }, msg);
+    this.logger.warn({ meta, ...this.loggerOptions }, msg);
   }
   error(msg: string, meta?: LoggerMeta): void {
-    this.logger.error({ meta }, msg);
+    this.logger.error({ meta, ...this.loggerOptions }, msg);
   }
   fatal(msg: string, meta?: LoggerMeta): void {
-    this.logger.fatal({ meta }, msg);
+    this.logger.fatal({ meta, ...this.loggerOptions }, msg);
   }
 
   info(msg: string, meta?: LoggerMeta): void {
@@ -37,10 +42,10 @@ export class LoggerService {
     //   span.end();
     // });
 
-    this.logger.info({ meta }, msg);
+    this.logger.info({ meta, ...this.loggerOptions }, msg);
   }
 
   trace(msg: string, meta?: LoggerMeta): void {
-    this.logger.trace({ meta }, msg);
+    this.logger.trace({ meta, ...this.loggerOptions }, msg);
   }
 }