implemented the hooks

Author: nafiuishaaq

apps/api-service/src/performance-monitoring/__tests__/monitoring-hooks.service.spec.ts

@@ -0,0 +1,61 @@
+import { MonitoringHooksService } from '../services/monitoring-hooks.service';
+
+describe('MonitoringHooksService', () => {
+  let service: MonitoringHooksService;
+
+  beforeEach(() => {
+    service = new MonitoringHooksService();
+  });
+
+  it('increments counters using label-insensitive ordering', () => {
+    service.incrementCounter('http_requests_total', 1, {
+      statusCode: 200,
+      method: 'GET',
+    });
+    service.incrementCounter('http_requests_total', 2, {
+      method: 'GET',
+      statusCode: 200,
+    });
+
+    const snapshot = service.getSnapshot();
+
+    expect(snapshot.counters).toEqual([
+      {
+        name: 'http_requests_total',
+        labels: { method: 'GET', statusCode: '200' },
+        value: 3,
+      },
+    ]);
+  });
+
+  it('tracks gauges and histogram summaries', () => {
+    service.setGauge('http_requests_in_flight', 2, { method: 'POST' });
+    service.observeHistogram('http_request_duration_ms', 100, {
+      endpoint: '/api/scanner',
+    });
+    service.observeHistogram('http_request_duration_ms', 300, {
+      endpoint: '/api/scanner',
+    });
+
+    const snapshot = service.getSnapshot();
+
+    expect(snapshot.gauges).toEqual([
+      {
+        name: 'http_requests_in_flight',
+        labels: { method: 'POST' },
+        value: 2,
+      },
+    ]);
+    expect(snapshot.histograms).toEqual([
+      {
+        name: 'http_request_duration_ms',
+        labels: { endpoint: '/api/scanner' },
+        count: 2,
+        sum: 400,
+        min: 100,
+        max: 300,
+        average: 200,
+      },
+    ]);
+  });
+});

apps/api-service/src/performance-monitoring/controllers/metrics.controller.ts

@@ -0,0 +1,15 @@
+import { Controller, Get } from '@nestjs/common';
+import { ApiOperation, ApiTags } from '@nestjs/swagger';
+import { MonitoringHooksService } from '../services/monitoring-hooks.service';
+
+@ApiTags('Monitoring')
+@Controller('metrics')
+export class MetricsController {
+  constructor(private readonly monitoringHooksService: MonitoringHooksService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'Expose in-memory monitoring metrics snapshot' })
+  getMetrics() {
+    return this.monitoringHooksService.getSnapshot();
+  }
+}

apps/api-service/src/performance-monitoring/index.ts

@@ -0,0 +1,5 @@
+export * from './performance-monitoring.module';
+export * from './services/performance-metric.service';
+export * from './services/monitoring-hooks.service';
+export * from './middleware/performance-logging.middleware';
+export * from './entities/api-performance-metric.entity';

apps/api-service/src/performance-monitoring/middleware/performance-logging.middleware.ts

@@ -1,5 +1,6 @@
 import { Injectable, NestMiddleware, Logger } from '@nestjs/common';
 import { Request, Response, NextFunction } from 'express';
+import { MonitoringHooksService } from '../services/monitoring-hooks.service';
 import { PerformanceMetricService } from '../services/performance-metric.service';
 
 export interface ApiRequest extends Request {
@@ -11,7 +12,10 @@ export interface ApiRequest extends Request {
 export class PerformanceLoggingMiddleware implements NestMiddleware {
   private readonly logger = new Logger(PerformanceLoggingMiddleware.name);
 
-  constructor(private readonly performanceMetricService: PerformanceMetricService) {}
+  constructor(
+    private readonly performanceMetricService: PerformanceMetricService,
+    private readonly monitoringHooksService: MonitoringHooksService,
+  ) {}
 
   async use(req: ApiRequest, res: Response, next: NextFunction) {
     const requestId = req.headers['x-request-id'] as string || this.generateRequestId();
@@ -20,13 +24,28 @@ export class PerformanceLoggingMiddleware implements NestMiddleware {
     req.requestId = requestId;
     req.startTime = startTime;
 
-    // Capture response finish event
-    const originalSend = res.send;
-    res.send = (data: any) => {
+    this.monitoringHooksService.adjustGauge('http_requests_in_flight', 1, {
+      method: req.method,
+    });
+
+    res.on('finish', () => {
       const duration = Date.now() - startTime;
       const statusCode = res.statusCode;
-      
-      // Log performance metric asynchronously
+
+      this.monitoringHooksService.incrementCounter('http_requests_total', 1, {
+        method: req.method,
+        endpoint: this.categorizeEndpoint(req.path),
+        statusCode,
+      });
+      this.monitoringHooksService.adjustGauge('http_requests_in_flight', -1, {
+        method: req.method,
+      });
+      this.monitoringHooksService.observeHistogram('http_request_duration_ms', duration, {
+        method: req.method,
+        endpoint: this.categorizeEndpoint(req.path),
+        statusCode,
+      });
+
       this.logPerformance({
         method: req.method,
         path: req.path,
@@ -38,9 +57,7 @@ export class PerformanceLoggingMiddleware implements NestMiddleware {
       }).catch(err => {
         this.logger.error(`Failed to log performance metric: ${err.message}`);
       });
-
-      return originalSend.call(res, data);
-    };
+    });
 
     next();
   }

apps/api-service/src/performance-monitoring/performance-monitoring.module.ts

@@ -1,15 +1,32 @@
-import { Module } from '@nestjs/common';
+import { MiddlewareConsumer, Module, NestModule, RequestMethod } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { ApiPerformanceMetric, ApiPerformanceAggregate } from './entities/api-performance-metric.entity';
+import { MetricsController } from './controllers/metrics.controller';
+import { PerformanceLoggingMiddleware } from './middleware/performance-logging.middleware';
+import { MonitoringHooksService } from './services/monitoring-hooks.service';
 import { PerformanceMetricService } from './services/performance-metric.service';
 import { PerformanceController } from './controllers/performance.controller';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([ApiPerformanceMetric, ApiPerformanceAggregate]),
   ],
-  controllers: [PerformanceController],
-  providers: [PerformanceMetricService],
-  exports: [PerformanceMetricService],
+  controllers: [PerformanceController, MetricsController],
+  providers: [
+    PerformanceMetricService,
+    MonitoringHooksService,
+    PerformanceLoggingMiddleware,
+  ],
+  exports: [PerformanceMetricService, MonitoringHooksService],
 })
-export class PerformanceMonitoringModule {}
+export class PerformanceMonitoringModule implements NestModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer
+      .apply(PerformanceLoggingMiddleware)
+      .exclude(
+        { path: 'health', method: RequestMethod.ALL },
+        { path: 'metrics', method: RequestMethod.ALL },
+      )
+      .forRoutes({ path: '*', method: RequestMethod.ALL });
+  }
+}

apps/api-service/src/performance-monitoring/services/monitoring-hooks.service.ts

@@ -0,0 +1,158 @@
+import { Injectable } from '@nestjs/common';
+
+export interface MetricLabels {
+  [key: string]: string | number | boolean | undefined;
+}
+
+export interface CounterMetricSnapshot {
+  name: string;
+  labels: Record<string, string>;
+  value: number;
+}
+
+export interface GaugeMetricSnapshot {
+  name: string;
+  labels: Record<string, string>;
+  value: number;
+}
+
+export interface HistogramMetricSnapshot {
+  name: string;
+  labels: Record<string, string>;
+  count: number;
+  sum: number;
+  min: number;
+  max: number;
+  average: number;
+}
+
+export interface MonitoringSnapshot {
+  counters: CounterMetricSnapshot[];
+  gauges: GaugeMetricSnapshot[];
+  histograms: HistogramMetricSnapshot[];
+}
+
+interface HistogramMetricState {
+  count: number;
+  sum: number;
+  min: number;
+  max: number;
+}
+
+@Injectable()
+export class MonitoringHooksService {
+  private readonly counters = new Map<string, number>();
+  private readonly gauges = new Map<string, number>();
+  private readonly histograms = new Map<string, HistogramMetricState>();
+
+  incrementCounter(name: string, value = 1, labels?: MetricLabels): number {
+    const key = this.buildMetricKey(name, labels);
+    const next = (this.counters.get(key) || 0) + value;
+    this.counters.set(key, next);
+    return next;
+  }
+
+  setGauge(name: string, value: number, labels?: MetricLabels): number {
+    const key = this.buildMetricKey(name, labels);
+    this.gauges.set(key, value);
+    return value;
+  }
+
+  adjustGauge(name: string, delta: number, labels?: MetricLabels): number {
+    const key = this.buildMetricKey(name, labels);
+    const next = (this.gauges.get(key) || 0) + delta;
+    this.gauges.set(key, next);
+    return next;
+  }
+
+  observeHistogram(name: string, value: number, labels?: MetricLabels): HistogramMetricSnapshot {
+    const key = this.buildMetricKey(name, labels);
+    const current = this.histograms.get(key) || {
+      count: 0,
+      sum: 0,
+      min: value,
+      max: value,
+    };
+
+    const next: HistogramMetricState = {
+      count: current.count + 1,
+      sum: current.sum + value,
+      min: Math.min(current.min, value),
+      max: Math.max(current.max, value),
+    };
+
+    this.histograms.set(key, next);
+    return this.toHistogramSnapshot(key, next);
+  }
+
+  getSnapshot(): MonitoringSnapshot {
+    return {
+      counters: Array.from(this.counters.entries()).map(([key, value]) =>
+        this.toNumberSnapshot(key, value),
+      ),
+      gauges: Array.from(this.gauges.entries()).map(([key, value]) =>
+        this.toNumberSnapshot(key, value),
+      ),
+      histograms: Array.from(this.histograms.entries()).map(([key, value]) =>
+        this.toHistogramSnapshot(key, value),
+      ),
+    };
+  }
+
+  reset(): void {
+    this.counters.clear();
+    this.gauges.clear();
+    this.histograms.clear();
+  }
+
+  private buildMetricKey(name: string, labels?: MetricLabels): string {
+    return JSON.stringify({
+      name,
+      labels: this.normalizeLabels(labels),
+    });
+  }
+
+  private normalizeLabels(labels?: MetricLabels): Record<string, string> {
+    if (!labels) {
+      return {};
+    }
+
+    return Object.entries(labels)
+      .filter(([, value]) => value !== undefined)
+      .sort(([left], [right]) => left.localeCompare(right))
+      .reduce<Record<string, string>>((acc, [key, value]) => {
+        acc[key] = String(value);
+        return acc;
+      }, {});
+  }
+
+  private parseMetricKey(key: string): { name: string; labels: Record<string, string> } {
+    return JSON.parse(key) as { name: string; labels: Record<string, string> };
+  }
+
+  private toNumberSnapshot(
+    key: string,
+    value: number,
+  ): CounterMetricSnapshot | GaugeMetricSnapshot {
+    const parsed = this.parseMetricKey(key);
+    return {
+      ...parsed,
+      value,
+    };
+  }
+
+  private toHistogramSnapshot(
+    key: string,
+    histogram: HistogramMetricState,
+  ): HistogramMetricSnapshot {
+    const parsed = this.parseMetricKey(key);
+    return {
+      ...parsed,
+      count: histogram.count,
+      sum: histogram.sum,
+      min: histogram.min,
+      max: histogram.max,
+      average: histogram.count === 0 ? 0 : histogram.sum / histogram.count,
+    };
+  }
+}