feat(logging): scaffold centralized logging and observability foundation

Author: rabsqueen

src/logging/config/logger.config.ts

@@ -0,0 +1,23 @@
+import { utilities as nestWinstonModuleUtilities } from 'nest-winston';
+import { format, transports } from 'winston';
+
+export const loggerConfig = {
+  level: process.env.LOG_LEVEL ?? 'info',
+
+  transports: [
+    new transports.Console({
+      format: format.combine(
+        format.timestamp(),
+        format.errors({ stack: true }),
+        format.ms(),
+        nestWinstonModuleUtilities.format.nestLike(
+          process.env.APP_NAME ?? 'QuestService',
+          {
+            prettyPrint: true,
+            colors: process.env.NODE_ENV !== 'production',
+          },
+        ),
+      ),
+    }),
+  ],
+};

src/logging/logging.controller.ts

@@ -0,0 +1,30 @@
+import { Controller, Get } from '@nestjs/common';
+
+import { LoggingService } from './logging.service';
+
+@Controller('logs')
+export class LoggingController {
+  constructor(
+    private readonly loggingService: LoggingService,
+  ) {}
+
+  @Get('health')
+  health() {
+    return this.loggingService.health();
+  }
+
+  @Get('levels')
+  levels() {
+    return {
+      supported: [
+        'error',
+        'warn',
+        'info',
+        'debug',
+        'verbose',
+      ],
+      active:
+        process.env.LOG_LEVEL ?? 'info',
+    };
+  }
+}

src/logging/logging.service.ts

@@ -0,0 +1,87 @@
+import { Injectable, LoggerService } from '@nestjs/common';
+import { createLogger, Logger } from 'winston';
+
+import { loggerConfig } from './config/logger.config';
+
+@Injectable()
+export class LoggingService implements LoggerService {
+  private readonly logger: Logger = createLogger(loggerConfig);
+
+  log(message: unknown, context?: string): void {
+    this.logger.info(message, { context });
+  }
+
+  error(
+    message: unknown,
+    trace?: string,
+    context?: string,
+  ): void {
+    this.logger.error(message, {
+      trace,
+      context,
+    });
+  }
+
+  warn(message: unknown, context?: string): void {
+    this.logger.warn(message, { context });
+  }
+
+  debug(message: unknown, context?: string): void {
+    this.logger.debug(message, { context });
+  }
+
+  verbose(
+    message: unknown,
+    context?: string,
+  ): void {
+    this.logger.verbose(message, { context });
+  }
+
+  metric(
+    name: string,
+    value: number,
+    metadata?: Record<string, unknown>,
+  ) {
+    this.logger.info({
+      type: 'metric',
+      name,
+      value,
+      metadata,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  audit(
+    action: string,
+    metadata?: Record<string, unknown>,
+  ) {
+    this.logger.info({
+      type: 'audit',
+      action,
+      metadata,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  exception(
+    error: Error,
+    metadata?: Record<string, unknown>,
+  ) {
+    this.logger.error({
+      type: 'exception',
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+      metadata,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  health() {
+    return {
+      logger: 'healthy',
+      level: process.env.LOG_LEVEL ?? 'info',
+      timestamp: new Date().toISOString(),
+    };
+  }
+}