Collect data about time that is needed for request execution

Author: ivanvs

src/status.monitor.middleware.ts

@@ -0,0 +1,23 @@
+import { Injectable, NestMiddleware, MiddlewareFunction } from '@nestjs/common';
+import * as onHeaders from 'on-headers';
+import { StatusMonitoringService } from './status.monitoring.service';
+
+@Injectable()
+export class StatusMonitorMiddleware implements NestMiddleware {
+  constructor(
+    private readonly statusMonitoringService: StatusMonitoringService,
+  ) {}
+
+  resolve(...args: any[]): MiddlewareFunction {
+    return (req, res, next) => {
+      const startTime = process.hrtime();
+      onHeaders(res, () => {
+        this.statusMonitoringService.collectResponseTime(
+          res.statusCode,
+          startTime,
+        );
+      });
+      next();
+    };
+  }
+}

src/status.monitor.module.ts

@@ -1,10 +1,17 @@
-import { Module } from '@nestjs/common';
+import { Module, MiddlewareConsumer, RequestMethod } from '@nestjs/common';
 import { StatusMonitorController } from './status.monitor.controller';
 import { StatusMonitorGateway } from './status.monitor.gateway';
 import { StatusMonitoringService } from './status.monitoring.service';
+import { StatusMonitorMiddleware } from './status.monitor.middleware';
 
 @Module({
   controllers: [StatusMonitorController],
   providers: [StatusMonitorGateway, StatusMonitoringService],
 })
-export class StatusMonitorModule {}
+export class StatusMonitorModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer
+      .apply(StatusMonitorMiddleware)
+      .forRoutes({ path: '*', method: RequestMethod.ALL });
+  }
+}

src/status.monitoring.service.ts

@@ -88,4 +88,34 @@ export class StatusMonitoringService {
   getData() {
     return this.spans;
   }
+
+  collectResponseTime(statusCode, startTime) {
+    const diff = process.hrtime(startTime);
+    const responseTime = (diff[0] * 1e3 + diff[1]) * 1e-6;
+    const category = Math.floor(statusCode / 100);
+
+    console.log(responseTime);
+    this.spans.forEach(span => {
+      const last = span.responses[span.responses.length - 1];
+
+      if (
+        last !== undefined &&
+        last.timestamp / 1000 + span.interval > Date.now() / 1000
+      ) {
+        last[category] += 1;
+        last.count += 1;
+        last.mean += (responseTime - last.mean) / last.count;
+      } else {
+        span.responses.push({
+          2: category === 2 ? 1 : 0,
+          3: category === 3 ? 1 : 0,
+          4: category === 4 ? 1 : 0,
+          5: category === 5 ? 1 : 0,
+          count: 1,
+          mean: responseTime,
+          timestamp: Date.now(),
+        });
+      }
+    });
+  }
 }