jerkjs 2.5.8 → 2.6.1

package/lib/queue/example.js

@@ -0,0 +1,268 @@
+/**
+ * Ejemplo de uso del sistema de colas para el framework JERK
+ * Archivo de ejemplo: queue/example.js
+ * Demostración con 3 colas distintas
+ */
+
+// Importar el sistema de colas
+const QueueIntegration = require('./integration');
+const { hooks } = require('../../index.js'); // Suponiendo que se está usando dentro del framework
+
+// Crear una instancia de la integración de colas
+const queueIntegration = new QueueIntegration();
+const queueSystem = queueIntegration.getQueueSystem();
+
+// Ejemplo de tarea para la cola de procesamiento de imágenes
+function tareaProcesamientoImagen(datos, taskObj) {
+  return new Promise((resolve, reject) => {
+    console.log(`[IMAGEN] Procesando imagen: ${datos.nombreArchivo}`);
+    
+    // Simular un proceso de procesamiento de imagen
+    setTimeout(() => {
+      if (Math.random() < 0.2) { // 20% de probabilidad de fallo
+        console.error(`[IMAGEN] Falló el procesamiento de: ${datos.nombreArchivo}`);
+        reject(new Error(`Error procesando imagen: ${datos.nombreArchivo}`));
+      } else {
+        console.log(`[IMAGEN] Imagen procesada exitosamente: ${datos.nombreArchivo}`);
+        resolve(`Imagen ${datos.nombreArchivo} procesada con éxito`);
+      }
+    }, 2000);
+  });
+}
+
+// Ejemplo de tarea para la cola de envío de correos
+function tareaEnvioCorreo(datos, taskObj) {
+  return new Promise((resolve, reject) => {
+    console.log(`[CORREO] Enviando correo a: ${datos.destinatario}`);
+    
+    // Simular un proceso de envío de correo
+    setTimeout(() => {
+      if (Math.random() < 0.15) { // 15% de probabilidad de fallo
+        console.error(`[CORREO] Falló el envío a: ${datos.destinatario}`);
+        reject(new Error(`Error enviando correo a: ${datos.destinatario}`));
+      } else {
+        console.log(`[CORREO] Correo enviado exitosamente a: ${datos.destinatario}`);
+        resolve(`Correo enviado a ${datos.destinatario} con éxito`);
+      }
+    }, 1500);
+  });
+}
+
+// Ejemplo de tarea para la cola de procesamiento de pagos
+function tareaProcesamientoPago(datos, taskObj) {
+  return new Promise((resolve, reject) => {
+    console.log(`[PAGO] Procesando pago de: $${datos.monto} para ${datos.usuario}`);
+    
+    // Simular un proceso de procesamiento de pago
+    setTimeout(() => {
+      if (Math.random() < 0.25) { // 25% de probabilidad de fallo
+        console.error(`[PAGO] Falló el procesamiento de pago para: ${datos.usuario}`);
+        reject(new Error(`Error procesando pago para: ${datos.usuario}`));
+      } else {
+        console.log(`[PAGO] Pago procesado exitosamente para: ${datos.usuario}`);
+        resolve(`Pago de $${datos.monto} para ${datos.usuario} procesado con éxito`);
+      }
+    }, 3000);
+  });
+}
+
+// Configurar la cola de procesamiento de imágenes con hooks personalizados
+function setupColaImagenes() {
+  const HookSystem = require('../../lib/core/hooks');
+  const imagenHooks = new HookSystem();
+  
+  // Hook para personalizar la lógica de procesamiento de tareas de imagen
+  imagenHooks.addAction('queue_execute_task', (task, queueName, taskObj) => {
+    console.log(`[IMAGEN] Preparando para procesar tarea de imagen: ${taskObj.id}`);
+    // Aquí puedes modificar la tarea o agregar lógica personalizada
+    const wrappedTask = async (datos, taskObj) => {
+      console.log(`[IMAGEN] Iniciando ejecución de tarea de imagen: ${taskObj.id} con datos:`, datos);
+      try {
+        const result = await task(datos, taskObj);
+        console.log(`[IMAGEN] Tarea de imagen completada: ${taskObj.id}`);
+        return result;
+      } catch (error) {
+        console.log(`[IMAGEN] Error en tarea de imagen: ${taskObj.id} - ${error.message}`);
+        throw error;
+      }
+    };
+    return wrappedTask;
+  });
+  
+  // Hook para manejar la lógica de fallback para tareas de imagen
+  imagenHooks.addAction('queue_task_fallback', (queueName, task, error) => {
+    console.log(`[IMAGEN] Ejecutando lógica de fallback para tarea de imagen:`, error.message);
+    // Aquí puedes implementar la lógica de fallback personalizada para imágenes
+    console.log(`[IMAGEN] Guardando información de error para procesamiento posterior...`);
+  });
+  
+  // Crear la cola de imágenes con los hooks personalizados
+  queueIntegration.createQueue('imagenes', { 
+    concurrency: 3, 
+    retryAttempts: 2, 
+    retryDelay: 1000
+  }, imagenHooks);
+}
+
+// Configurar la cola de envío de correos con hooks personalizados
+function setupColaCorreos() {
+  const HookSystem = require('../../lib/core/hooks');
+  const correoHooks = new HookSystem();
+  
+  // Hook para personalizar la lógica de procesamiento de tareas de correo
+  correoHooks.addAction('queue_execute_task', (task, queueName, taskObj) => {
+    console.log(`[CORREO] Preparando para enviar correo: ${taskObj.id}`);
+    // Aquí puedes modificar la tarea o agregar lógica personalizada
+    const wrappedTask = async (datos, taskObj) => {
+      console.log(`[CORREO] Iniciando ejecución de tarea de correo: ${taskObj.id} con datos:`, datos);
+      try {
+        const result = await task(datos, taskObj);
+        console.log(`[CORREO] Tarea de correo completada: ${taskObj.id}`);
+        return result;
+      } catch (error) {
+        console.log(`[CORREO] Error en tarea de correo: ${taskObj.id} - ${error.message}`);
+        throw error;
+      }
+    };
+    return wrappedTask;
+  });
+  
+  // Hook para manejar la lógica de fallback para tareas de correo
+  correoHooks.addAction('queue_task_fallback', (queueName, task, error) => {
+    console.log(`[CORREO] Ejecutando lógica de fallback para tarea de correo:`, error.message);
+    // Aquí puedes implementar la lógica de fallback personalizada para correos
+    console.log(`[CORREO] Agregando destinatario a lista de reintento...`);
+  });
+  
+  // Crear la cola de correos con los hooks personalizados
+  queueIntegration.createQueue('correos', { 
+    concurrency: 2, 
+    retryAttempts: 3, 
+    retryDelay: 2000
+  }, correoHooks);
+}
+
+// Configurar la cola de procesamiento de pagos con hooks personalizados
+function setupColaPagos() {
+  const HookSystem = require('../../lib/core/hooks');
+  const pagoHooks = new HookSystem();
+  
+  // Hook para personalizar la lógica de procesamiento de tareas de pago
+  pagoHooks.addAction('queue_execute_task', (task, queueName, taskObj) => {
+    console.log(`[PAGO] Preparando para procesar pago: ${taskObj.id}`);
+    // Aquí puedes modificar la tarea o agregar lógica personalizada
+    const wrappedTask = async (datos, taskObj) => {
+      console.log(`[PAGO] Iniciando ejecución de tarea de pago: ${taskObj.id} con datos:`, datos);
+      try {
+        const result = await task(datos, taskObj);
+        console.log(`[PAGO] Tarea de pago completada: ${taskObj.id}`);
+        return result;
+      } catch (error) {
+        console.log(`[PAGO] Error en tarea de pago: ${taskObj.id} - ${error.message}`);
+        throw error;
+      }
+    };
+    return wrappedTask;
+  });
+  
+  // Hook para manejar la lógica de fallback para tareas de pago
+  pagoHooks.addAction('queue_task_fallback', (queueName, task, error) => {
+    console.log(`[PAGO] Ejecutando lógica de fallback para tarea de pago:`, error.message);
+    // Aquí puedes implementar la lógica de fallback personalizada para pagos
+    console.log(`[PAGO] Marcando transacción como pendiente para revisión manual...`);
+  });
+  
+  // Crear la cola de pagos con los hooks personalizados
+  queueIntegration.createQueue('pagos', { 
+    concurrency: 1, 
+    retryAttempts: 5, 
+    retryDelay: 3000
+  }, pagoHooks);
+}
+
+// Ejemplo de uso con 3 colas distintas
+function ejemploDeUso() {
+  // Configurar las 3 colas con sus hooks personalizados
+  setupColaImagenes();
+  setupColaCorreos();
+  setupColaPagos();
+  
+  // Agregar tareas a la cola de imágenes
+  console.log("\nAgregando tareas a la cola de imágenes...");
+  for (let i = 0; i < 5; i++) {
+    const taskId = queueIntegration.addTask('imagenes', tareaProcesamientoImagen, { 
+      id: i, 
+      nombreArchivo: `imagen_${i}.jpg`,
+      tamano: `${Math.floor(Math.random() * 10) + 1}MB`
+    }, i); // Usar el índice como prioridad (0 es la más alta)
+    
+    console.log(`Tarea de imagen agregada con ID: ${taskId}`);
+  }
+  
+  // Agregar tareas a la cola de correos
+  console.log("\nAgregando tareas a la cola de correos...");
+  const destinatarios = ['juan@ejemplo.com', 'maria@ejemplo.com', 'pedro@ejemplo.com', 'ana@ejemplo.com', 'luis@ejemplo.com'];
+  for (let i = 0; i < destinatarios.length; i++) {
+    const taskId = queueIntegration.addTask('correos', tareaEnvioCorreo, { 
+      id: i, 
+      destinatario: destinatarios[i],
+      asunto: `Mensaje de prueba #${i}`
+    }, i);
+    
+    console.log(`Tarea de correo agregada con ID: ${taskId}`);
+  }
+  
+  // Agregar tareas a la cola de pagos
+  console.log("\nAgregando tareas a la cola de pagos...");
+  const usuarios = ['Cliente A', 'Cliente B', 'Cliente C', 'Cliente D', 'Cliente E'];
+  for (let i = 0; i < usuarios.length; i++) {
+    const taskId = queueIntegration.addTask('pagos', tareaProcesamientoPago, { 
+      id: i, 
+      usuario: usuarios[i],
+      monto: (Math.floor(Math.random() * 1000) + 100),
+      metodo: i % 2 === 0 ? 'Tarjeta' : 'PayPal'
+    }, i);
+    
+    console.log(`Tarea de pago agregada con ID: ${taskId}`);
+  }
+  
+  // Iniciar el procesamiento de tareas
+  console.log("\nIniciando el sistema de colas...");
+  queueIntegration.start();
+  
+  // Mostrar estado periódicamente
+  setInterval(() => {
+    console.log('\n--- Estado del sistema de colas ---');
+    const status = queueIntegration.getStatus();
+    for (const [queueName, queueStatus] of Object.entries(status)) {
+      console.log(`${queueName}: Pendientes=${queueStatus.pendingTasks}, En proceso=${queueStatus.runningTasks}, Fallidas=${queueStatus.failedTasks}`);
+    }
+    console.log('------------------------------------\n');
+  }, 5000);
+  
+  // Detener el sistema después de 60 segundos
+  setTimeout(() => {
+    console.log("\nDeteniendo el sistema de colas...");
+    queueIntegration.stop();
+    console.log('Sistema de colas detenido');
+    
+    // Mostrar estado final
+    console.log('\n--- Estado final del sistema de colas ---');
+    const finalStatus = queueIntegration.getStatus();
+    for (const [queueName, queueStatus] of Object.entries(finalStatus)) {
+      console.log(`${queueName}: Pendientes=${queueStatus.pendingTasks}, En proceso=${queueStatus.runningTasks}, Fallidas=${queueStatus.failedTasks}`);
+    }
+    console.log('------------------------------------------\n');
+  }, 60000);
+}
+
+// Exportar para que pueda ser usado en otros lugares
+module.exports = {
+  QueueIntegration,
+  ejemploDeUso
+};
+
+// Si este archivo se ejecuta directamente, correr el ejemplo
+if (require.main === module) {
+  ejemploDeUso();
+}

package/lib/queue/integration.js

@@ -0,0 +1,109 @@
+/**
+ * Integración del Sistema de Colas para el framework JERK
+ * Implementación del componente queue/integration.js
+ * Archivo de integración para usar el sistema de colas como extensión del framework
+ */
+
+const { queueSystem } = require('./GlobalQueueStorage');
+
+class QueueIntegration {
+  /**
+   * Constructor de la integración
+   * @param {Object} options - Opciones de configuración
+   */
+  constructor(options = {}) {
+    // Usar el sistema de colas global
+    this.queueSystem = queueSystem;
+    
+    // Obtener los hooks del framework
+    try {
+      const framework = require('../../index.js');
+      this.globalHooks = framework.hooks;
+    } catch (error) {
+      // Si no está disponible, crear instancia local
+      const HookSystem = require('../core/hooks');
+      this.globalHooks = new HookSystem();
+    }
+  }
+
+  /**
+   * Inicializa la integración con el framework
+   * @param {Object} frameworkInstance - Instancia del framework JERK
+   */
+  initialize(frameworkInstance) {
+    // Registrar el sistema de colas en la instancia del framework
+    frameworkInstance.queueSystem = this.queueSystem;
+    
+    // Disparar hook cuando se inicializa la integración
+    this.globalHooks.doAction('queue_integration_initialized', this.queueSystem);
+  }
+
+  /**
+   * Obtiene el sistema de colas
+   * @returns {QueueSystem} - Instancia del sistema de colas
+   */
+  getQueueSystem() {
+    return this.queueSystem;
+  }
+
+  /**
+   * Crea una cola específica con hooks personalizados
+   * @param {string} queueName - Nombre de la cola
+   * @param {Object} options - Opciones específicas para la cola
+   * @param {Object} hooks - Sistema de hooks específico para esta cola (opcional)
+   * @returns {Object} - Cola creada
+   */
+  createQueue(queueName, options = {}, hooks = null) {
+    // Si se proporcionan hooks específicos para esta cola, usarlos
+    if (hooks) {
+      options.hooks = hooks;
+    }
+
+    // Crear la cola con las opciones
+    return this.queueSystem.getOrCreateQueue(queueName, options);
+  }
+
+  /**
+   * Agrega una tarea a una cola
+   * @param {string} queueName - Nombre de la cola
+   * @param {Function} task - Función que representa la tarea
+   * @param {Object} data - Datos para la tarea
+   * @param {number} priority - Prioridad de la tarea
+   * @returns {string} - ID único de la tarea
+   */
+  addTask(queueName, task, data = {}, priority = 0) {
+    return this.queueSystem.addTask(queueName, task, data, priority);
+  }
+
+  /**
+   * Inicia la ejecución de tareas en todas las colas
+   */
+  start() {
+    this.queueSystem.start();
+  }
+
+  /**
+   * Detiene la ejecución de tareas en todas las colas
+   */
+  stop() {
+    this.queueSystem.stop();
+  }
+
+  /**
+   * Obtiene el estado actual del sistema de colas
+   * @returns {Object} - Estado del sistema de colas
+   */
+  getStatus() {
+    return this.queueSystem.getStatus();
+  }
+
+  /**
+   * Reintenta todas las tareas fallidas en una cola específica
+   * @param {string} queueName - Nombre de la cola
+   */
+  retryFailedTasks(queueName) {
+    this.queueSystem.retryFailedTasks(queueName);
+  }
+}
+
+module.exports = QueueIntegration;

package/lib/utils/globalViewCacheInfo.js

@@ -0,0 +1,16 @@
+/**
+ * Almacenamiento global de información del caché de vistas para el framework JERK
+ */
+
+// Crear un objeto global para almacenar información del caché de vistas
+const globalViewCacheInfo = {
+  viewCache: new Map(), // Cache de vistas compiladas
+  cacheStats: {
+    hits: 0,
+    misses: 0,
+    totalViews: 0
+  },
+  viewDependencies: new Map() // Registro de dependencias entre vistas (inclusiones)
+};
+
+module.exports = { globalViewCacheInfo };

package/lib/utils/globalWAFStats.js

@@ -0,0 +1,54 @@
+/**
+ * Sistema de Almacenamiento Global de Estadísticas del WAF (Web Application Firewall)
+ * Almacenamiento centralizado de datos del firewall para acceso eficiente
+ */
+
+// Objeto global para almacenar estadísticas del WAF
+const globalWAFStats = {
+  // Contadores de solicitudes
+  requestsProcessed: 0,
+  responsesSent: 0,
+  
+  // Contadores de bytes
+  requestBytes: 0,
+  responseBytes: 0,
+  
+  // Registro de accesos a rutas
+  routeAccesses: new Map(), // Mapa de rutas y número de accesos
+  
+  // Registro de hits a endpoints
+  endpointHits: new Map(), // Mapa de endpoints y número de hits
+  
+  // IPs bloqueadas temporalmente
+  blockedIPs: new Map(), // Mapa de IPs bloqueadas con información de bloqueo
+  
+  // IPs en lista blanca (nunca bloqueadas)
+  whitelist: new Set(),
+  
+  // IPs en lista negra (siempre bloqueadas)
+  blacklist: new Set(),
+  
+  // Reglas de seguridad activas
+  securityRules: new Map(), // Mapa de reglas de seguridad
+
+  // Reglas de headers X-
+  xHeaderRules: new Map(), // Mapa de reglas de headers X-
+
+  // Tipos de ataques detectados
+  attackTypes: new Set(), // Conjunto de tipos de ataques detectados
+
+  // Contador de intentos de ataque
+  attackAttempts: 0,
+
+  // Registros de seguridad
+  securityLogs: [],
+
+  // Estadísticas de rendimiento
+  performanceStats: {
+    startTime: new Date().toISOString(),
+    requestProcessingTime: 0,
+    averageResponseTime: 0
+  }
+};
+
+module.exports = { globalWAFStats };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jerkjs",
-  "version": "2.5.8",
-  "description": "JERK Framework v2.5.8 - A comprehensive framework for building secure and scalable APIs with frontend support, sessions, template engine, integration with qbuilderjs, complete MVC architecture with models, enhanced route loading from directory, improved model loading system, administration extension, and fixed routing issues with static and parametrized routes",
+  "version": "2.6.1",
+  "description": "JERK Framework v2.6.1 - A comprehensive framework for building secure and scalable APIs with frontend support, sessions, template engine, integration with qbuilderjs, complete MVC architecture with models, enhanced route loading from directory, improved model loading system, administration extension, queue management system, route cache management module, and fixed routing issues with static and parametrized routes",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",

package/test-colors.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+/**
+ * Script de prueba para verificar que los colores funcionan en el módulo de cache de rutas
+ * Este script simula la interacción con el módulo para verificar la visualización de comandos en color
+ */
+
+// Simulación de socket para probar la funcionalidad de color
+const mockSocket = {
+  data: '',
+  write: function(text) {
+    this.data += text;
+    // En un entorno real, esto escribiría en el socket
+    process.stdout.write(text);
+  }
+};
+
+// Importar el módulo
+const RouteCacheModule = require('./lib/admin/modules/RouteCacheModule');
+
+// Crear una instancia simulada de adminExtension
+const mockAdminExtension = {
+  frameworkInstance: {
+    routeMatcher: {
+      routeRegexCache: new Map([
+        ['/users/:id', /^\/users\/([^\/]+?)$/],
+        ['/posts/:slug', /^\/posts\/([^\/]+?)$/]
+      ]),
+      exactRoutes: new Map([
+        ['GET:/api/users', { handler: { name: 'getUserHandler' }, isStatic: false }],
+        ['POST:/api/users', { handler: { name: 'createUserHandler' }, isStatic: false }]
+      ]),
+      indexesValid: true
+    }
+  }
+};
+
+// Crear instancia del módulo
+const routeCacheModule = new RouteCacheModule(mockAdminExtension);
+
+console.log('Probando el módulo de cache de rutas con colores...\n');
+
+// Probar el manejo de un comando desconocido para ver el mensaje con comandos en verde
+routeCacheModule.handleCommand('comando-invalido', mockSocket);
+
+console.log('\nFin de la prueba.');

package/test-help-alias.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+/**
+ * Script de prueba para verificar que el alias '?' funciona en el sistema de administración
+ */
+
+const { APIServer } = require('./index.js');
+
+// Crear instancia del servidor
+const server = new APIServer({ port: 3001 }); // Usar un puerto diferente para evitar conflictos
+
+// Agregar una ruta de ejemplo
+server.addRoute('GET', '/', (req, res) => {
+  res.writeHead(200, { 'Content-Type': 'text/plain' });
+  res.end('Hola Mundo!');
+});
+
+// Inicializar la extensión de administración
+server.initializeAdminExtension({
+  port: 9998, // Usar un puerto diferente para evitar conflictos
+  host: '127.0.0.1'
+});
+
+console.log('Servidor de prueba iniciado en http://localhost:3001');
+console.log('Servidor de administración en tcp://localhost:9998');
+console.log('\nPara probar el alias "?":');
+console.log('- Conéctate al servidor de administración con: telnet localhost 9998 o nc localhost 9998');
+console.log('- Escribe "?" y presiona Enter para ver la ayuda');
+
+// Iniciar el servidor
+server.start();

package/ESTADISTICAS_RENDIMIENTO.md

@@ -1,106 +0,0 @@
-# Informe de Pruebas del Módulo de Estadísticas - JERK Framework v2.5.8
-
-## Resumen Ejecutivo
-
-El módulo de estadísticas para la extensión de administración de JERK Framework ha sido sometido a pruebas exhaustivas que demuestran su capacidad para capturar y mostrar métricas precisas del servidor en tiempo real. Las pruebas incluyeron desde operaciones básicas hasta pruebas de estrés con 20,000 solicitudes concurrentes.
-
-## Características del Módulo de Estadísticas
-
-### Funcionalidades Implementadas
-1. **Cantidad de requests procesados mostrando kilobytes**
-2. **Cantidad de responses enviadas mostrando kilobytes**
-3. **Accesos a las rutas registradas (input y output)**
-4. **Endpoints y rutas más accedidas**
-
-### Comandos Disponibles
-- `stats` o `statistics`: Muestra estadísticas generales del servidor
-- `requests`: Muestra estadísticas específicas de solicitudes
-- `endpoints`: Muestra estadísticas de endpoints y rutas más accedidas
-
-## Pruebas Realizadas
-
-### 1. Pruebas Básicas
-- Login con usuario testuser: ✅ Exitoso
-- Consumo de endpoints con autenticación: ✅ Exitoso
-- Uso del endpoint qwen con cola asincrónica: ✅ Exitoso
-
-### 2. Pruebas con Apache Bench (ab)
-- 100 solicitudes concurrentes a 10 por vez: ✅ Exitoso
-- 50 solicitudes concurrentes al endpoint de resultados qwen: ✅ Exitoso
-- 500 solicitudes concurrentes a 20 por vez: ✅ Exitoso
-- 1000 solicitudes concurrentes a 50 por vez: ✅ Exitoso
-- **20,000 solicitudes concurrentes a 100 por vez**: ✅ Exitoso
-
-### 3. Pruebas de Rendimiento
-- **Rendimiento Máximo**: 1,235.46 RPS (requests por segundo)
-- **Tiempo Total de Prueba**: 16.188 segundos para 20,000 solicitudes
-- **Conexiones Concurrentes**: 100
-- **Tasa de Éxito**: 100% (0 fallos)
-
-## Resultados de las Pruebas
-
-### Estadísticas Generales (Después de 20,000 solicitudes)
-- **Solicitudes procesadas**: 21,666
-- **Solicitudes procesadas (KB)**: 740 Bytes
-- **Respuestas enviadas**: 21,666
-- **Respuestas enviadas (KB)**: 287.69 MB
-- **Rutas registradas**: 45
-- **Rutas activas**: 10
-
-### Distribución de Accesos
-- **GET /api/endpoints**: 20,602 accesos (dominante por la prueba de estrés)
-- **GET /api/qwen/result/:id**: 1,051 accesos
-- **POST /api/qwen/queue**: 3 accesos
-- **POST /api/analytics**: 3 accesos
-- **Otros endpoints**: variados accesos
-
-### Métricas de Rendimiento
-- **Transfer rate**: 17,911.75 KB/s recibidos
-- **Tiempo medio por solicitud**: 80.942 ms
-- **Tiempo de procesamiento**: 15-272 ms (rango)
-- **50% de solicitudes**: respondidas en ≤75 ms
-- **99% de solicitudes**: respondidas en ≤172 ms
-
-## Validación de Requisitos
-
-### ✅ Cantidad de requests procesados mostrando kilobytes
-- Contador preciso de solicitudes: 21,666
-- Medición de bytes recibidos: 740 Bytes
-
-### ✅ Cantidad de responses enviadas mostrando kilobytes
-- Contador preciso de respuestas: 21,666
-- Medición de bytes enviados: 287.69 MB
-
-### ✅ Accesos a las rutas registradas (input y output)
-- Registro detallado de todas las rutas accedidas
-- Visualización clara de accesos por método y ruta
-
-### ✅ Endpoints y rutas más accedidas
-- Visualización de endpoints más accedidos (top 10)
-- Visualización de rutas más accedidas (top 10)
-- Actualización en tiempo real
-
-## Arquitectura del Sistema de Estadísticas
-
-### Componentes Principales
-1. **`globalStats`**: Sistema de almacenamiento global en `lib/utils/globalStats.js`
-2. **Actualización directa**: Las estadísticas se actualizan en el servidor cuando ocurren eventos
-3. **Módulo StatsModule**: Lee las estadísticas globales y las muestra a través de comandos
-
-### Ventajas del Diseño
-- **Acceso directo**: Sin dependencia de hooks para actualización
-- **Confiable**: Persistencia de datos entre solicitudes
-- **Rápido**: Bajo overhead de procesamiento
-- **Escalable**: Funciona eficientemente bajo alta carga
-
-## Conclusiones
-
-El módulo de estadísticas para JERK Framework v2.5.8 ha demostrado un rendimiento excepcional bajo condiciones de estrés extremo. Las pruebas con 20,000 solicitudes concurrentes han confirmado que:
-
-1. **Estabilidad**: 0 fallos en 20,000 solicitudes
-2. **Precisión**: Métricas actualizadas correctamente en tiempo real
-3. **Rendimiento**: Más de 1,200 RPS consistentes
-4. **Escalabilidad**: Capacidad para manejar alta concurrencia
-5. **Funcionalidad**: Cumplimiento completo de todos los requisitos
-
-El módulo está listo para producción y proporciona una herramienta invaluable para el monitoreo y análisis del rendimiento del servidor.

package/debug_hook.js

@@ -1,11 +0,0 @@
-// Modificar temporalmente el archivo de hooks para mostrar la estructura completa del objeto
-const { hooks } = require('../index.js');
-
-// Hook para registrar cada ruta encontrada - versión de depuración
-hooks.addAction('route_matched', (matchedRoute, req, res) => {
-    console.log(`[${new Date().toISOString()}] DEBUG route_matched:`);
-    console.log(`  matchedRoute:`, JSON.stringify(matchedRoute, null, 2));
-    console.log(`  req.method:`, req ? req.method : 'undefined');
-    console.log(`  req.url:`, req ? req.url : 'undefined');
-    console.log('---');
-});