kukuy 1.5.0 → 1.9.0

package/README-SSL.md

@@ -1,165 +0,0 @@
-# Kukuy - Balanceador de Carga con SSL
-
-![Kukuy Logo](kukuu1.webp)
-
-Este documento explica cómo configurar e iniciar el balanceador Kukuy con soporte SSL/TLS.
-
-## Información del Proyecto
-
-- **Página Oficial**: [https://bsanchez.unaux.com/](https://bsanchez.unaux.com/)
-- **Repositorio Oficial**: [https://gitlab.com/bytedogssyndicate1/kukuy](https://gitlab.com/bytedogssyndicate1/kukuy)
-
-## Contenido
-
-- [Requisitos](#requisitos)
-- [Configuración de SSL](#configuración-de-ssl)
-- [Inicio del Balanceador con SSL](#inicio-del-balanceador-con-ssl)
-- [Uso de ngrok con SSL](#uso-de-ngrok-con-ssl)
-- [Scripts Disponibles](#scripts-disponibles)
-- [Variables de Entorno](#variables-de-entorno)
-- [Configuración de Servidores](#configuración-de-servidores)
-
-## Requisitos
-
-- Node.js instalado
-- OpenSSL (para generar certificados autofirmados)
-- Opcional: ngrok para exponer servicios locales a Internet
-
-## Configuración de SSL
-
-### Generar Certificados Autofirmados
-
-Para generar certificados SSL autofirmados, ejecuta el siguiente comando:
-
-```bash
-mkdir -p certs/auto
-openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout certs/auto/private.key -out certs/auto/certificate.crt -subj "/C=ES/ST=Madrid/L=Madrid/O=Kukuy/OU=IT Department/CN=localhost"
-```
-
-Esto creará los siguientes archivos:
-- `certs/auto/certificate.crt`: El certificado SSL
-- `certs/auto/private.key`: La llave privada
-
-### Usar Certificados Existentes
-
-Si tienes certificados SSL válidos emitidos por una CA, colócalos en el directorio `certs/auto` o en cualquier ubicación de tu elección y actualiza las rutas en las variables de entorno.
-
-## Inicio del Balanceador con SSL
-
-### Método 1: Variables de Entorno Directas
-
-```bash
-SSL_CERT_PATH=certs/auto/certificate.crt SSL_KEY_PATH=certs/auto/private.key BALANCER_HTTPS_PORT=8443 CONFIG_FILE_PATH=./servers_real.json node kukuy.js
-```
-
-### Método 2: Usando Scripts Preparados
-
-El proyecto incluye scripts para facilitar el inicio:
-
-```bash
-# Iniciar con SSL usando el script básico
-./start-ssl.sh
-
-# Iniciar con SSL usando el script de configuración
-./start-ssl-config.sh
-```
-
-Por defecto, ambos scripts utilizan el archivo `servers_real.json` para la configuración de servidores.
-
-## Uso de ngrok con SSL
-
-Para exponer tu balanceador SSL a Internet a través de ngrok:
-
-1. Instala ngrok desde https://ngrok.com/download
-2. Ejecuta el siguiente comando:
-
-```bash
-ngrok tls 8443
-```
-
-Esto creará un túnel seguro que redirigirá las conexiones SSL a tu balanceador local en el puerto 8443.
-
-Alternativamente, puedes usar un túnel HTTP si prefieres que ngrok maneje la terminación SSL:
-
-```bash
-ngrok http https://localhost:8443
-```
-
-## Scripts Disponibles
-
-### `start-ssl.sh`
-
-Script básico para iniciar Kukuy en modo SSL con valores predeterminados:
-- Puerto HTTPS: 8443
-- Archivo de certificado: `certs/auto/certificate.crt`
-- Archivo de llave privada: `certs/auto/private.key`
-- Archivo de configuración de servidores: `servers_real.json`
-
-Opcionalmente, puedes habilitar el modo HTTP simultáneamente:
-```bash
-ENABLE_HTTP=true ./start-ssl.sh
-```
-
-### `start-ssl-config.sh`
-
-Script que carga la configuración desde el archivo `.env.ssl`. Este archivo contiene todas las variables de entorno necesarias para la operación del balanceador con SSL.
-
-## Variables de Entorno
-
-Las siguientes variables de entorno controlan la configuración SSL:
-
-- `SSL_CERT_PATH`: Ruta al archivo de certificado SSL
-- `SSL_KEY_PATH`: Ruta al archivo de llave privada SSL
-- `BALANCER_HTTPS_PORT`: Puerto en el que escuchará el servidor HTTPS
-- `BALANCER_HTTP_PORT`: Puerto opcional para el servidor HTTP (si se desea mantener ambos)
-- `CONFIG_FILE_PATH`: Ruta al archivo de configuración de servidores
-- `ROUTES_FILE_PATH`: Ruta al archivo de configuración de rutas
-- `LOG_LEVEL`: Nivel de logging (info, debug, warn, error)
-- `HEALTH_CHECK_INTERVAL`: Intervalo para verificaciones de salud de servidores (en milisegundos)
-
-## Configuración de Servidores
-
-El balanceador puede leer la configuración de servidores desde archivos JSON. Por defecto, este setup utiliza `servers_real.json` que contiene:
-
-```json
-{
-  "servers": [
-    {
-      "url": "http://localhost:3434",
-      "weight": 1,
-      "tags": ["backend"]
-    },
-    {
-      "url": "http://localhost:8765",
-      "weight": 1,
-      "tags": ["backend"]
-    },
-    {
-      "url": "http://localhost:5445",
-      "weight": 1,
-      "tags": ["backend"]
-    }
-  ]
-}
-```
-
-Puedes modificar este archivo para apuntar a tus servidores backend reales o crear nuevos archivos de configuración según sea necesario.
-
-## Panel de Control
-
-Una vez iniciado el balanceador, el panel de control web estará disponible en:
-- HTTP: http://localhost:8082
-
-## Solución de Problemas
-
-### Certificados SSL Autofirmados
-
-Cuando uses certificados autofirmados, los navegadores mostrarán advertencias de seguridad. Esto es normal y esperado. Para producción, utiliza certificados firmados por una Autoridad de Certificación (CA) reconocida.
-
-### Puertos Bloqueados
-
-Asegúrate de que los puertos que deseas usar (por defecto 8443 para HTTPS y 8082 para el panel) estén disponibles y no sean usados por otros servicios.
-
-### Conexión a Servidores Backend
-
-Verifica que los servidores backend definidos en el archivo de configuración estén accesibles desde la máquina donde corre el balanceador.

package/kukuy.workspace

@@ -1,11 +0,0 @@
-{
- "NodeJS": {
-  "metadata": {
-   "version": "1.0",
-   "ide": "CodeLite",
-   "type": "NodeJS"
-  },
-  "folders": ["."],
-  "m_showHiddenFiles": false
- }
-}

package/optimize-mariadb.sh

@@ -1,152 +0,0 @@
-#!/bin/bash
-
-# Script para optimizar MariaDB y liberar espacio en disco
-# Autor: Sistema de Optimización
-# Fecha: $(date +%Y-%m-%d)
-
-set -e  # Salir si ocurre algún error
-
-echo "=== Iniciando optimización de MariaDB y liberación de espacio ==="
-
-# Crear directorio para backups
-BACKUP_DIR="/home/bds/kukuy/backups-$(date +%Y%m%d_%H%M%S)"
-mkdir -p "$BACKUP_DIR"
-
-echo "Directorio de backup: $BACKUP_DIR"
-
-# 1. BACKUP DE ARCHIVOS DE CONFIGURACIÓN DE MARIADB
-echo ""
-echo "1. Realizando backup de archivos de configuración..."
-
-CONFIG_FILES=(
-    "/etc/mysql/mariadb.conf.d/50-server.cnf"
-    "/etc/mysql/mariadb.conf.d/50-client.cnf"
-    "/etc/mysql/mariadb.conf.d/50-mysql-clients.cnf"
-    "/etc/mysql/my.cnf"
-    "/etc/mysql/debian-start"
-)
-
-for config_file in "${CONFIG_FILES[@]}"; do
-    if [ -f "$config_file" ]; then
-        cp "$config_file" "$BACKUP_DIR/$(basename "$config_file")"
-        echo "  - Backup de $config_file realizado"
-    else
-        echo "  - $config_file no encontrado"
-    fi
-done
-
-# 2. LIBERAR ESPACIO EN DISCO
-echo ""
-echo "2. Liberando espacio en disco..."
-
-# Limpiar paquetes desactualizados
-echo "  - Limpiando paquetes desactualizados..."
-sudo apt autoremove -y 2>/dev/null || echo "  - No se pudo ejecutar apt autoremove (sin privilegios)"
-
-# Limpiar cache de paquetes
-echo "  - Limpiando cache de paquetes..."
-sudo apt autoclean 2>/dev/null || echo "  - No se pudo ejecutar apt autoclean (sin privilegios)"
-
-# Limpiar logs antiguos (sin sudo)
-echo "  - Buscando logs grandes en /tmp..."
-find /tmp -name "*.log" -size +100M -delete 2>/dev/null || echo "  - No se pudieron eliminar logs en /tmp (sin privilegios)"
-
-# Limpiar historial de comandos si es necesario
-echo "  - Verificando tamaño de archivos de historial..."
-if [ -f "$HOME/.bash_history" ] && [ $(stat -c%s "$HOME/.bash_history" 2>/dev/null || echo 0) -gt 100000 ]; then
-    tail -n 1000 "$HOME/.bash_history" > "$HOME/.bash_history.tmp" && mv "$HOME/.bash_history.tmp" "$HOME/.bash_history"
-    echo "    Archivo de historial reducido"
-fi
-
-# 3. OPTIMIZACIÓN DE CONFIGURACIÓN DE MARIADB
-echo ""
-echo "3. Optimizando configuración de MariaDB..."
-
-SERVER_CONFIG="/etc/mysql/mariadb.conf.d/50-server.cnf"
-
-if [ -f "$SERVER_CONFIG" ]; then
-    # Crear copia de seguridad temporal
-    TEMP_CONFIG="$BACKUP_DIR/50-server.cnf.optimized"
-    cp "$SERVER_CONFIG" "$TEMP_CONFIG"
-    
-    # Aplicar optimizaciones (solo si se puede escribir)
-    if [ -w "$SERVER_CONFIG" ]; then
-        echo "  - Aplicando optimizaciones a $SERVER_CONFIG"
-        
-        # Ajustar tamaño del buffer pool de InnoDB (si hay suficiente RAM)
-        TOTAL_RAM=$(free -m | awk 'NR==2{print $2}')
-        if [ $TOTAL_RAM -gt 2048 ]; then
-            # Si hay más de 2GB de RAM, asignar 25% a buffer pool
-            BUFFER_POOL_SIZE=$((TOTAL_RAM * 25 / 100))
-            BUFFER_POOL_BYTES=$((BUFFER_POOL_SIZE * 1024 * 1024))
-        else
-            # Si hay menos de 2GB, asignar 128MB
-            BUFFER_POOL_BYTES=134217728
-        fi
-        
-        # Ajustar configuración de logs para reducir uso de disco
-        sudo tee -a "$SERVER_CONFIG" > /dev/null << EOF
-
-# Optimizaciones añadidas por optimize-mariadb.sh
-[mysqld]
-# Ajustar tamaño del buffer pool de InnoDB
-innodb_buffer_pool_size = ${BUFFER_POOL_BYTES}
-
-# Reducir tamaño de logs para ahorrar espacio en disco
-innodb_log_file_size = 67108864  # 64MB
-innodb_log_files_in_group = 2
-
-# Configurar rotación de logs binarios
-expire_logs_days = 3
-max_binlog_size = 100M
-
-# Limitar tamaño de queries temporales
-tmp_table_size = 64M
-max_heap_table_size = 64M
-
-# Ajustar timeouts para liberar conexiones rápidamente
-wait_timeout = 300
-interactive_timeout = 300
-
-# Habilitar slow query log con umbral razonable
-slow_query_log = 1
-long_query_time = 2
-slow_query_log_file = /var/log/mysql/slow.log
-EOF
-        echo "    Configuración optimizada aplicada"
-    else
-        echo "    No se tienen permisos para modificar $SERVER_CONFIG"
-        echo "    Las optimizaciones recomendadas son:"
-        echo "    - innodb_buffer_pool_size = [25% de RAM disponible]"
-        echo "    - innodb_log_file_size = 64M"
-        echo "    - expire_logs_days = 3"
-        echo "    - wait_timeout = 300"
-    fi
-else
-    echo "  - $SERVER_CONFIG no encontrado"
-fi
-
-# 4. ANALIZAR USO DE ESPACIO EN MARIADB
-echo ""
-echo "4. Analizando uso de espacio en bases de datos..."
-
-# Obtener información de tamaño de bases de datos
-mysql -u root -e "
-SELECT 
-    table_schema AS 'Base de Datos',
-    ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS 'Tamaño (MB)'
-FROM information_schema.tables 
-GROUP BY table_schema
-ORDER BY (data_length + index_length) DESC;
-" 2>/dev/null || echo "  - No se pudo acceder a la información de bases de datos"
-
-# 5. RECOMENDACIONES FINALES
-echo ""
-echo "=== Recomendaciones ==="
-echo "1. Revisa el directorio de backup: $BACKUP_DIR"
-echo "2. Reinicia MariaDB para aplicar cambios de configuración:"
-echo "   sudo systemctl restart mariadb"
-echo "3. Considera eliminar archivos innecesarios en el sistema"
-echo "4. Monitorea el uso de disco regularmente con 'df -h'"
-echo ""
-echo "=== Optimización completada ==="

package/restart-balancer.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-# Script para matar e iniciar KUKUY con estadísticas por servidor y WebSocket
-
-echo "Matando procesos existentes de KUKUY..."
-pkill -f "node kukuy.js" 2>/dev/null || true
-
-sleep 2
-
-echo "Iniciando KUKUY con estadísticas por servidor y WebSocket..."
-LOAD_BALANCING_ALGORITHM=roundrobin CONFIG_FILE_PATH=./servers_real.json BALANCER_HTTP_PORT=8088 DASHBOARD_PORT=8082 WEBSOCKET_PORT=8084 node kukuy.js

package/scripts/load_test.py

@@ -1,151 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script de prueba de carga concurrente para el balanceador
-"""
-
-import threading
-import time
-import requests
-import sys
-from datetime import datetime
-
-# Configuración
-BASE_URL = "http://localhost:8081"
-ENDPOINT = "/api/endpoints"
-NUM_THREADS = 100  # Número de hilos concurrentes para alta carga
-REQUESTS_PER_THREAD = 6000  # Solicitudes por hilo (100 hilos * 60 solicitudes = 6000 solicitudes totales por segundo)
-DURATION_SECONDS = 120  # Duración de la prueba en segundos (2 minutos)
-TARGET_RPS = 5000  # Objetivo de solicitudes por segundo
-
-# Variables globales para métricas
-total_requests = 0
-successful_requests = 0
-failed_requests = 0
-lock = threading.Lock()
-
-def make_requests_continuous(thread_id, end_time_target):
-    """Función que realiza solicitudes HTTP continuas hasta alcanzar la duración objetivo"""
-    global total_requests, successful_requests, failed_requests
-
-    thread_start_time = time.time()
-    thread_successful = 0
-    thread_failed = 0
-
-    # Calcular el intervalo entre solicitudes para alcanzar el objetivo RPS
-    interval = 1.0 / (TARGET_RPS / NUM_THREADS) if NUM_THREADS > 0 else 0.001  # Evitar división por cero
-
-    while time.time() < end_time_target:
-        try:
-            response = requests.get(f"{BASE_URL}{ENDPOINT}", timeout=10)
-            with lock:
-                total_requests += 1
-                if response.status_code == 200:
-                    successful_requests += 1
-                    thread_successful += 1
-                else:
-                    failed_requests += 1
-                    thread_failed += 1
-        except requests.exceptions.RequestException as e:
-            with lock:
-                total_requests += 1
-                failed_requests += 1
-                thread_failed += 1
-            if thread_id == 0:  # Solo imprimir errores para el primer hilo
-                print(f"[Thread-{thread_id}] Error en solicitud: {e}")
-
-        # Esperar el intervalo calculado para alcanzar el objetivo RPS
-        time.sleep(interval)
-
-    thread_end_time = time.time()
-    thread_duration = thread_end_time - thread_start_time
-
-    print(f"[Thread-{thread_id}] Completado: {thread_successful} exitosas, {thread_failed} fallidas en {thread_duration:.2f}s")
-
-
-def make_requests(thread_id):
-    """Función original que realiza solicitudes HTTP en un hilo (mantenida por compatibilidad)"""
-    global total_requests, successful_requests, failed_requests
-
-    thread_start_time = time.time()
-    thread_successful = 0
-    thread_failed = 0
-
-    for i in range(REQUESTS_PER_THREAD):
-        try:
-            response = requests.get(f"{BASE_URL}{ENDPOINT}", timeout=10)
-            with lock:
-                total_requests += 1
-                if response.status_code == 200:
-                    successful_requests += 1
-                    thread_successful += 1
-                else:
-                    failed_requests += 1
-                    thread_failed += 1
-        except requests.exceptions.RequestException as e:
-            with lock:
-                total_requests += 1
-                failed_requests += 1
-                thread_failed += 1
-            if thread_id == 0:  # Solo imprimir errores para el primer hilo
-                print(f"[Thread-{thread_id}] Error en solicitud {i+1}: {e}")
-
-    thread_end_time = time.time()
-    thread_duration = thread_end_time - thread_start_time
-
-    print(f"[Thread-{thread_id}] Completado: {thread_successful} exitosas, {thread_failed} fallidas en {thread_duration:.2f}s")
-
-def run_load_test():
-    """Función principal que ejecuta la prueba de carga"""
-    global total_requests, successful_requests, failed_requests
-
-    print(f"Iniciando prueba de carga...")
-    print(f"- URL base: {BASE_URL}")
-    print(f"- Endpoint: {ENDPOINT}")
-    print(f"- Hilos concurrentes: {NUM_THREADS}")
-    print(f"- Solicitudes por hilo: {REQUESTS_PER_THREAD}")
-    print(f"- Duración: {DURATION_SECONDS} segundos")
-    print(f"- Objetivo RPS: {TARGET_RPS}")
-    print("-" * 50)
-
-    start_time = time.time()
-    end_time_target = start_time + DURATION_SECONDS
-
-    # Crear y arrancar hilos
-    threads = []
-    for i in range(NUM_THREADS):
-        thread = threading.Thread(target=make_requests_continuous, args=(i, end_time_target))
-        threads.append(thread)
-        thread.start()
-
-        # Pequeño retraso entre la creación de hilos para evitar congestión
-        time.sleep(0.001)
-
-    # Esperar a que todos los hilos terminen
-    for thread in threads:
-        thread.join()
-
-    actual_duration = time.time() - start_time
-
-    # Mostrar resultados
-    print("-" * 50)
-    print("RESULTADOS DE LA PRUEBA DE CARGA:")
-    print(f"Tiempo total: {actual_duration:.2f} segundos")
-    print(f"Solicitudes totales: {total_requests}")
-    print(f"Solicitudes exitosas: {successful_requests}")
-    print(f"Solicitudes fallidas: {failed_requests}")
-    print(f"Tasa de éxito: {(successful_requests/total_requests*100) if total_requests > 0 else 0:.2f}%")
-    print(f"RPS Real (Solicitudes por segundo): {total_requests/actual_duration if actual_duration > 0 else 0:.2f}")
-    print(f"RPS Objetivo: {TARGET_RPS}")
-
-    if successful_requests > 0:
-        print(f"RPS Exitoso (Solicitudes exitosas por segundo): {successful_requests/actual_duration if actual_duration > 0 else 0:.2f}")
-
-if __name__ == "__main__":
-    try:
-        run_load_test()
-    except KeyboardInterrupt:
-        print("\nPrueba interrumpida por el usuario.")
-        print(f"Resultados parciales:")
-        print(f"- Solicitudes totales: {total_requests}")
-        print(f"- Solicitudes exitosas: {successful_requests}")
-        print(f"- Solicitudes fallidas: {failed_requests}")

package/stress-test.js

@@ -1,190 +0,0 @@
-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 };