[93] fix: Connected Grafana Api to the response-time-interceptor

packages/common/test/interceptor/response-time.interceptor.spec.ts

@@ -1,11 +1,11 @@
-import { ResponseTimeInterceptor } from '../../src/interceptors/response-time.interceptor';
 import { ExecutionContext, CallHandler } from '@nestjs/common';
 import { of, throwError } from 'rxjs';
 import { Test, TestingModule } from '@nestjs/testing';
 import { Histogram } from 'prom-client';
-import * as fs from 'fs';
 import { performance } from 'perf_hooks';
+import { ResponseTimeInterceptor } from '../../src/interceptors/response-time.interceptor';
 
+// Mock dependencies
 jest.mock('prom-client', () => {
   const labels = jest.fn().mockReturnThis();
   const observe = jest.fn();
@@ -18,12 +18,6 @@ jest.mock('prom-client', () => {
   };
 });
 
-jest.mock('fs', () => ({
-  readFileSync: jest.fn(),
-  writeFileSync: jest.fn(),
-  existsSync: jest.fn(),
-}));
-
 jest.mock('perf_hooks', () => ({
   performance: {
     now: jest.fn(),
@@ -35,19 +29,19 @@ describe('ResponseTimeInterceptor', () => {
   let mockHistogram: Histogram;
   let mockExecutionContext: ExecutionContext;
   let mockCallHandler: CallHandler;
-  const jsonPath = 'path/to/json';
+
+  const grafanaUrl = 'http://localhost:7889';
+  const grafanaToken = '<GRAFANA_TOKEN>';
   const histogramTitle = 'test_histogram';
 
   beforeEach(async () => {
-    mockHistogram = new (jest.requireMock('prom-client')
-      .Histogram as jest.Mock)();
-
+    mockHistogram = new (jest.requireMock('prom-client').Histogram as jest.Mock)();
+
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         {
           provide: ResponseTimeInterceptor,
-          useFactory: () =>
-            new ResponseTimeInterceptor(histogramTitle, jsonPath),
+          useFactory: () => new ResponseTimeInterceptor(histogramTitle, grafanaUrl, grafanaToken),
         },
       ],
     }).compile();
@@ -64,9 +58,6 @@ describe('ResponseTimeInterceptor', () => {
     mockCallHandler = {
       handle: jest.fn().mockReturnValue(of('test')),
     };
-
-    (fs.readFileSync as jest.Mock).mockImplementation(() => JSON.stringify({}));
-    (fs.writeFileSync as jest.Mock).mockImplementation(() => {});
   });
 
   afterEach(() => {
@@ -82,15 +73,12 @@ describe('ResponseTimeInterceptor', () => {
       .mockReturnValueOnce(0)
       .mockReturnValueOnce(100);
 
-    await interceptor
-      .intercept(mockExecutionContext, mockCallHandler)
-      .toPromise();
+    await interceptor.intercept(mockExecutionContext, mockCallHandler).toPromise();
 
     expect(mockHistogram.labels).toHaveBeenCalledWith({
       statusCode: 200,
       endpoint: '/test',
     });
-    // expect(mockHistogram.observe).toHaveBeenCalledWith(100);
   });
 
   it('should log response time and error on failed request', async () => {
@@ -102,30 +90,12 @@ describe('ResponseTimeInterceptor', () => {
       .mockReturnValueOnce(0)
       .mockReturnValueOnce(200);
 
-    await expect(
-      interceptor.intercept(mockExecutionContext, mockCallHandler).toPromise(),
-    ).rejects.toThrow('Test Error');
+    await expect(interceptor.intercept(mockExecutionContext, mockCallHandler).toPromise()).rejects.toThrow('Test Error');
 
     expect(mockHistogram.labels).toHaveBeenCalledWith({
       statusCode: 500,
       endpoint: '/test',
-    });
-    // expect(mockHistogram.observe).toHaveBeenCalledWith(200);
+    });    
   });
 
-  it('should handle JSON parsing errors gracefully', async () => {
-    (fs.readFileSync as jest.Mock).mockImplementationOnce(() => {
-      throw new SyntaxError('Invalid JSON');
-    });
-
-    await expect(
-      interceptor.intercept(mockExecutionContext, mockCallHandler).toPromise(),
-    ).resolves.toBe('test');
-
-    expect(mockHistogram.labels).toHaveBeenCalledWith({
-      statusCode: 200,
-      endpoint: '/test',
-    });
-    // expect(mockHistogram.observe).toHaveBeenCalledWith(100);
-  });
 });

sample/01-monitoring/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "02-monitoring",
+  "name": "01-monitoring",
   "version": "0.0.1",
   "description": "",
   "author": "",
@@ -17,14 +17,14 @@
     "test:watch": "jest --passWithNoTests --watch",
     "test:cov": "jest --passWithNoTests --coverage",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
-    "test:e2e": "jest --passWithNoTests --config ./test/jest-e2e.json"
+    "test:e2e": "jest --passWithNoTests --runInBand --detectOpenHandles --forceExit --config ./test/jest-e2e.json"
   },
   "dependencies": {
     "@nestjs/common": "^10.0.0",
     "@nestjs/config": "^3.2.3",
     "@nestjs/core": "^10.0.0",
     "@nestjs/platform-express": "^10.0.0",
-    "@samagra-x/stencil": "^0.0.2",
+    "@samagra-x/stencil": "^0.0.6",
     "axios": "^1.6.7",
     "reflect-metadata": "^0.1.13",
     "rxjs": "^7.8.1",

sample/01-monitoring/test/app.e2e-spec.ts

@@ -0,0 +1,72 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import * as request from 'supertest';
+import { INestApplication, Logger } from '@nestjs/common';
+import { AppModule } from '../src/app.module';
+import { ResponseTimeInterceptor } from '@samagra-x/stencil';
+import { delay } from 'rxjs';
+import { ConfigService } from '@nestjs/config';
+
+describe('ResponseTimeInterceptor (Integration)', () => {
+
+  let app: INestApplication;
+  const mockLogger = {
+    log: jest.fn(),
+    error: jest.fn(),
+  };
+  let configService: ConfigService;
+  let grafanaBaseURL: string;
+  let apiToken : string;
+
+  beforeAll(async () => {
+    jest.spyOn(Logger.prototype, 'log').mockImplementation(mockLogger.log);
+    jest.spyOn(Logger.prototype, 'error').mockImplementation(mockLogger.error);
+
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule], 
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+     configService = app.get(ConfigService);
+     grafanaBaseURL = configService.get<string>('GRAFANA_BASE_URL');
+     apiToken = configService.get<string>('GRAFANA_API_TOKEN');
+
+  });
+  afterAll(async () => {
+    await app.close();
+  });
+
+// it('should log sucessfull message of the logger', async () => {
+//    expect(mockLogger.log).toHaveBeenCalledWith(
+//      expect.stringContaining('Successfully added histogram to dashboard!')
+//    );
+//    console.log(mockLogger.log.mock.calls); 
+// });
+
+  it('should contain only controller level interceptor response', async () => {
+
+    const metrics = await request(app.getHttpServer())
+      .get('/metrics')
+      .expect(200);
+    expect(metrics.text).toContain('controller_response_time');
+  });
+
+  it('should contain both controller and global level interceptor response', async () => {
+
+    app.useGlobalInterceptors(
+      new ResponseTimeInterceptor(
+        'global',
+        grafanaBaseURL,
+        apiToken,
+      ),
+    );
+
+    const metrics = await request(app.getHttpServer())
+      .get('/metrics')
+      .expect(200);
+    expect(metrics.text).toContain('global_response_time');
+    expect(metrics.text).toContain('controller_response_time');
+
+  });
+
+});