latest

server/monitoring.ts

@@ -0,0 +1,151 @@
+import { Request, Response, NextFunction } from 'express';
+
+// Interface pour les métriques
+interface Metrics {
+  requestCount: number;
+  errorCount: number;
+  responseTime: number[];
+  memoryUsage: NodeJS.MemoryUsage;
+  activeConnections: number;
+  lastReset: Date;
+}
+
+class PerformanceMonitor {
+  private metrics: Metrics = {
+    requestCount: 0,
+    errorCount: 0,
+    responseTime: [],
+    memoryUsage: process.memoryUsage(),
+    activeConnections: 0,
+    lastReset: new Date()
+  };
+
+  private slowQueries: Array<{ query: string; duration: number; timestamp: Date }> = [];
+  private MAX_RESPONSE_TIMES = 1000; // Garder les 1000 derniers temps de réponse
+
+  // Middleware pour mesurer les performances
+  middleware() {
+    return (req: Request, res: Response, next: NextFunction) => {
+      const startTime = Date.now();
+      this.metrics.requestCount++;
+      this.metrics.activeConnections++;
+
+      // Capturer le temps de réponse
+      res.on('finish', () => {
+        const duration = Date.now() - startTime;
+        this.metrics.responseTime.push(duration);
+        
+        // Garder seulement les N derniers temps de réponse
+        if (this.metrics.responseTime.length > this.MAX_RESPONSE_TIMES) {
+          this.metrics.responseTime.shift();
+        }
+
+        // Détecter les requêtes lentes
+        if (duration > 1000) {
+          this.logSlowQuery(req.originalUrl, duration);
+        }
+
+        // Compter les erreurs
+        if (res.statusCode >= 400) {
+          this.metrics.errorCount++;
+        }
+
+        this.metrics.activeConnections--;
+        this.metrics.memoryUsage = process.memoryUsage();
+      });
+
+      next();
+    };
+  }
+
+  // Enregistrer une requête lente
+  private logSlowQuery(query: string, duration: number) {
+    this.slowQueries.push({
+      query,
+      duration,
+      timestamp: new Date()
+    });
+
+    // Garder seulement les 100 dernières requêtes lentes
+    if (this.slowQueries.length > 100) {
+      this.slowQueries.shift();
+    }
+
+    console.warn(`⚠️  Slow query detected: ${query} (${duration}ms)`);
+  }
+
+  // Obtenir les statistiques
+  getStats() {
+    const responseTimes = this.metrics.responseTime;
+    const avgResponseTime = responseTimes.length > 0 
+      ? responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length 
+      : 0;
+
+    const p95ResponseTime = responseTimes.length > 0 
+      ? responseTimes.sort((a, b) => a - b)[Math.floor(responseTimes.length * 0.95)]
+      : 0;
+
+    return {
+      uptime: process.uptime(),
+      requestCount: this.metrics.requestCount,
+      errorCount: this.metrics.errorCount,
+      errorRate: this.metrics.requestCount > 0 ? (this.metrics.errorCount / this.metrics.requestCount) * 100 : 0,
+      avgResponseTime: Math.round(avgResponseTime),
+      p95ResponseTime: Math.round(p95ResponseTime),
+      activeConnections: this.metrics.activeConnections,
+      memoryUsage: {
+        rss: `${Math.round(this.metrics.memoryUsage.rss / 1024 / 1024)}MB`,
+        heapTotal: `${Math.round(this.metrics.memoryUsage.heapTotal / 1024 / 1024)}MB`,
+        heapUsed: `${Math.round(this.metrics.memoryUsage.heapUsed / 1024 / 1024)}MB`,
+        external: `${Math.round(this.metrics.memoryUsage.external / 1024 / 1024)}MB`
+      },
+      slowQueries: this.slowQueries.slice(-10), // 10 dernières requêtes lentes
+      lastReset: this.metrics.lastReset
+    };
+  }
+
+  // Réinitialiser les métriques
+  reset() {
+    this.metrics = {
+      requestCount: 0,
+      errorCount: 0,
+      responseTime: [],
+      memoryUsage: process.memoryUsage(),
+      activeConnections: 0,
+      lastReset: new Date()
+    };
+    this.slowQueries = [];
+  }
+
+  // Alerte si l'utilisation mémoire est trop élevée
+  checkMemoryUsage() {
+    const memUsage = process.memoryUsage();
+    const heapUsedMB = memUsage.heapUsed / 1024 / 1024;
+    
+    if (heapUsedMB > 500) { // Plus de 500MB
+      console.warn(`⚠️  High memory usage: ${Math.round(heapUsedMB)}MB`);
+      return true;
+    }
+    return false;
+  }
+}
+
+// Instance globale
+export const monitor = new PerformanceMonitor();
+
+// Vérification périodique de la mémoire
+setInterval(() => {
+  monitor.checkMemoryUsage();
+}, 5 * 60 * 1000); // Toutes les 5 minutes
+
+// Endpoint pour les métriques
+export function setupMonitoringEndpoints(app: any) {
+  app.get('/api/metrics', (req: Request, res: Response) => {
+    res.json(monitor.getStats());
+  });
+
+  app.post('/api/metrics/reset', (req: Request, res: Response) => {
+    monitor.reset();
+    res.json({ message: 'Metrics reset successfully' });
+  });
+}