feat: Implement Prometheus metrics collection for HTTP requests and login attempts, including custom metrics and interceptors

Author: letnull19A

README.md

@@ -79,6 +79,31 @@ http://localhost:3000/admin/api/metrics
 - Путь `PROMETHEUS_PATH` указывается относительно корня приложения, но с учетом глобального префикса `admin/api`
 - Для доступа к метрикам без префикса установите `PROMETHEUS_PATH=/metrics` и используйте `http://localhost:3000/metrics`
 
+**Доступные метрики:**
+
+Приложение автоматически собирает следующие кастомные метрики:
+
+1. **`http_requests_total`** - Общее количество HTTP запросов
+   - Метки: `method` (HTTP метод), `route` (маршрут), `status_code` (код ответа)
+   
+2. **`http_request_duration_seconds`** - Длительность HTTP запросов в секундах
+   - Метки: `method` (HTTP метод), `route` (маршрут)
+   - Бакеты: 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10 секунд
+   
+3. **`http_errors_total`** - Общее количество HTTP ошибок
+   - Метки: `method` (HTTP метод), `route` (маршрут), `status_code` (код ошибки), `error_type` (тип ошибки)
+
+4. **`login_attempts_total`** - Общее количество попыток входа
+   - Метки: `status` (success/failure), `reason` (invalid_credentials, user_not_found, user_blocked, unauthorized, unknown)
+   
+5. **`login_duration_seconds`** - Длительность попыток входа в секундах
+   - Метки: `status` (success/failure)
+   - Бакеты: 0.01, 0.05, 0.1, 0.25, 0.5, 1, 2, 5 секунд
+
+Все метрики автоматически собираются:
+- HTTP метрики (1-3) - для всех HTTP запросов через глобальный interceptor
+- Метрики входа (4-5) - для попыток входа через LoginLoggingInterceptor
+
 ## Запуск
 
 ```bash

src/auth/auth.module.ts

@@ -7,11 +7,13 @@ import { AuthController } from './auth.controller';
 import { JwtStrategy } from './strategies/jwt.strategy';
 import { RefreshTokenGuard } from './guards/refresh-token.guard';
 import { UserModule } from '../user/user.module';
+import { PrometheusModule } from '../prometheus/prometheus.module';
 
 @Module({
   imports: [
     UserModule,
     PassportModule,
+    PrometheusModule,
     JwtModule.registerAsync({
       imports: [ConfigModule],
       useFactory: async (configService: ConfigService) => ({

src/auth/interceptors/login-logging.interceptor.ts

@@ -7,36 +7,65 @@ import {
 } from '@nestjs/common';
 import { Observable, throwError } from 'rxjs';
 import { tap, catchError } from 'rxjs/operators';
+import { PrometheusService } from '../../prometheus/prometheus.service';
 
 /**
  * Интерцептор для логирования попыток входа
  * Логирует попытку входа, успешный вход и неуспешные попытки
+ * Собирает метрики Prometheus для мониторинга
  */
 @Injectable()
 export class LoginLoggingInterceptor implements NestInterceptor {
   private readonly logger = new Logger(LoginLoggingInterceptor.name);
 
+  constructor(private readonly prometheusService: PrometheusService) {}
+
   intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
     const request = context.switchToHttp().getRequest();
     const loginDto = request.body;
     const email = loginDto?.email;
+    const startTime = Date.now();
 
     if (email) {
       this.logger.log(`Попытка входа: ${email}`);
     }
 
     return next.handle().pipe(
       tap((result) => {
+        const duration = (Date.now() - startTime) / 1000;
+        
         if (email && result?.user?.id) {
           this.logger.log(`Успешный вход: ${email} (ID: ${result.user.id})`);
+          
+          // Записываем метрики для успешного входа
+          this.prometheusService.incrementLoginAttempts('success');
+          this.prometheusService.recordLoginDuration('success', duration);
         }
       }),
       catchError((error) => {
+        const duration = (Date.now() - startTime) / 1000;
+        const errorMessage = error.message || 'Неверный email или пароль';
+        
         if (email) {
-          this.logger.warn(
-            `Неуспешный вход: ${email} - ${error.message || 'Неверный email или пароль'}`,
-          );
+          this.logger.warn(`Неуспешный вход: ${email} - ${errorMessage}`);
+        }
+
+        // Определяем причину ошибки
+        let reason = 'unknown';
+        if (errorMessage.includes('email') || errorMessage.includes('пароль') || errorMessage.includes('password')) {
+          reason = 'invalid_credentials';
+        } else if (errorMessage.includes('не найден') || errorMessage.includes('not found')) {
+          reason = 'user_not_found';
+        } else if (errorMessage.includes('заблокирован') || errorMessage.includes('blocked')) {
+          reason = 'user_blocked';
+        } else if (error.status === 401) {
+          reason = 'unauthorized';
         }
+
+        // Записываем метрики для неуспешного входа
+        this.prometheusService.incrementLoginAttempts('failure', reason);
+        this.prometheusService.recordLoginDuration('failure', duration);
+
         return throwError(() => error);
       }),
     );

src/main.ts

@@ -4,6 +4,7 @@ import { VersioningType, Logger } from '@nestjs/common';
 import { AppModule } from './app.module';
 import { json } from 'express';
 import { ConfigService } from '@nestjs/config';
+import { PrometheusInterceptor } from './prometheus/prometheus.interceptor';
 
 async function bootstrap() {
   try {
@@ -84,6 +85,10 @@ async function bootstrap() {
 
     app.setGlobalPrefix('admin/api');
 
+    // Глобальный interceptor для сбора метрик Prometheus
+    const prometheusInterceptor = app.get(PrometheusInterceptor);
+    app.useGlobalInterceptors(prometheusInterceptor);
+
     const config = new DocumentBuilder()
       .setTitle('Atom DBRO Admin Backend API')
       .setDescription('API для админ панели Atom DBRO')

src/prometheus/prometheus.interceptor.ts

@@ -0,0 +1,78 @@
+import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+} from '@nestjs/common';
+import { Observable, throwError } from 'rxjs';
+import { tap, catchError } from 'rxjs/operators';
+import { PrometheusService } from './prometheus.service';
+
+@Injectable()
+export class PrometheusInterceptor implements NestInterceptor {
+  constructor(private readonly prometheusService: PrometheusService) {}
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const request = context.switchToHttp().getRequest();
+    const response = context.switchToHttp().getResponse();
+    const method = request.method;
+    const route = this.getRoute(request);
+    const startTime = Date.now();
+
+    // Пропускаем сбор метрик для самого endpoint /metrics
+    if (route === '/metrics' || request.path === '/metrics' || request.originalUrl?.includes('/metrics')) {
+      return next.handle();
+    }
+
+    return next.handle().pipe(
+      tap((data) => {
+        const duration = (Date.now() - startTime) / 1000;
+        // Используем статус код из response, если доступен, иначе 200
+        const statusCode = response.statusCode || 200;
+
+        // Записываем метрики для успешных запросов
+        this.prometheusService.incrementHttpRequests(method, route, statusCode);
+        this.prometheusService.recordHttpRequestDuration(method, route, duration);
+      }),
+      catchError((error) => {
+        const duration = (Date.now() - startTime) / 1000;
+        const statusCode = error.status || error.statusCode || response.statusCode || 500;
+        const errorType = error.constructor?.name || 'UnknownError';
+
+        // Записываем метрики для ошибок
+        this.prometheusService.incrementHttpRequests(method, route, statusCode);
+        this.prometheusService.recordHttpRequestDuration(method, route, duration);
+        this.prometheusService.incrementHttpErrors(method, route, statusCode, errorType);
+
+        return throwError(() => error);
+      }),
+    );
+  }
+
+  /**
+   * Получает нормализованный маршрут из запроса
+   */
+  private getRoute(request: any): string {
+    // Используем route.path если доступен (NestJS)
+    if (request.route?.path) {
+      return request.route.path;
+    }
+
+    // Используем originalUrl или path
+    const url = request.originalUrl || request.url || '/';
+
+    // Убираем query параметры
+    const path = url.split('?')[0];
+
+    // Нормализуем путь (убираем версию API и префикс для более чистых метрик)
+    let normalizedPath = path.replace(/^\/admin\/api\/v\d+\//, '/');
+    normalizedPath = normalizedPath.replace(/^\/admin\/api\//, '/');
+
+    // Заменяем ID параметры на :id для группировки
+    normalizedPath = normalizedPath.replace(/\/\d+/g, '/:id');
+    normalizedPath = normalizedPath.replace(/\/[a-f0-9-]{36}/gi, '/:id'); // UUID
+
+    return normalizedPath || '/';
+  }
+}
+

src/prometheus/prometheus.metrics.ts

@@ -0,0 +1,50 @@
+import { Counter, Histogram } from 'prom-client';
+import { makeCounterProvider, makeHistogramProvider } from '@willsoto/nestjs-prometheus';
+
+/**
+ * Метрика: Общее количество HTTP запросов
+ */
+export const httpRequestsTotal = makeCounterProvider({
+  name: 'http_requests_total',
+  help: 'Total number of HTTP requests',
+  labelNames: ['method', 'route', 'status_code'],
+});
+
+/**
+ * Метрика: Длительность HTTP запросов
+ */
+export const httpRequestDuration = makeHistogramProvider({
+  name: 'http_request_duration_seconds',
+  help: 'Duration of HTTP requests in seconds',
+  labelNames: ['method', 'route'],
+  buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10],
+});
+
+/**
+ * Метрика: Общее количество HTTP ошибок
+ */
+export const httpErrorsTotal = makeCounterProvider({
+  name: 'http_errors_total',
+  help: 'Total number of HTTP errors',
+  labelNames: ['method', 'route', 'status_code', 'error_type'],
+});
+
+/**
+ * Метрика: Общее количество попыток входа
+ */
+export const loginAttemptsTotal = makeCounterProvider({
+  name: 'login_attempts_total',
+  help: 'Total number of login attempts',
+  labelNames: ['status', 'reason'],
+});
+
+/**
+ * Метрика: Длительность попыток входа
+ */
+export const loginDuration = makeHistogramProvider({
+  name: 'login_duration_seconds',
+  help: 'Duration of login attempts in seconds',
+  labelNames: ['status'],
+  buckets: [0.01, 0.05, 0.1, 0.25, 0.5, 1, 2, 5],
+});
+

src/prometheus/prometheus.module.ts

@@ -1,6 +1,15 @@
 import { Module } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { PrometheusModule as PrometheusModuleLib } from '@willsoto/nestjs-prometheus';
+import { PrometheusService } from './prometheus.service';
+import { PrometheusInterceptor } from './prometheus.interceptor';
+import {
+  httpRequestsTotal,
+  httpRequestDuration,
+  httpErrorsTotal,
+  loginAttemptsTotal,
+  loginDuration,
+} from './prometheus.metrics';
 
 @Module({
   imports: [
@@ -33,7 +42,16 @@ import { PrometheusModule as PrometheusModuleLib } from '@willsoto/nestjs-promet
       inject: [ConfigService],
     }),
   ],
-  exports: [PrometheusModuleLib],
+  providers: [
+    httpRequestsTotal,
+    httpRequestDuration,
+    httpErrorsTotal,
+    loginAttemptsTotal,
+    loginDuration,
+    PrometheusService,
+    PrometheusInterceptor,
+  ],
+  exports: [PrometheusModuleLib, PrometheusService, PrometheusInterceptor],
 })
 export class PrometheusModule {}
 

src/prometheus/prometheus.service.ts

@@ -0,0 +1,78 @@
+import { Injectable } from '@nestjs/common';
+import { InjectMetric } from '@willsoto/nestjs-prometheus';
+import { Counter, Histogram } from 'prom-client';
+
+@Injectable()
+export class PrometheusService {
+  constructor(
+    @InjectMetric('http_requests_total')
+    private readonly httpRequestsTotal: Counter<string>,
+    @InjectMetric('http_request_duration_seconds')
+    private readonly httpRequestDuration: Histogram<string>,
+    @InjectMetric('http_errors_total')
+    private readonly httpErrorsTotal: Counter<string>,
+    @InjectMetric('login_attempts_total')
+    private readonly loginAttemptsTotal: Counter<string>,
+    @InjectMetric('login_duration_seconds')
+    private readonly loginDuration: Histogram<string>,
+  ) {}
+
+  /**
+   * Увеличивает счетчик HTTP запросов
+   */
+  incrementHttpRequests(method: string, route: string, statusCode: number) {
+    this.httpRequestsTotal.inc({
+      method,
+      route,
+      status_code: statusCode.toString(),
+    });
+  }
+
+  /**
+   * Записывает длительность HTTP запроса
+   */
+  recordHttpRequestDuration(method: string, route: string, duration: number) {
+    this.httpRequestDuration.observe(
+      {
+        method,
+        route,
+      },
+      duration,
+    );
+  }
+
+  /**
+   * Увеличивает счетчик HTTP ошибок
+   */
+  incrementHttpErrors(method: string, route: string, statusCode: number, errorType?: string) {
+    this.httpErrorsTotal.inc({
+      method,
+      route,
+      status_code: statusCode.toString(),
+      error_type: errorType || 'unknown',
+    });
+  }
+
+  /**
+   * Увеличивает счетчик попыток входа
+   */
+  incrementLoginAttempts(status: 'success' | 'failure', reason?: string) {
+    this.loginAttemptsTotal.inc({
+      status,
+      reason: reason || 'unknown',
+    });
+  }
+
+  /**
+   * Записывает длительность попытки входа
+   */
+  recordLoginDuration(status: 'success' | 'failure', duration: number) {
+    this.loginDuration.observe(
+      {
+        status,
+      },
+      duration,
+    );
+  }
+}
+