kukuy 1.4.0

package/src/utils/ProfessionalMetrics.js

@@ -0,0 +1,501 @@
+const os = require('os');
+
+class ProfessionalMetrics {
+  constructor() {
+    this.metrics = {
+      requests: {
+        total: 0,
+        successful: 0,
+        failed: 0,
+        byMethod: {},
+        byPath: {},
+        byServer: {}, // Contador general por servidor
+        byResponseCode: {}
+      },
+      serverStats: {}, // Estadísticas detalladas por servidor
+      performance: {
+        totalResponseTime: 0,
+        minResponseTime: Infinity,
+        maxResponseTime: 0,
+        avgResponseTime: 0,
+        p95ResponseTime: 0,
+        p99ResponseTime: 0
+      },
+      servers: {
+        total: 0,
+        healthy: 0,
+        unhealthy: 0,
+        byStatus: {}
+      },
+      system: {
+        cpuUsage: 0,
+        memoryUsage: 0,
+        uptime: 0,
+        loadAverage: [0, 0, 0]
+      },
+      timestamps: {
+        startTime: Date.now(),
+        lastUpdate: Date.now()
+      },
+      responseTimes: [] // Para calcular percentiles
+    };
+
+    // Iniciar recolección de métricas del sistema
+    this.startSystemMetricsCollection();
+  }
+
+  startSystemMetricsCollection() {
+    // Actualizar métricas del sistema periódicamente
+    setInterval(() => {
+      this.updateSystemMetrics();
+    }, 5000); // Actualizar cada 5 segundos
+  }
+
+  updateSystemMetrics() {
+    const loadAvg = os.loadavg();
+    const totalMemory = os.totalmem();
+    const freeMemory = os.freemem();
+    
+    this.metrics.system = {
+      ...this.metrics.system,
+      cpuUsage: this.getCpuUsage(),
+      memoryUsage: ((totalMemory - freeMemory) / totalMemory) * 100,
+      loadAverage: loadAvg,
+      uptime: process.uptime()
+    };
+  }
+
+  getCpuUsage() {
+    const cpus = os.cpus();
+    let totalIdle = 0;
+    let totalTick = 0;
+
+    for (const cpu of cpus) {
+      for (const type in cpu.times) {
+        totalTick += cpu.times[type];
+      }
+      totalIdle += cpu.times.idle;
+    }
+
+    const currentUsage = ((totalTick - totalIdle) / totalTick) * 100;
+    return parseFloat(currentUsage.toFixed(2));
+  }
+
+  recordRequest(method, path, serverId, responseTime, responseCode, success = true) {
+    const now = Date.now();
+
+    // Actualizar contadores de solicitudes
+    this.metrics.requests.total++;
+
+    if (success) {
+      this.metrics.requests.successful++;
+    } else {
+      this.metrics.requests.failed++;
+    }
+
+    // Contar por método HTTP
+    if (!this.metrics.requests.byMethod[method]) {
+      this.metrics.requests.byMethod[method] = 0;
+    }
+    this.metrics.requests.byMethod[method]++;
+
+    // Contar por ruta
+    if (!this.metrics.requests.byPath[path]) {
+      this.metrics.requests.byPath[path] = 0;
+    }
+    this.metrics.requests.byPath[path]++;
+
+    // Contar por servidor
+    if (!this.metrics.requests.byServer[serverId]) {
+      this.metrics.requests.byServer[serverId] = 0;
+    }
+    this.metrics.requests.byServer[serverId]++;
+
+    // Contar por código de respuesta
+    if (!this.metrics.requests.byResponseCode[responseCode]) {
+      this.metrics.requests.byResponseCode[responseCode] = 0;
+    }
+    this.metrics.requests.byResponseCode[responseCode]++;
+
+    // Actualizar estadísticas detalladas por servidor
+    this.updateServerStats(serverId, responseTime, responseCode, success);
+
+    // Actualizar métricas de rendimiento
+    this.metrics.performance.totalResponseTime += responseTime;
+    this.metrics.performance.minResponseTime = Math.min(this.metrics.performance.minResponseTime, responseTime);
+    this.metrics.performance.maxResponseTime = Math.max(this.metrics.performance.maxResponseTime, responseTime);
+
+    // Almacenar tiempos de respuesta para calcular percentiles
+    this.metrics.responseTimes.push(responseTime);
+    if (this.metrics.responseTimes.length > 10000) { // Limitar el tamaño del array
+      this.metrics.responseTimes.shift();
+    }
+
+    // Registrar marca de tiempo para cálculo de RPS instantáneo
+    this.recordRequestTimestamp();
+
+    // Calcular promedio
+    this.metrics.performance.avgResponseTime =
+      this.metrics.performance.totalResponseTime / this.metrics.requests.total;
+
+    // Calcular percentiles
+    this.calculatePercentiles();
+
+    this.metrics.timestamps.lastUpdate = now;
+  }
+
+  updateServerStats(serverId, responseTime, responseCode, success) {
+    // Inicializar estadísticas para el servidor si no existen
+    if (!this.metrics.serverStats[serverId]) {
+      this.metrics.serverStats[serverId] = {
+        id: serverId,
+        totalRequests: 0,
+        successfulRequests: 0,
+        failedRequests: 0,
+        totalResponseTime: 0,
+        minResponseTime: Infinity,
+        maxResponseTime: 0,
+        avgResponseTime: 0,
+        responseCodes: {},
+        uptimeRatio: 0,
+        lastActive: Date.now(),
+        responseTimes: [] // Para calcular percentiles por servidor
+      };
+    }
+
+    const serverStat = this.metrics.serverStats[serverId];
+
+    // Actualizar contadores
+    serverStat.totalRequests++;
+    if (success) {
+      serverStat.successfulRequests++;
+    } else {
+      serverStat.failedRequests++;
+    }
+
+    // Actualizar tiempos de respuesta
+    serverStat.totalResponseTime += responseTime;
+    serverStat.minResponseTime = Math.min(serverStat.minResponseTime, responseTime);
+    serverStat.maxResponseTime = Math.max(serverStat.maxResponseTime, responseTime);
+
+    // Actualizar códigos de respuesta
+    if (!serverStat.responseCodes[responseCode]) {
+      serverStat.responseCodes[responseCode] = 0;
+    }
+    serverStat.responseCodes[responseCode]++;
+
+    // Actualizar promedio
+    serverStat.avgResponseTime = serverStat.totalResponseTime / serverStat.totalRequests;
+
+    // Actualizar último acceso
+    serverStat.lastActive = Date.now();
+
+    // Almacenar tiempos de respuesta para percentiles por servidor
+    serverStat.responseTimes.push(responseTime);
+    if (serverStat.responseTimes.length > 1000) { // Limitar tamaño del array por servidor
+      serverStat.responseTimes.shift();
+    }
+
+    // Asegurar que minResponseTime sea válido
+    if (serverStat.minResponseTime === Infinity) {
+      serverStat.minResponseTime = 0;
+    }
+  }
+
+  getServerStats(serverId) {
+    if (serverId) {
+      return this.metrics.serverStats[serverId] || null;
+    }
+    return this.metrics.serverStats;
+  }
+
+  calculateServerPercentiles(serverId) {
+    if (serverId) {
+      const serverStat = this.metrics.serverStats[serverId];
+      if (serverStat && serverStat.responseTimes.length > 0) {
+        const sorted = [...serverStat.responseTimes].sort((a, b) => a - b);
+        const length = sorted.length;
+
+        // Calcular P95 (percentil 95)
+        const p95Index = Math.floor(length * 0.95);
+        serverStat.p95ResponseTime = sorted[p95Index] || 0;
+
+        // Calcular P99 (percentil 99)
+        const p99Index = Math.floor(length * 0.99);
+        serverStat.p99ResponseTime = sorted[p99Index] || 0;
+      }
+    } else {
+      // Calcular percentiles para todos los servidores
+      for (const id in this.metrics.serverStats) {
+        this.calculateServerPercentiles(id);
+      }
+    }
+  }
+
+  calculatePercentiles() {
+    if (this.metrics.responseTimes.length === 0) return;
+    
+    const sorted = [...this.metrics.responseTimes].sort((a, b) => a - b);
+    const length = sorted.length;
+    
+    // Calcular P95 (percentil 95)
+    const p95Index = Math.floor(length * 0.95);
+    this.metrics.performance.p95ResponseTime = sorted[p95Index] || 0;
+    
+    // Calcular P99 (percentil 99)
+    const p99Index = Math.floor(length * 0.99);
+    this.metrics.performance.p99ResponseTime = sorted[p99Index] || 0;
+  }
+
+  updateServerStatus(serverId, status) {
+    // Actualizar estado de servidor
+    if (!this.metrics.servers.byStatus[status]) {
+      this.metrics.servers.byStatus[status] = 0;
+    }
+    
+    // Incrementar el nuevo estado y decrementar el anterior si existe
+    this.metrics.servers.byStatus[status]++;
+    
+    // Actualizar contadores generales
+    this.updateServerCounts();
+  }
+
+  updateServerCounts() {
+    let healthyCount = 0;
+    let unhealthyCount = 0;
+
+    // Contar servidores según su estado actual
+    for (const [status, count] of Object.entries(this.metrics.servers.byStatus)) {
+      if (status === 'healthy' || status === 'online' || status === 'active') {
+        healthyCount += count;
+      } else {
+        unhealthyCount += count;
+      }
+    }
+
+    // El conteo de servidores activos debe reflejar solo los servidores verificados como online
+    // No puede ser mayor al número total de servidores configurados
+    const totalConfiguredServers = Object.keys(this.metrics.serverStats).length;
+
+    // Solo contar servidores que han sido verificados como online
+    let verifiedOnlineCount = 0;
+    for (const [serverId, serverStat] of Object.entries(this.metrics.serverStats)) {
+      if (serverStat.status === 'online' || serverStat.status === 'healthy' || serverStat.status === 'active') {
+        verifiedOnlineCount++;
+      }
+    }
+
+    this.metrics.servers.healthy = verifiedOnlineCount;
+    this.metrics.servers.unhealthy = totalConfiguredServers - verifiedOnlineCount;
+    this.metrics.servers.total = totalConfiguredServers;
+  }
+
+  // Método para actualizar el estado de un servidor
+  updateServerStatus(serverId, status) {
+    // Inicializar estadísticas para el servidor si no existen
+    if (!this.metrics.serverStats[serverId]) {
+      this.metrics.serverStats[serverId] = {
+        id: serverId,
+        totalRequests: 0,
+        successfulRequests: 0,
+        failedRequests: 0,
+        totalResponseTime: 0,
+        minResponseTime: Infinity,
+        maxResponseTime: 0,
+        avgResponseTime: 0,
+        responseCodes: {},
+        uptimeRatio: 0,
+        lastActive: Date.now(),
+        responseTimes: []
+      };
+    }
+
+    const serverStat = this.metrics.serverStats[serverId];
+
+    // Actualizar el estado del servidor
+    serverStat.status = status;
+    serverStat.lastActive = Date.now();
+
+    // Actualizar el conteo por estado
+    // Primero decrementar el conteo del estado anterior si ya existía
+    if (serverStat.previousStatus && serverStat.previousStatus !== status) {
+      if (this.metrics.servers.byStatus[serverStat.previousStatus]) {
+        this.metrics.servers.byStatus[serverStat.previousStatus]--;
+        if (this.metrics.servers.byStatus[serverStat.previousStatus] < 0) {
+          this.metrics.servers.byStatus[serverStat.previousStatus] = 0;
+        }
+      }
+    }
+
+    // Incrementar el conteo del nuevo estado
+    if (!this.metrics.servers.byStatus[status]) {
+      this.metrics.servers.byStatus[status] = 0;
+    }
+    this.metrics.servers.byStatus[status]++;
+
+    // Guardar el estado anterior para futuras actualizaciones
+    serverStat.previousStatus = status;
+
+    // Actualizar los contadores generales
+    this.updateServerCounts();
+  }
+
+  getMetrics() {
+    // Asegurar que los valores mínimos sean válidos
+    if (this.metrics.performance.minResponseTime === Infinity) {
+      this.metrics.performance.minResponseTime = 0;
+    }
+
+    // Calcular RPS acumulado (desde el inicio)
+    const uptimeSecs = (Date.now() - this.metrics.timestamps.startTime) / 1000;
+    const cumulativeRps = uptimeSecs > 0 ? this.metrics.requests.total / uptimeSecs : 0;
+
+    // Calcular RPS instantáneo (últimos 5 segundos)
+    const instantaneousRps = this.calculateInstantaneousRps();
+
+    // Calcular percentiles por servidor
+    this.calculateServerPercentiles();
+
+    // Actualizar métricas del sistema
+    this.updateSystemMetrics();
+
+    return {
+      ...this.metrics,
+      calculated: {
+        cumulativeRps: parseFloat(cumulativeRps.toFixed(2)),
+        instantaneousRps: parseFloat(instantaneousRps.toFixed(2)),
+        uptime: Date.now() - this.metrics.timestamps.startTime,
+        successRate: this.metrics.requests.total > 0
+          ? parseFloat(((this.metrics.requests.successful / this.metrics.requests.total) * 100).toFixed(2))
+          : 0
+      }
+    };
+  }
+
+  // Método para calcular RPS instantáneo (últimos 5 segundos)
+  calculateInstantaneousRps() {
+    if (!this.recentRequests) {
+      this.recentRequests = [];
+    }
+
+    const now = Date.now();
+    const fiveSecondsAgo = now - 5000; // 5 segundos atrás
+
+    // Limpiar solicitudes antiguas
+    this.recentRequests = this.recentRequests.filter(timestamp => timestamp > fiveSecondsAgo);
+
+    // Calcular RPS instantáneo
+    const timeWindow = 5; // 5 segundos
+    return this.recentRequests.length / timeWindow;
+  }
+
+  // Método para registrar una solicitud reciente para cálculo de RPS instantáneo
+  recordRequestTimestamp() {
+    if (!this.recentRequests) {
+      this.recentRequests = [];
+    }
+
+    this.recentRequests.push(Date.now());
+
+    // Limpiar solicitudes antiguas (> 5 segundos) para mantener solo las recientes
+    const fiveSecondsAgo = Date.now() - 5000;
+    this.recentRequests = this.recentRequests.filter(timestamp => timestamp > fiveSecondsAgo);
+  }
+
+  updateSystemMetrics() {
+    const os = require('os');
+
+    // Obtener uso de CPU (corrección para cálculo preciso)
+    const cpus = os.cpus();
+    let totalUser = 0;
+    let totalNice = 0;
+    let totalSys = 0;
+    let totalIdle = 0;
+    let totalIrq = 0;
+
+    for (const cpu of cpus) {
+      totalUser += cpu.times.user;
+      totalNice += cpu.times.nice;
+      totalSys += cpu.times.sys;
+      totalIdle += cpu.times.idle;
+      totalIrq += cpu.times.irq;
+    }
+
+    const total = totalUser + totalNice + totalSys + totalIdle + totalIrq;
+    const currentUsage = ((total - totalIdle) / total) * 100;
+    this.metrics.system.cpuUsage = parseFloat(currentUsage.toFixed(2));
+
+    // Obtener uso de memoria
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    const usedMem = totalMem - freeMem;
+    this.metrics.system.memoryUsage = parseFloat(((usedMem / totalMem) * 100).toFixed(2));
+
+    // Obtener carga promedio
+    this.metrics.system.loadAverage = os.loadavg();
+
+    // Actualizar tiempo de actividad
+    this.metrics.system.uptime = process.uptime();
+  }
+
+  reset() {
+    this.metrics = {
+      requests: {
+        total: 0,
+        successful: 0,
+        failed: 0,
+        byMethod: {},
+        byPath: {},
+        byServer: {},
+        byResponseCode: {}
+      },
+      performance: {
+        totalResponseTime: 0,
+        minResponseTime: Infinity,
+        maxResponseTime: 0,
+        avgResponseTime: 0,
+        p95ResponseTime: 0,
+        p99ResponseTime: 0
+      },
+      servers: {
+        total: 0,
+        healthy: 0,
+        unhealthy: 0,
+        byStatus: {}
+      },
+      system: {
+        cpuUsage: 0,
+        memoryUsage: 0,
+        uptime: 0,
+        loadAverage: [0, 0, 0]
+      },
+      timestamps: {
+        startTime: Date.now(),
+        lastUpdate: Date.now()
+      },
+      responseTimes: []
+    };
+  }
+
+  getHealthStatus() {
+    const { total, successful, failed } = this.metrics.requests;
+    const successRate = total > 0 ? (successful / total) * 100 : 100;
+    
+    let status = 'healthy';
+    if (successRate < 90) {
+      status = 'critical';
+    } else if (successRate < 95) {
+      status = 'warning';
+    }
+    
+    return {
+      status,
+      successRate,
+      totalRequests: total,
+      healthyServers: this.metrics.servers.healthy,
+      unhealthyServers: this.metrics.servers.unhealthy
+    };
+  }
+}
+
+module.exports = { ProfessionalMetrics };

package/start-iphash.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# Script para iniciar KUKUY
+
+echo "Iniciando KUKUY..."
+LOAD_BALANCING_ALGORITHM=iphash CONFIG_FILE_PATH=./servers.json BALANCER_HTTP_PORT=8080 DASHBOARD_PORT=8082 node kukuy.js

package/start-roundrobin.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# Script para iniciar KUKUY
+
+echo "Iniciando KUKUY..."
+LOAD_BALANCING_ALGORITHM=roundrobin CONFIG_FILE_PATH=./servers_real.json BALANCER_HTTP_PORT=8088 DASHBOARD_PORT=8082 node kukuy.js

package/stress-test.js

@@ -0,0 +1,190 @@
+const http = require('http');
+const https = require('https');
+const url = require('url');
+
+class StressTester {
+  constructor(balancerUrl, durationSeconds = 60, concurrentRequests = 10) {
+    this.balancerUrl = balancerUrl;
+    this.durationSeconds = durationSeconds;
+    this.concurrentRequests = concurrentRequests;
+    this.startTime = null;
+    this.stats = {
+      totalRequests: 0,
+      successfulRequests: 0,
+      failedRequests: 0,
+      statusCodes: {},
+      totalTime: 0,
+      minTime: Infinity,
+      maxTime: 0
+    };
+    this.running = false;
+  }
+
+  async makeRequest(path, method = 'GET', body = null) {
+    const startTime = Date.now();
+    let statusCode = 0;
+    let success = false;
+    
+    return new Promise((resolve, reject) => {
+      const parsedUrl = url.parse(`${this.balancerUrl}${path}`);
+      const options = {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port,
+        path: parsedUrl.path,
+        method: method,
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      };
+
+      const request = http.request(options, (res) => {
+        statusCode = res.statusCode;
+        let data = '';
+        
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+        
+        res.on('end', () => {
+          const endTime = Date.now();
+          const responseTime = endTime - startTime;
+          
+          success = statusCode >= 200 && statusCode < 300;
+          
+          // Actualizar estadísticas
+          this.stats.totalRequests++;
+          if (success) {
+            this.stats.successfulRequests++;
+          } else {
+            this.stats.failedRequests++;
+          }
+          
+          if (!this.stats.statusCodes[statusCode]) {
+            this.stats.statusCodes[statusCode] = 0;
+          }
+          this.stats.statusCodes[statusCode]++;
+          
+          this.stats.totalTime += responseTime;
+          this.stats.minTime = Math.min(this.stats.minTime, responseTime);
+          this.stats.maxTime = Math.max(this.stats.maxTime, responseTime);
+          
+          resolve({
+            statusCode,
+            responseTime,
+            success
+          });
+        });
+      });
+
+      request.on('error', (err) => {
+        const endTime = Date.now();
+        const responseTime = endTime - startTime;
+        
+        this.stats.totalRequests++;
+        this.stats.failedRequests++;
+        
+        if (!this.stats.statusCodes['ERROR']) {
+          this.stats.statusCodes['ERROR'] = 0;
+        }
+        this.stats.statusCodes['ERROR']++;
+        
+        this.stats.totalTime += responseTime;
+        this.stats.maxTime = Math.max(this.stats.maxTime, responseTime);
+        
+        resolve({
+          statusCode: 'ERROR',
+          responseTime,
+          success: false,
+          error: err.message
+        });
+      });
+
+      if (body) {
+        request.write(JSON.stringify(body));
+      }
+      
+      request.end();
+    });
+  }
+
+  async runTest() {
+    console.log(`Iniciando prueba de estrés...`);
+    console.log(`URL del balanceador: ${this.balancerUrl}`);
+    console.log(`Duración: ${this.durationSeconds} segundos`);
+    console.log(`Concurrencia: ${this.concurrentRequests} solicitudes simultáneas`);
+    console.log('----------------------------------------');
+    
+    this.startTime = Date.now();
+    this.running = true;
+    
+    // Lista de endpoints para probar
+    const endpoints = [
+      { path: '/api/endpoints', method: 'GET' },
+      { path: '/sessions', method: 'GET' },
+      { path: '/events', method: 'GET' },
+      { path: '/reports/user-flow', method: 'GET' },
+      { path: '/reports/product-views-by-country', method: 'GET' },
+      { path: '/track/registerSession', method: 'POST', body: { test: 'stress_test_data' } },
+      { path: '/track/registerEventA', method: 'POST', body: { event: 'test_event', data: 'test_data' } }
+    ];
+    
+    // Función para hacer solicitudes continuamente durante la duración del test
+    const makeRequests = async () => {
+      while (this.running) {
+        const randomEndpoint = endpoints[Math.floor(Math.random() * endpoints.length)];
+        await this.makeRequest(randomEndpoint.path, randomEndpoint.method, randomEndpoint.body || null);
+      }
+    };
+    
+    // Iniciar múltiples promesas concurrentes
+    const promises = [];
+    for (let i = 0; i < this.concurrentRequests; i++) {
+      promises.push(makeRequests());
+    }
+    
+    // Esperar hasta que se cumpla la duración del test
+    setTimeout(() => {
+      this.running = false;
+    }, this.durationSeconds * 1000);
+    
+    // Esperar a que todas las promesas terminen
+    await Promise.all(promises);
+    
+    this.printResults();
+  }
+  
+  printResults() {
+    const totalTimeMs = Date.now() - this.startTime;
+    const avgTime = this.stats.totalRequests > 0 ? this.stats.totalTime / this.stats.totalRequests : 0;
+    const requestsPerSecond = this.stats.totalRequests / (totalTimeMs / 1000);
+    
+    console.log('\n========================================');
+    console.log('RESULTADOS DE LA PRUEBA DE ESTRÉS');
+    console.log('========================================');
+    console.log(`Tiempo total de prueba: ${(totalTimeMs / 1000).toFixed(2)} segundos`);
+    console.log(`Solicitudes totales: ${this.stats.totalRequests}`);
+    console.log(`Solicitudes exitosas: ${this.stats.successfulRequests}`);
+    console.log(`Solicitudes fallidas: ${this.stats.failedRequests}`);
+    console.log(`RPS (Solicitudes por segundo): ${requestsPerSecond.toFixed(2)}`);
+    console.log(`Tiempo promedio por solicitud: ${avgTime.toFixed(2)} ms`);
+    console.log(`Tiempo mínimo: ${this.stats.minTime !== Infinity ? this.stats.minTime : 0} ms`);
+    console.log(`Tiempo máximo: ${this.stats.maxTime} ms`);
+    console.log('\nDistribución de códigos de estado:');
+    Object.entries(this.stats.statusCodes).forEach(([code, count]) => {
+      console.log(`  ${code}: ${count} (${((count / this.stats.totalRequests) * 100).toFixed(2)}%)`);
+    });
+    console.log('========================================');
+  }
+}
+
+// Ejecutar la prueba de estrés si se llama directamente
+if (require.main === module) {
+  const balancerUrl = process.env.BALANCER_URL || 'http://localhost:8081';
+  const duration = parseInt(process.env.DURATION_SECONDS) || 30;
+  const concurrency = parseInt(process.env.CONCURRENT_REQUESTS) || 10;
+  
+  const tester = new StressTester(balancerUrl, duration, concurrency);
+  tester.runTest().catch(console.error);
+}
+
+module.exports = { StressTester };