- VERSION 5.09.16

- feat: Implementa control de logs de SQLite granular por DBKey y corrige la concurrencia del Timer en Hot-Swap.
- Este commit introduce una mejora crucial en el rendimiento y la flexibilidad del servidor al permitir el control detallado del registro de logs en SQLite (users.db) por cada base de datos configurada (DB1, DB2, etc.).
- Cambios Principales y Beneficios:
1. Control Granular de Logs: Se reemplazó el flag de control global de logs por un mapa (SQLiteLoggingStatusByDB), permitiendo al administrador deshabilitar el costoso proceso de escritura de query_logs y errores para bases de datos específicas mediante la propiedad enableSQLiteLogs en sus archivos .properties correspondientes.
2. Estabilización del Timer y Hot-Swap:
    ◦ Se corrigió un problema de concurrencia y estado asegurando que timerLogs se inicialice incondicionalmente, resolviendo el error IllegalStateException: Interval must be larger than 0 que ocurría durante el reload.
    ◦ El Timer de limpieza (borraArribaDe15000Logs y VACUUM) ahora se activa solo si al menos una base de datos tiene el logging habilitado (IsAnySQLiteLoggingEnabled), minimizando el overhead de E/S de disco cuando los logs no se requieren.
3. Recarga Dinámica de Estado: El comando manager?command=reload ahora lee la configuración enableSQLiteLogs de todos los conectores nuevos y actualiza atómicamente el estado global de logs, aplicando los cambios sin requerir un reinicio del servidor.

Cambios.bas

@@ -5,165 +5,178 @@ Type=StaticCode
 Version=10.3
 @EndOfDesignText@
 ' ########################################
-' #####     HISTORIAL DE CAMBIOS     #####
+' ##### HISTORIAL DE CAMBIOS #####
 ' ########################################
+
 Sub Process_Globals
-	'- VERSION X.XX.XX (cabios a implementar)
-	'- Agregar que se puedan usar cualquier cantidad de archivos config.properties
-	'- Agregar que se pueda recargar solo un archivo de configuracion o todos a la vez.
-	'- Agregar que el "Test" del manager revise (con el query de Jorge) cuantas conexiones hay actualmente activas,
-	'  o si no en el test, un nuevo handler, talvez "Conexiones".
-	'- Agregar una forma de probar con carga el servidor
-	'- Agregar la opcion de "Queries lentos"
-	
-	' VERSION 5.09.14
-	' -feat: Implementación robusta de monitoreo de pool de conexiones y peticiones activas
 
-	' -Este commit resuelve problemas críticos en el monitoreo del pool de conexiones (C3P0) y el conteo de peticiones activas por base de datos, mejorando significativamente la visibilidad y fiabilidad del rendimiento del servidor jRDC2-Multi.
+'	- VERSION X.XX.XX (cambios a implementar)
+'	- Agregar que se puedan usar cualquier cantidad de archivos config.properties
+'	- Agregar que se pueda recargar solo un archivo de configuracion o todos a la vez.
+'	- Agregar una forma de probar con carga el servidor.
+'	- Agregar algun tipo de autenticación, posiblemente con tokens ... se podria poner
+'	  en el config.properties un token de conexion y solo las peticiones que lo incluyan sean atendidas, o
+'	  guardar los tokens en la BD sqlite.
+'	- Si se implementan los tokens, se podrian ligar los tokens con el "*" de CORS, y los tokens definirian
+'	  los dominios permitidos.
+'	- Ej: token:1224abcd5678fghi, dominio:"keymon.net"
+'	- Ej: token:4321abcd8765fghi, dominio:"*"
+'	- Que los logs, en lugar de guardar de uno en uno en la BD Sqlte, se guarden en memoria, se junten ... por ejemplo 100 y ya que haya 100, se guarden
+'	  en una solo query a la BD Sqlite.
+'	- Que en el reporte de "Queries lentos" se pueda especificar de cuanto tiempo, ahorita esta de la ultima hora, pero que se pueda seleccionar desde una
+'	  lista, por ejemplo 15, 30, 45 y 60 minutos antes.
 
-	' -Problemas Identificados y Resueltos:
-
-	' -1.  **Métricas de `BusyConnections` y `TotalConnections` inconsistentes o siempre en `0` en el `Manager` y `query_logs`:**
-'		    *   **Problema**: Anteriormente, la métrica `busy_connections` en `query_logs` a menudo reportaba `0` o no reflejaba el estado real. De manera similar, el panel de `Manager?command=totalcon` consistentemente mostraba `BusyConnections: 0` y `TotalConnections` estancadas en `InitialPoolSize`, a pesar de que Oracle sí reportaba conexiones activas. Esto generaba confusión sobre el uso real y la expansión del pool.
-'		    *   **Solución**: Se modificó la lógica en los *handlers* (`DBHandlerJSON.bas` y `DBHandlerB4X.bas`) para capturar la métrica `BusyConnections` directamente del pool de C3P0 **inmediatamente después de que el *handler* adquiere una conexión** (`con = Connector.GetConnection(finalDbKey)`). Este valor se pasa explícitamente a la subrutina `Main.LogQueryPerformance` para su registro en `query_logs` y para ser consumido por `Manager.bas` a través de `RDCConnector.GetPoolStats`. Esto garantiza que el valor registrado y reportado refleje con precisión el número de conexiones activas en el instante de su adquisición. Pruebas exhaustivas confirmaron que C3P0 sí reporta conexiones ocupadas y sí expande `TotalConnections` hasta `MaxPoolSize` cuando la demanda lo exige.
-
-	' -2.  **Contador `handler_active_requests` no decrementaba correctamente:**
-'		    *   **Problema**: El contador de peticiones activas por base de datos (`GlobalParameters.ActiveRequestsCountByDB`) no mostraba un decremento consistente, resultando en un conteo que solo aumentaba o mostraba valores erráticos en los logs.
-'		    *   **Solución**:
-'		        *   Se aseguró la declaración `Public ActiveRequestsCountByDB As Map` en `GlobalParameters.bas`.
-'		        *   Se garantizó su inicialización como un `srvr.CreateThreadSafeMap` en `Main.AppStart` para un manejo concurrente seguro de los contadores.
-'		        *   En `DBHandlerJSON.bas`, la `dbKey` (obtenida del parámetro `dbx` del JSON) ahora se resuelve *antes* de incrementar el contador, asegurando que el incremento y el decremento se apliquen siempre a la misma clave de base de datos correcta.
-'		        *   Se implementó una coerción explícita a `Int` (`.As(Int)`) para todas las operaciones de lectura y escritura (`GetDefault`, `Put`) en `GlobalParameters.ActiveRequestsCountByDB`, resolviendo problemas de tipo que causaban inconsistencias y el fallo en el decremento.
-'		        *   La lógica de decremento en `Private Sub CleanupAndLog` (presente en ambos *handlers*) se hizo más robusta, verificando que el contador sea mayor que cero antes de decrementar para evitar valores negativos.
-
-	' -Beneficios de estos Cambios:
-
-'		*   **Monitoreo Preciso y Fiable**: Las métricas `busy_connections` y `handler_active_requests` en `query_logs` y el panel `Manager` ahora son totalmente fiables, proporcionando una visión clara y en tiempo real del uso del pool de conexiones y la carga de peticiones activas por base de datos.
-'		*   **Diagnóstico Mejorado**: La visibilidad interna del estado del pool de C3P0 durante las pruebas confirma que la configuración de `RDCConnector` es correcta y que el pool se expande y contrae según lo esperado por la demanda.
-'		*   **Robustez del Código**: La gestión de contadores de peticiones activas es ahora consistente, thread-safe y a prueba de fallos de tipo, mejorando la estabilidad general del servidor bajo carga.
-
-	
-	
-	'- VERSION 5.09.13.3
-	'- Implementación de "Hot-Swap" para recarga de configuraciones de DB sin reiniciar el servidor.
-	'- Migración a ReentrantLock para sincronización debido a incompatibilidad con 'Sync'.
-
-	'- **Problemas Resueltos:**
-
-	'- 1. **Falta de "Hot-Swap" en `reload`:** El comando `reload` en `Manager.bas` no permitía la recarga dinámica de las configuraciones de la base de datos (config.properties) sin necesidad de reiniciar el servidor. La implementación anterior simplemente re-inicializaba las instancias existentes de `RDCConnector` in-situ, sin liberar los recursos de los pools de conexión anteriores, lo cual era ineficiente y propenso a errores.
-	'- 2. **Ausencia de un mecanismo de cierre de pools:** No existía un método `Close` en `RDCConnector.bas` que permitiera cerrar ordenadamente los `ConnectionPool` (C3P0) y liberar las conexiones a la base de datos, lo que era crítico para un "hot-swap" limpio .
-	'- 3. **Incompatibilidad con `Sync`:** La palabra clave `Sync` de B4X no era reconocida por el entorno de desarrollo del usuario, impidiendo su uso para la sincronización de hilos necesaria en el "hot-swap".
-	'- 4. **Ausencia de `Finally` en B4X:** La palabra clave `Finally` (común en otros lenguajes como Java para asegurar la liberación de recursos) no está disponible directamente en B4X, lo cual planteó un desafío para garantizar la liberación del `ReentrantLock` de forma segura.
-
-	'- **Cambios Implementados:**
-
-	'- **En `Main.bas`:**
-	'- * **Declaración de `MainConnectorsLock`:** Se añadió `Public MainConnectorsLock As JavaObject` en `Sub Process_Globals` para declarar una instancia de `java.util.concurrent.locks.ReentrantLock`, que servirá como objeto de bloqueo global para proteger el mapa `Main.Connectors`.
-	'- * **Inicialización de `MainConnectorsLock`:** Se inicializó `MainConnectorsLock.InitializeNewInstance("java.util.concurrent.locks.ReentrantLock", Null)` en `Sub AppStart`, asegurando que el objeto de bloqueo esté listo al inicio del servidor.
-
-	'- **En `RDCConnector.bas`:**
-	'- * **Método `Public Sub Close`:** Se añadió esta subrutina al final del módulo. Utiliza `JavaObject` para invocar `joPool.RunMethod("close", Null)` sobre la instancia subyacente de C3P0, permitiendo un cierre ordenado y la liberación de todas las conexiones del pool .
-
-	'- **En `Manager.bas`:**
-	'- * **Reemplazo completo de la lógica `If Command = "reload" Then`:**
-	'-   * **Creación de `newConnectors`:** Se crea un mapa temporal (`Dim newConnectors As Map`) para inicializar las **nuevas instancias** de `RDCConnector` con la configuración fresca de los archivos `.properties` .
-	'-   * **Preservación de `oldConnectors`:** Se almacena una referencia al mapa `Main.Connectors` actual en un nuevo mapa (`Dim oldConnectors As Map`) para tener acceso a los conectores antiguos que necesitan ser cerrados .
-	'-   * **Sincronización con `ReentrantLock`:** Para proteger la manipulación del mapa `Main.Connectors` (que es compartido por múltiples hilos), se utilizan `Main.MainConnectorsLock.RunMethod("lock", Null)` y `Main.MainConnectorsLock.RunMethod("unlock", Null)`. Esto asegura que el reemplazo del mapa sea atómico, es decir, que solo un hilo pueda acceder a `Main.Connectors` durante la lectura y la escritura .
-	'-   * **Manejo de Bloqueo Seguro sin `Finally`:** Dado que `Finally` no está disponible en B4X, se implementó un patrón con una bandera booleana (`lockAcquired`) dentro de un bloque `Try...Catch` para garantizar que `unlock()` siempre se ejecute si `lock()` fue exitoso, previniendo interbloqueos .
-	'-   * **Cierre explícito de `oldConnectors`:** Después de que los `newConnectors` reemplazan a los `oldConnectors`, se itera sobre el mapa `oldConnectors` y se llama a `oldRDC.Close` para cada conector, liberando sus recursos de base de datos de manera limpia .
-	'-   * **Validación de inicialización y control de errores:** Se agregó lógica para verificar el éxito de la inicialización de los nuevos conectores y abortar el "hot-swap" si ocurre un error crítico, manteniendo los conectores antiguos activos para evitar una interrupción del servicio .
-	'-   * **Registro detallado:** Se mejoró la salida del log HTML del `Manager` para mostrar el proceso de recarga, las estadísticas de los pools recién inicializados y el cierre de los antiguos, incluyendo JSON detallado de las métricas de C3P0 .
-
-	'- • Beneficio: Estos cambios dotan al servidor jRDC2-Multi de una capacidad crítica para actualizar sus configuraciones de conexión a bases de datos en caliente, sin necesidad de reiniciar el servicio. Esto mejora la disponibilidad, simplifica el mantenimiento y previene fugas de recursos al asegurar el cierre ordenado de los pools de conexión antiguos.
-
-	'- VERSION 5.09.13.2
-	'-	Módulo: DBHandlerJSON.bas
-	'-	Descripción de Cambios: Manejo de Peticiones POST con Content-Type: application/json
-	'-	• Problema Identificado: La implementación anterior de DBHandlerJSON procesaba las peticiones POST esperando que el payload JSON se encontrara en el parámetro j de la URL (req.GetParameter("j")). Esto impedía la correcta lectura de peticiones POST que utilizaban Content-Type: application/json, donde el JSON se envía directamente en el cuerpo de la petición (InputStream). Como resultado, los clientes recibían un error indicando la ausencia del parámetro j .
-	'-	• Solución Implementada:
-	'-	1. Se modificó la lógica en el método Handle para detectar explícitamente las peticiones POST con Content-Type igual a application/json.
-	'-	2. En estos casos, el payload JSON ahora se lee directamente del InputStream de la petición (req.InputStream).
-	'-	3. Se utilizó Bit.InputStreamToBytes(Is0) para leer el cuerpo completo de la petición a un Array de bytes, seguido de BytesToString para convertirlo en la cadena JSON.
-	'-	4. Se añadió el cierre explícito del InputStream (Is0.Close) para asegurar la liberación de recursos .
-	'-	5. Se corrigió el nombre de la variable Is a Is0 para evitar un conflicto con la palabra reservada Is de B4X .
-	'-	6. Se actualizó el mensaje de error para aclarar que el JSON puede faltar tanto en el parámetro j como en el cuerpo de la petición.
-	'-	• Beneficio: Esta corrección asegura que el DBHandlerJSON sea compatible con el "Método Recomendado" de POST con application/json, mejorando la robustez y la adherencia a los estándares de las APIs web, Sin comprometer la retrocompatibilidad con el "Método Legacy" (GET con parámetro j).
-	
-	'- VERSION 5.09.13
-'	feat: Mejora la inicialización del pool de conexiones y el soporte multi-DB.
+'	- Versión: 5.09.16
+'	- feat: Implementa control de logs de SQLite granular por DBKey y corrige la concurrencia del Timer en Hot-Swap.
+'	- Este commit introduce una mejora crucial en el rendimiento y la flexibilidad del servidor al permitir el control detallado del registro de logs en SQLite (users.db) por cada base de datos configurada (DB1, DB2, etc.).
+'	- Cambios Principales y Beneficios:
+'	1. Control Granular de Logs: Se reemplazó el flag de control global de logs por un mapa (SQLiteLoggingStatusByDB), permitiendo al administrador deshabilitar el costoso proceso de escritura de query_logs y errores para bases de datos específicas mediante la propiedad enableSQLiteLogs en sus archivos .properties correspondientes.
+'	2. Estabilización del Timer y Hot-Swap:
+'	◦ Se corrigió un problema de concurrencia y estado asegurando que timerLogs se inicialice incondicionalmente, resolviendo el error IllegalStateException: Interval must be larger than 0 que ocurría durante el reload.
+'	◦ El Timer de limpieza (borraArribaDe15000Logs y VACUUM) ahora se activa solo si al menos una base de datos tiene el logging habilitado (IsAnySQLiteLoggingEnabled), minimizando el overhead de E/S de disco cuando los logs no se requieren.
+'	3. Recarga Dinámica de Estado: El comando manager?command=reload ahora lee la configuración enableSQLiteLogs de todos los conectores nuevos y actualiza atómicamente el estado global de logs, aplicando los cambios Sin requerir un reinicio del servidor.
 '	
-'	- Este commit aborda y resuelve varios problemas críticos relacionados con la inicialización
-'	  del pool de conexiones (C3P0) para múltiples bases de datos y la depuración de logs
-'	  en el servidor jRDC2-Multi.
+'	- VERSION 5.09.16
+'	feat: Implementa tolerancia de parámetros configurable y mejora estabilidad general del servidor.
+'	La tolerancia de parametros permite que si un query requiere 3 parametros y se mandan 4, NO mande un error,
+'	solo manda a la base de datos los parametros correctos y tira los extras, y guarda una "ADVERTENCIA" en el Log de errores.
+'	
+'	Este commit introduce la funcionalidad de `parameterTolerance` configurable y aborda varias mejoras críticas para la estabilidad y eficiencia del jRDC2-Multi.
 '
-'	  **Problemas Resueltos:**
+'	Principales cambios y beneficios:
+'	- **Tolerancia de Parámetros**: Añade la propiedad `parameterTolerance` en `config.properties` para controlar el manejo de parámetros de más. Cuando está habilitada, recorta los parámetros excesivos; si está deshabilitada (modo estricto, por defecto), genera un error, aumentando la robustez de la validación.
+'	- **Inicialización Multi-DB Confiable**: Corrige la lógica de inicialización en `Main.AppStart` para `RDCConnector` de DB3 y DB4, asegurando que cada base de datos tenga su propio *pool* de conexiones correctamente configurado.
+'	- **Optimización de Ejecución SQL**: Elimina llamadas duplicadas a `ExecQuery2` y `ExecNonQuery2` en `DBHandlerB4X.bas`, garantizando que solo los parámetros validados se utilicen y evitando ejecuciones redundantes en la base de datos.
+'	- **Refactorización y Limpieza**: Se eliminó la declaración duplicada de `ActiveRequestsCountByDB` en `Main.bas` y la subrutina `Handle0` obsoleta en `Manager.bas`, mejorando la claridad y mantenibilidad del código.
 '	
-'	  1.  **Inicialización de `TotalConnections: 0` en todos los pools:** Anteriormente, el Log mostraba 0 conexiones inicializadas para todas las bases de datos (DB1, DB2, DB3, DB4) durante `AppStart`, a pesar de que los `handlers` de `DBHandlerB4X` y `DBHandlerJSON` podían conectarse más tarde bajo demanda. Esto indicaba un fallo silencioso en la creación de conexiones iniciales por parte de C3P0.
-'	  2.  **Configuración inconsistente de C3P0:** Parámetros críticos de C3P0 como `acquireRetryAttempts` y `breakAfterAcquireFailure` no se aplicaban correctamente al inicio, manteniendo los valores por defecto que ocultaban errores de conexión.
-'	  3.  **`jdbcUrl` truncado/vacío:** Se observó que la `jdbcUrl` aparecía truncada o vacía en algunos logs de C3P0, indicando un problema en la carga de la configuración. 
+'	- VERSION 5.09.15
+'
+'	 1.  **Nuevas Funcionalidades en el Panel de Administración (Manager):**
+'	     *   Se añadió el comando `slowqueries` al `Manager` para permitir la visualización de las 20 consultas más lentas registradas en la tabla `query_logs` de SQLite [22].
+'	     *   Se mejoró el comando `totalcon` en `Manager.bas` para mostrar estadísticas detalladas de *todos* los pools de conexión C3P0 configurados, obteniendo métricas en tiempo real (TotalConnections, BusyConnections, IdleConnections, etc.) de cada `RDCConnector` [2, 22].
+'	     *   Beneficio: Mayor visibilidad y control proactivo sobre el rendimiento y el uso de recursos del servidor desde la interfaz de administración.
 '	
-'	**Cambios Implementados:**
+'	 2.  **Optimización de la Gestión de Logs (`query_logs`):**
+'	     *   Se implementó un `Public timerLogs As Timer` en `Main.bas` [conversación], que se inicializa en `AppStart` y ejecuta periódicamente (cada 10 minutos) la subrutina `borraArribaDe15000Logs`.
+'	     *   La subrutina `borraArribaDe15000Logs` recorta la tabla `query_logs` en `users.db` para mantener solo los 15,000 registros más recientes, y luego realiza un `vacuum` para optimizar el espacio en disco utilizado por la base de datos SQLite [conversación].
+'	     *   Beneficio: Prevención del crecimiento excesivo de la base de datos de logs de rendimiento, manteniendo un historial manejable y optimizando el uso del almacenamiento a largo plazo.
+'
+'	- VERSION 5.09.14 (Ahora consolidado en 5.09.15)
+'	 -feat: Implementación robusta de monitoreo de pool de conexiones y peticiones activas
+'	 -Este commit resuelve problemas críticos en el monitoreo del pool de conexiones (C3P0) y el conteo de peticiones activas por base de datos, mejorando significativamente la visibilidad y fiabilidad del rendimiento del servidor jRDC2-Multi.
+'	 -Problemas Identificados y Resueltos:
+'	 -1. **Métricas de `BusyConnections` y `TotalConnections` inconsistentes o siempre en `0` en el `Manager` y `query_logs`:**
+'	 * **Problema**: Anteriormente, la métrica `busy_connections` en `query_logs` a menudo reportaba `0` o no reflejaba el estado real. De manera similar, el panel de `Manager?command=totalcon` consistentemente mostraba `BusyConnections: 0` y `TotalConnections` estancadas en `InitialPoolSize`, a pesar de que Oracle sí reportaba conexiones activas. Esto generaba confusión sobre el uso real y la expansión del pool.
+'	 * **Solución**: Se modificó la lógica en los *handlers* (`DBHandlerJSON.bas` y `DBHandlerB4X.bas`) para capturar la métrica `BusyConnections` directamente del pool de C3P0 **inmediatamente después de que el *handler* adquiere una conexión** (`con = Connector.GetConnection(finalDbKey)`). Este valor se pasa explícitamente a la subrutina `Main.LogQueryPerformance` para su registro en `query_logs` y para ser consumido por `Manager.bas` a través de `RDCConnector.GetPoolStats`. Esto garantiza que el valor registrado y reportado refleje con precisión el número de conexiones activas en el instante de su adquisición. Pruebas exhaustivas confirmaron que C3P0 sí reporta conexiones ocupadas y sí expande `TotalConnections` hasta `MaxPoolSize` cuando la demanda lo exige.
+'	 -2. **Contador `handler_active_requests` no decrementaba correctamente:**
+'	 * **Problema**: El contador de peticiones activas por base de datos (`GlobalParameters.ActiveRequestsCountByDB`) no mostraba un decremento consistente, resultando en un conteo que solo aumentaba o mostraba valores erráticos en los logs.
+'	 * **Solución**:
+'	 * Se aseguró la declaración `Public ActiveRequestsCountByDB As Map` en `GlobalParameters.bas`.
+'	 * Se garantizó su inicialización como un `srvr.CreateThreadSafeMap` en `Main.AppStart` para un manejo concurrente seguro de los contadores.
+'	 * En `DBHandlerJSON.bas`, la `dbKey` (obtenida del parámetro `dbx` del JSON) ahora se resuelve *antes* de incrementar el contador, asegurando que el incremento y el decremento se apliquen siempre a la misma clave de base de datos correcta.
+'	 * Se implementó una coerción explícita a `Int` (`.As(Int)`) para todas las operaciones de lectura y escritura (`GetDefault`, `Put`) en `GlobalParameters.ActiveRequestsCountByDB`, resolviendo problemas de tipo que causaban inconsistencias y el fallo en el decremento.
+'	 * La lógica de decremento en `Private Sub CleanupAndLog` (presente en ambos *handlers*) se hizo más robusta, verificando que el contador sea mayor que cero antes de decrementar para evitar valores negativos.
+'	 -Beneficios de estos Cambios:
+'	 * **Monitoreo Preciso y Fiable**: Las métricas `busy_connections` y `handler_active_requests` en `query_logs` y el panel `Manager` ahora son totalmente fiables, proporcionando una visión clara y en tiempo real del uso del pool de conexiones y la carga de peticiones activas por base de datos.
+'	 * **Diagnóstico Mejorado**: La visibilidad interna del estado del pool de C3P0 durante las pruebas confirma que la configuración de `RDCConnector` es correcta y que el pool se expande y contrae según lo esperado por la demanda.
+'	 * **Robustez del Código**: La gestión de contadores de peticiones activas es ahora consistente, thread-safe y a prueba de fallos de tipo, mejorando la estabilidad general del servidor bajo carga.
+'
+'	- VERSION 5.09.13.3 (Ahora consolidado en 5.09.15)
+'	- Implementación de "Hot-Swap" para recarga de configuraciones de DB sin reiniciar el servidor.
+'	- Migración a ReentrantLock para sincronización debido a incompatibilidad con 'Sync'.
+'	- **Problemas Resueltos:**
+'	- 1. **Falta de "Hot-Swap" en `reload`:** El comando `reload` en `Manager.bas` no permitía la recarga dinámica de las configuraciones de la base de datos (config.properties) sin necesidad de reiniciar el servidor. La implementación anterior simplemente re-inicializaba las instancias existentes de `RDCConnector` in-situ, sin liberar los recursos de los pools de conexión anteriores, lo cual era ineficiente y propenso a errores.
+'	- 2. **Ausencia de un mecanismo de cierre de pools:** No existía un método `Close` en `RDCConnector.bas` que permitiera cerrar ordenadamente los `ConnectionPool` (C3P0) y liberar las conexiones a la base de datos, lo que era crítico para un "hot-swap" limpio .
+'	- 3. **Incompatibilidad con `Sync`:** La palabra clave `Sync` de B4X no era reconocida por el entorno de desarrollo del usuario, impidiendo su uso para la sincronización de hilos necesaria en el "hot-swap".
+'	- 4. **Ausencia de `Finally` en B4X:** La palabra clave `Finally` (común en otros lenguajes como Java para asegurar la liberación de recursos) no está disponible directamente en B4X, lo cual planteó un desafío para garantizar la liberación del `ReentrantLock` de forma segura.
+'	- **Cambios Implementados:**
+'	- **En `Main.bas`:**
+'	- * **Declaración de `MainConnectorsLock`:** Se añadió `Public MainConnectorsLock As JavaObject` en `Sub Process_Globals` para declarar una instancia de `java.util.concurrent.locks.ReentrantLock`, que servirá como objeto de bloqueo global para proteger el mapa `Main.Connectors`.
+'	- * **Inicialización de `MainConnectorsLock`:** Se inicializó `MainConnectorsLock.InitializeNewInstance("java.util.concurrent.locks.ReentrantLock", Null)` en `Sub AppStart`, asegurando que el objeto de bloqueo esté listo al inicio del servidor.
+'	- **En `RDCConnector.bas`:**
+'	- * **Método `Public Sub Close`:** Se añadió esta subrutina al final del módulo. Utiliza `JavaObject` para invocar `joPool.RunMethod("close", Null)` sobre la instancia subyacente de C3P0, permitiendo un cierre ordenado y la liberación de todas las conexiones del pool .
+'	- **En `Manager.bas`:**
+'	- * **Reemplazo completo de la lógica `If Command = "reload" Then`:**
+'	- * **Creación de `newConnectors`:** Se crea un mapa temporal (`Dim newConnectors As Map`) para inicializar las **nuevas instancias** de `RDCConnector` con la configuración fresca de los archivos `.properties` .
+'	- * **Preservación de `oldConnectors`:** Se almacena una referencia al mapa `Main.Connectors` actual en un nuevo mapa (`Dim oldConnectors As Map`) para tener acceso a los conectores antiguos que necesitan ser cerrados .
+'	- * **Sincronización con `ReentrantLock`:** Para proteger la manipulación del mapa `Main.Connectors` (que es compartido por múltiples hilos), se utilizan `Main.MainConnectorsLock.RunMethod("lock", Null)` y `Main.MainConnectorsLock.RunMethod("unlock", Null)`. Esto asegura que el reemplazo del mapa sea atómico, es decir, que solo un hilo pueda acceder a `Main.Connectors` durante la lectura y la escritura .
+'	- * **Manejo de Bloqueo Seguro sin `Finally`:** Dado que `Finally` no está disponible en B4X, se implementó un patrón con una bandera booleana (`lockAcquired`) dentro de un bloque `Try...Catch` para garantizar que `unlock()` siempre se ejecute si `lock()` fue exitoso, previniendo interbloqueos .
+'	- * **Cierre explícito de `oldConnectors`:** Después de que los `newConnectors` reemplazan a los `oldConnectors`, se itera sobre el mapa `oldConnectors` y se llama a `oldRDC.Close` para cada conector, liberando sus recursos de base de datos de manera limpia .
+'	- * **Validación de inicialización y control de errores:** Se agregó lógica para verificar el éxito de la inicialización de los nuevos conectores y abortar el "hot-swap" si ocurre un error crítico, manteniendo los conectores antiguos activos para evitar una interrupción del servicio .
+'	- * **Registro detallado:** Se mejoró la salida del log HTML del `Manager` para mostrar el proceso de recarga, las estadísticas de los pools recién inicializados y el cierre de los antiguos, incluyendo JSON detallado de las métricas de C3P0 .
+'	- • Beneficio: Estos cambios dotan al servidor jRDC2-Multi de una capacidad crítica para actualizar sus configuraciones de conexión a bases de datos en caliente, sin necesidad de reiniciar el servicio. Esto mejora la disponibilidad, simplifica el mantenimiento y previene fugas de recursos al asegurar el cierre ordenado de los pools de conexión antiguos.
+'
+'	- VERSION 5.09.13.2 (Ahora consolidado en 5.09.15)
+'	- Módulo: DBHandlerJSON.bas
+'	- Descripción de Cambios: Manejo de Peticiones POST con Content-Type: application/json
+'	- • Problema Identificado: La implementación anterior de DBHandlerJSON procesaba las peticiones POST esperando que el payload JSON se encontrara en el parámetro j de la URL (req.GetParameter("j")). Esto impedía la correcta lectura de peticiones POST que utilizaban Content-Type: application/json, donde el JSON se envía directamente en el cuerpo de la petición (InputStream). Como resultado, los clientes recibían un error indicando la ausencia del parámetro j .
+'	- • Solución Implementada:
+'	- 1. Se modificó la lógica en el método Handle para detectar explícitamente las peticiones POST con Content-Type igual a application/json.
+'	- 2. En estos casos, el payload JSON ahora se lee directamente del InputStream de la petición (req.InputStream).
+'	- 3. Se utilizó Bit.InputStreamToBytes(Is0) para leer el cuerpo completo de la petición a un Array de bytes, seguido de BytesToString para convertirlo en la cadena JSON.
+'	- 4. Se añadió el cierre explícito del InputStream (Is0.Close) para asegurar la liberación de recursos .
+'	- 5. Se corrigió el nombre de la variable Is a Is0 para evitar un conflicto con la palabra reservada Is de B4X .
+'	- 6. Se actualizó el mensaje de error para aclarar que el JSON puede faltar tanto en el parámetro j como en el cuerpo de la petición.
+'	- • Beneficio: Esta corrección asegura que el DBHandlerJSON sea compatible con el "Método Recomendado" de POST con application/json, mejorando la robustez y la adherencia a los estándares de las APIs web, Sin comprometer la retrocompatibilidad con el "Método Legacy" (GET con parámetro j).
+'
+'	- VERSION 5.09.13 (Ahora consolidado en 5.09.15)
+'	 feat: Mejora la inicialización del pool de conexiones y el soporte multi-DB.
 '	
-'	**En `Main.bas`:**
+'	 **Problemas Resueltos:**
 '	
-'	*   **Declaración de conectores:** Se aseguró la declaración de variables `Dim conX As RDCConnector` separadas para cada conector (con1, con2, con3, con4) para evitar conflictos de variables y asegurar la inicialización correcta. 
-	
-'	**En `RDCConnector.bas`:**
+'	 1. **Inicialización de `TotalConnections: 0` en todos los pools:** Anteriormente, el Log mostraba 0 conexiones inicializadas para todas las bases de datos (DB1, DB2, DB3, DB4) durante `AppStart`, a pesar de que los `handlers` de `DBHandlerB4X` y `DBHandlerJSON` podían conectarse más tarde bajo demanda. Esto indicaba un fallo silencioso en la creación de conexiones iniciales por parte de C3P0.
+'	 2. **Configuración inconsistente de C3P0:** Parámetros críticos de C3P0 como `acquireRetryAttempts` y `breakAfterAcquireFailure` no se aplicaban correctamente al inicio, manteniendo los valores por defecto que ocultaban errores de conexión.
+'	 3. **`jdbcUrl` truncado/vacío:** Se observó que la `jdbcUrl` aparecía truncada o vacía en algunos logs de C3P0, indicando un problema en la carga de la configuración.
 '	
-'	*   **Corrección de *shadowing* de `config`:** Se modificó `LoadConfigMap(DB)` para asignar directamente a la variable de clase `config` (eliminando `Dim` local), resolviendo el problema de la `jdbcUrl` truncada y asegurando que cada `RDCConnector` use su configuración específica de manera persistente. 
-'	*   **Reordenamiento y robustecimiento de `Initialize`:**
-'	*   **Carga de `config`:** Se asegura que `config` se cargue completamente en la variable de clase antes de cualquier operación del pool.
-'	*   **Configuración de C3P0:** Todas las propiedades del pool (incluyendo `setInitialPoolSize`, `setMinPoolSize`, `setMaxPoolSize`, `setMaxIdleTime`, etc. ahora se aplican mediante `jo.RunMethod` *inmediatamente después* de `pool.Initialize` y *antes* de que el pool intente adquirir conexiones. 
-'	*   **Forzar reportes de errores:** Se añadieron las líneas `jo.RunMethod("setAcquireRetryAttempts", Array As Object(1))` y `jo.RunMethod("setBreakAfterAcquireFailure", Array As Object(True))`. Estas son cruciales para forzar a C3P0 a lanzar una `SQLException` explícita si falla al crear las conexiones iniciales, en lugar de fallar silenciosamente. 
-'	*   **Activación forzada del pool:** Se implementó `Dim tempCon As SQL = pool.GetConnection` seguido de `tempCon.Close` dentro de un bloque `Try...Catch`. Esto obliga al pool a establecer las conexiones iniciales (`InitialPoolSize`) con la configuración ya aplicada, permitiendo la captura de errores reales si la conexión falla.
+'	 **Cambios Implementados:**
+'	
+'	 **En `Main.bas`:**
+'	
+'	 * **Declaración de conectores:** Se aseguró la declaración de variables `Dim conX As RDCConnector` separadas para cada conector (con1, con2, con3, con4) para evitar conflictos de variables y asegurar la inicialización correcta.
+'	
+'	 **En `RDCConnector.bas`:**
+'	
+'	 * **Corrección de shadowing de `config`:** Se modificó `LoadConfigMap(DB)` para asignar directamente a la variable de clase `config` (eliminando `Dim` local), resolviendo el problema de la `jdbcUrl` truncada y asegurando que cada `RDCConnector` use su configuración específica de manera persistente.
+'	 * **Reordenamiento y robustecimiento de `Initialize`:**
+'	 * **Carga de `config`:** Se asegura que `config` se cargue completamente en la variable de clase antes de cualquier operación del pool.
+'	 * **Configuración de C3P0:** Todas las propiedades del pool (incluyendo `setInitialPoolSize`, `setMinPoolSize`, `setMaxPoolSize`, `setMaxIdleTime`, etc. ahora se aplican mediante `jo.RunMethod` *inmediatamente después* de `pool.Initialize` y *antes* de que el pool intente adquirir conexiones.
+'	 * **Forzar reportes de errores:** Se añadieron las líneas `jo.RunMethod("setAcquireRetryAttempts", Array As Object(1))` y `jo.RunMethod("setBreakAfterAcquireFailure", Array As Object(True))`. Estas son cruciales para forzar a C3P0 a lanzar una `SQLException` explícita si falla al crear las conexiones iniciales, en lugar de fallar silenciosamente.
+'	 * **Activación forzada del pool:** Se implementó `Dim tempCon As SQL = pool.GetConnection` seguido de `tempCon.Close` dentro de un bloque `Try...Catch`. Esto obliga al pool a establecer las conexiones iniciales (`InitialPoolSize`) con la configuración ya aplicada, permitiendo la captura de errores reales si la conexión falla.
+'
+'	- VERSION 5.09.08
+'	- Se agregó que se puedan configurar en el config.properties los siguientes parametros:
+'	- - setInitialPoolSize = 3
+'	- - setMinPoolSize = 2
+'	- - setMaxPoolSize = 5
+'	- Se agregaron en duro a RDConnector los siguientes parametros:
+'	- - setMaxIdleTime <-- Tiempo máximo de inactividad de la conexión.
+'	- - setMaxConnectionAge <-- Tiempo de vida máximo de una conexión.
+'	- - setCheckoutTimeout <-- Tiempo máximo de espera por una conexión.
+'	- Se agregó en el config.properties, al final del "JdbcUrl" este parametro, que le indica al servidor de Oracle
+'	- el nombre del cliente que se está conectando "?v$session.program=jRDC_Multi"
+'	- VERSION 5.09.08
+'	- Se cambio el codigo para que en lugar de esperar un mapa con los parametros del query y nombres de los parametros (par1, par2, etc) para definir el ordenamiento, ahora se espera una lista [1,"2",3], y el orden de los parametros se toma directamente del orden en el que se mandan, de la misma forma que en B4A.
+'	- VERSION 5.09.04
+'	- Se cambio el nombre del handler de B4X a DBHandlerB4X.
+'	- Se quitaron los handlers que ya no servian.
+'	- VERSION 5.09.01
+'	- Se corrigieron errores en "Manager".
+'	- Se cambiaron nombres de handlers.
+'	- Se corrigio un error en la ruta de "www/login.html".
+'	- VERSION 5.08.31
+'	- Se corrigio que no avisaba cuando el query no requeria parametros y si se enviaban (en el JSONHandler)
+'	- VERSION 5.08.30
+'	- Se cambiaron los 4 handlers de B4A a uno solo que toma el DB de la ruta automáticamente.
+'	- Se agregaron validaciones del numero de parametros y si el query no los requiere o se dan de mas o de menos, manda un error especificando eso, ya no se reciben errores directos de la base de datos, esto fue tanto para B4A como para JSON.
+'	- Se modificó el Readme.md para incluir todos estos cambios.
+'	- VERSION 5.08.25
+'	- Se modificaron los archivos de reinicio de los servicios (servidor y Bow) y se cambio el menu del "manager" para que a seccion de "reload" incluya la liga a reinciar Bow.
+'	- VERSION 5.08.02
+'	- Se hizo un cambio para tratar de que las conexiones se "identifiquen" con Oracle y Jorge pueda saber que conexiones/recursos estamos ocupando
+'	- VERSION 4.11.14
+'	- Se agregó el parametro "setMaxPoolSize=5" para que solo genere 5 conexiones a la base de datos, antes generaba 15.
+'	- Se quitaron lineas previamente comentadas.
+'	- VERSION 4.11.09
+'	- Commit inicial on Nov 9, 2024
 
-	
-	'- VERSION 5.09.08
-	'- Se agregó que se puedan configurar en el config.properties los siguientes parametros:
-	'
-	'  - setInitialPoolSize = 3
-	'  - setMinPoolSize = 2
-	'  - setMaxPoolSize = 5
-	'
-	'- Se agregaron en duro a RDConnector los siguientes parametros:
-	'
-	'  - setMaxIdleTime <-- Tiempo máximo de inactividad de la conexión.
-	'  - setMaxConnectionAge <-- Tiempo de vida máximo de una conexión.
-	'  - setCheckoutTimeout <-- Tiempo máximo de espera por una conexión.
-	'
-	'- Se agregó en el config.properties, al final del "JdbcUrl" este parametro, que le indica al servidor de Oracle
-	'  el nombre del cliente que se está conectando  "?v$session.program=jRDC_Multi"
-
-	'- VERSION 5.09.08
-	'- Se cambio el codigo para que en lugar de esperar un mapa con los parametros del query y nombres de los parametros (par1, par2, etc) para definir el ordenamiento, ahora se espera una lista [1,"2",3], y el orden de los parametros se toma directamente del orden en el que se mandan, de la misma forma que en B4A.
-
-	'- VERSION 5.09.04
-	'- Se cambio el nombre del handler de B4X a DBHandlerB4X.
-	'- Se quitaron los handlers que ya no servian.
-
-	'- VERSION 5.09.01
-	'- Se corrigieron errores en "Manager".
-	'- Se cambiaron nombres de handlers.
-	'- Se corrigio un error en la ruta de "www/login.html".
-
-	'- VERSION 5.08.31
-	'- Se corrigio que no avisaba cuando el query no requeria parametros y si se enviaban (en el JSONHandler)
-
-	'- VERSION 5.08.30
-	'- Se cambiaron los 4 handlers de B4A a uno solo que toma el DB de la ruta automáticamente.
-	'- Se agregaron validaciones del numero de parametros y si el query no los requiere o se dan de mas o de menos, manda un error especificando eso, ya no se reciben errores directos de la base de datos, esto fue tanto para B4A como para JSON.
-	'- Se modificó el Readme.md para incluir todos estos cambios.
-
-	'- VERSION 5.08.25
-	'- Se modificaron los archivos de reinicio de los servicios (servidor y Bow) y se cambio el menu del "manager" para que a seccion de "reload" incluya la liga a reinciar Bow.
-
-	'- VERSION 5.08.02
-	'- Se hizo un cambio para tratar de que las conexiones se "identifiquen" con Oracle y Jorge pueda saber que conexiones/recursos estamos ocupando
-
-	'- VERSION 4.11.14
-	'- Se agregó el parametro "setMaxPoolSize=5" para que solo genere 5 conexiones a la base de datos, antes generaba 15.
-	'- Se quitaron lineas previamente comentadas.
-
-	'- VERSION 4.11.09
-	'- Commit inicial on Nov 9, 2024
-End Sub
+End Sub

ChangePassHandler.bas

@@ -10,7 +10,7 @@ Sub Class_Globals
 End Sub
 
 Public Sub Initialize
-'	bc.Initialize ' <<--- CORRECCIÓN 1: Descomentado para que el objeto se cree.
+	bc.Initialize("BC")
 End Sub
 
 Public Sub Handle(req As ServletRequest, resp As ServletResponse)
@@ -32,8 +32,7 @@ Public Sub Handle(req As ServletRequest, resp As ServletResponse)
 
 	Try
 		Dim storedHash As String = Main.SQL1.ExecQuerySingleResult2("SELECT password_hash FROM users WHERE username = ?", Array As String(currentUser))
-		
-		Log("--- Probando con contraseña fija ---")
+
 		Log("Valor de la BD (storedHash): " & storedHash)
 		If storedHash = Null Or bc.checkpw(currentPass, storedHash) = False Then ' <<--- CAMBIO CLAVE AQUÍ
 			resp.Write("<script>alert('Error: La contraseña actual es incorrecta.'); history.back();</script>")

DBHandlerJSON.bas

@@ -4,222 +4,263 @@ ModulesStructureVersion=1
 Type=Class
 Version=10.3
 @EndOfDesignText@
-' Handler class for JSON requests from Web Clients (JavaScript/axios)
+' Módulo de clase: DBHandlerJSON
+' Este handler se encarga de procesar las peticiones HTTP que esperan o envían datos en formato JSON.
+' Es ideal para clientes web (JavaScript, axios, etc.) o servicios que interactúan con el servidor
+' mediante un API RESTful. Soporta tanto GET con JSON en un parámetro 'j' como POST con JSON
+' en el cuerpo de la petición.
+
 Sub Class_Globals
 	' Declara una variable privada para mantener una instancia del conector RDC.
-	' Este objeto maneja la comunicación con la base de datos.
+	' Este objeto maneja la comunicación con la base de datos específica de la petición.
 	Private Connector As RDCConnector
 End Sub
 
 ' Subrutina de inicialización de la clase. Se llama cuando se crea un objeto de esta clase.
 Public Sub Initialize
+	' No se requiere inicialización específica para esta clase en este momento.
 End Sub
 
-' Este es el método principal que maneja las peticiones HTTP entrantes (req) y prepara la respuesta (resp).
 ' Este es el método principal que maneja las peticiones HTTP entrantes (req) y prepara la respuesta (resp).
 Sub Handle(req As ServletRequest, resp As ServletResponse)
 	' --- Headers CORS (Cross-Origin Resource Sharing) ---
-	resp.SetHeader("Access-Control-Allow-Origin", "*")
-	resp.SetHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
-	resp.SetHeader("Access-Control-Allow-Headers", "Content-Type")
+	' Estos encabezados son esenciales para permitir que aplicaciones web (clientes)
+	' alojadas en diferentes dominios puedan comunicarse con este servidor.
+	resp.SetHeader("Access-Control-Allow-Origin", "*") ' Permite peticiones desde cualquier origen.
+	resp.SetHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS") ' Métodos HTTP permitidos.
+	resp.SetHeader("Access-Control-Allow-Headers", "Content-Type") ' Encabezados permitidos.
 
+	' Las peticiones OPTIONS son pre-vuelos de CORS y no deben procesar lógica de negocio ni contadores.
 	If req.Method = "OPTIONS" Then
-		Return ' Las peticiones OPTIONS no incrementan contadores ni usan BD, así que salimos directamente.
+		Return ' Salimos directamente para estas peticiones.
 	End If
 
-	Dim start As Long = DateTime.Now
+	Dim start As Long = DateTime.Now ' Registra el tiempo de inicio de la petición para calcular la duración.
 
-	' Declaraciones de variables con alcance en toda la subrutina para la limpieza.
+	' Declaraciones de variables con alcance en toda la subrutina para asegurar la limpieza final.
 	Dim con As SQL ' La conexión a la BD, se inicializará más tarde.
 	Dim queryNameForLog As String = "unknown_json_command" ' Nombre del comando para el log, con valor por defecto.
-	Dim duration As Long ' La duración de la petición, calculada antes del log.
+	Dim duration As Long ' La duración total de la petición, calculada antes del log.
 	Dim poolBusyConnectionsForLog As Int = 0 ' Contiene el número de conexiones ocupadas del pool.
-    
-	Dim finalDbKey As String = "DB1"
-	Dim requestsBeforeDecrement As Int = 0 ' Se inicializa en 0.
+	Dim finalDbKey As String = "DB1" ' Identificador de la base de datos, con valor por defecto "DB1".
+	Dim requestsBeforeDecrement As Int = 0 ' Contador de peticiones activas antes de decrementar, inicializado en 0.
 
 	Try ' --- INICIO: Bloque Try que envuelve la lógica principal del Handler ---
 
 		Dim jsonString As String
+		' <<<< INICIO: Lógica para manejar peticiones POST con JSON en el cuerpo >>>>
 		If req.Method = "POST" And req.ContentType.Contains("application/json") Then
+			' Si es un POST con JSON en el cuerpo, leemos directamente del InputStream.
 			Dim Is0 As InputStream = req.InputStream
-			Dim bytes() As Byte = Bit.InputStreamToBytes(Is0)
-			jsonString = BytesToString(bytes, 0, bytes.Length, "UTF8")
-			Is0.Close
+			Dim bytes() As Byte = Bit.InputStreamToBytes(Is0) ' Lee el cuerpo completo de la petición.
+			jsonString = BytesToString(bytes, 0, bytes.Length, "UTF8") ' Convierte los bytes a una cadena JSON.
+			Is0.Close ' Cierra explícitamente el InputStream para liberar recursos.
 		Else
+			' De lo contrario, asumimos que el JSON viene en el parámetro 'j' de la URL (método legacy/GET).
 			jsonString = req.GetParameter("j")
 		End If
+		' <<<< FIN: Lógica para manejar peticiones POST con JSON en el cuerpo >>>>
 
+		' Validación inicial: Si no hay JSON, se envía un error 400.
 		If jsonString = Null Or jsonString = "" Then
-			SendErrorResponse(resp, 400, "Falta el parámetro 'j' en el URL o el cuerpo JSON en la petición.")
+			Dim ErrorMsg As String = "Falta el parámetro 'j' en el URL o el cuerpo JSON en la petición."
+			SendErrorResponse(resp, 400, ErrorMsg)
+			Main.LogServerError("ERROR", "DBHandlerJSON.Handle", ErrorMsg, finalDbKey, queryNameForLog, req.RemoteAddress) ' <-- Nuevo Log
 			duration = DateTime.Now - start
 			CleanupAndLog(finalDbKey, queryNameForLog, duration, req.RemoteAddress, requestsBeforeDecrement, poolBusyConnectionsForLog, con)
-			Return ' Salida temprana.
+			Return
 		End If
 
 		Dim parser As JSONParser
-		parser.Initialize(jsonString)
-		Dim RootMap As Map = parser.NextObject
-		Dim execType As String = RootMap.GetDefault("exec", "")
-        
-		queryNameForLog = RootMap.GetDefault("query", "") '[___new 3.txt, 203]
-		If queryNameForLog = "" Then queryNameForLog = RootMap.GetDefault("exec", "unknown_json_command") '[___new 3.txt, 203]
+		parser.Initialize(jsonString) ' Inicializa el parser JSON con la cadena recibida.
+		Dim RootMap As Map = parser.NextObject ' Parsea el JSON a un objeto Map.
 
-		Dim paramsList As List = RootMap.Get("params")
+		Dim execType As String = RootMap.GetDefault("exec", "") ' Obtiene el tipo de ejecución (ej. "ExecuteQuery").
+        
+		' Obtiene el nombre de la query. Si no está en "query", busca en "exec".
+		queryNameForLog = RootMap.GetDefault("query", "")
+		If queryNameForLog = "" Then queryNameForLog = RootMap.GetDefault("exec", "unknown_json_command")
+
+		Dim paramsList As List = RootMap.Get("params") ' Obtiene la lista de parámetros para la query.
 		If paramsList = Null Or paramsList.IsInitialized = False Then
-			paramsList.Initialize
+			paramsList.Initialize ' Si no hay parámetros, inicializa una lista vacía.
 		End If
 
-		' <<<< ¡CORRECCIÓN CLAVE AQUÍ: RESOLVEMOS finalDbKey del JSON ANTES! >>>>
-		If RootMap.Get("dbx") <> Null Then finalDbKey = RootMap.Get("dbx") '[___new 3.txt, 204]
+		' <<<< ¡CORRECCIÓN CLAVE: RESOLVEMOS finalDbKey del JSON ANTES de usarla para los contadores! >>>>
+		' Esto asegura que el contador y el conector usen la DB correcta.
+		If RootMap.Get("dbx") <> Null Then finalDbKey = RootMap.Get("dbx")
 		' <<<< ¡FIN DE CORRECCIÓN CLAVE! >>>>
 
 		' --- INICIO: Conteo de peticiones activas para esta finalDbKey (Incrementar) ---
-		' 1. Aseguramos que el valor inicial sea un Int y lo recuperamos como Int.
+		' Este bloque incrementa un contador global que rastrea cuántas peticiones están
+		' activas para una base de datos específica en un momento dado.
+		' 1. Aseguramos que el valor inicial sea un Int y lo recuperamos como Int (usando .As(Int)).
 		Dim currentCountFromMap As Int = GlobalParameters.ActiveRequestsCountByDB.GetDefault(finalDbKey, 0).As(Int)
 		GlobalParameters.ActiveRequestsCountByDB.Put(finalDbKey, currentCountFromMap + 1)
-		requestsBeforeDecrement = currentCountFromMap + 1 ' Este es el valor que se registra en query_logs
-'		Log($"[DEBUG] Handle Increment: dbKey=${finalDbKey}, currentCountFromMap=${currentCountFromMap}, requestsBeforeDecrement=${requestsBeforeDecrement}, Map state: ${GlobalParameters.ActiveRequestsCountByDB}"$)
+		' requestsBeforeDecrement es el valor del contador justo después de que esta petición lo incrementa.
+		' Este es el valor que se registrará en la tabla 'query_logs'.
+		requestsBeforeDecrement = currentCountFromMap + 1
+		' Los logs de depuración para el incremento del contador pueden ser descomentados para una depuración profunda.
+		' Log($"[DEBUG] Handle Increment (JSON): dbKey=${finalDbKey}, currentCountFromMap=${currentCountFromMap}, requestsBeforeDecrement=${requestsBeforeDecrement}, Map state: ${GlobalParameters.ActiveRequestsCountByDB}"$)
 		' --- FIN: Conteo de peticiones activas ---
-        
-		Connector = Main.Connectors.Get(finalDbKey) ' Inicializamos el Connector con la finalDbKey resuelta.
 
+		' Inicializa el Connector con la finalDbKey resuelta.
+		Connector = Main.Connectors.Get(finalDbKey)
 
+		' Validación: Si el dbKey no es válido o no está configurado en Main.listaDeCP.
 		If Main.listaDeCP.IndexOf(finalDbKey) = -1 Then
-			SendErrorResponse(resp, 400, "Parámetro 'DB' inválido. El nombre '" & finalDbKey & "' no es válido.")
+			Dim ErrorMsg As String = "Parámetro 'DB' inválido. El nombre '" & finalDbKey & "' no es válido."
+			SendErrorResponse(resp, 400, ErrorMsg)
+			Main.LogServerError("ERROR", "DBHandlerJSON.Handle", ErrorMsg, finalDbKey, queryNameForLog, req.RemoteAddress) ' <-- Nuevo Log
 			duration = DateTime.Now - start
 			CleanupAndLog(finalDbKey, queryNameForLog, duration, req.RemoteAddress, requestsBeforeDecrement, poolBusyConnectionsForLog, con)
-			Return ' Salida temprana.
+			Return
 		End If
 
-		con = Connector.GetConnection(finalDbKey) ' La conexión a la BD se obtiene aquí.
-		
-		' <<<< ¡AÑADIR ESTE RETRASO ARTIFICIAL PARA LA PRUEBA! >>>>
-		' Esto forzará a C3P0 a mantener las conexiones ocupadas por más tiempo.
-		' Si tienes 100 VUs, esto debería hacer que BusyConnections suba.
-'		Sleep(100) ' Retraso artificial de 100ms para pruebas.
-'		Log($"[DEBUG - ${finalDbKey}] Retraso artificial de 500ms aplicado. Pool Stats (antes de exec): Busy=${Connector.GetPoolStats.GetDefault("BusyConnections",0).As(Int)}, Total=${Connector.GetPoolStats.GetDefault("TotalConnections",0).As(Int)}"$ )
-		' <<<< ¡FIN DEL RETRASO ARTIFICIAL! >>>>
-        
-		' <<<< BUSY_CONNECTIONS YA SE CAPTURABA BIEN. LO MANTENEMOS. >>>>
+		con = Connector.GetConnection(finalDbKey) ' ¡La conexión a la BD se obtiene aquí del pool de conexiones!
+
+		' <<<< ¡CAPTURAMOS BUSY_CONNECTIONS INMEDIATAMENTE DESPUÉS DE OBTENER LA CONEXIÓN! >>>>
+		' Este bloque captura el número de conexiones actualmente ocupadas en el pool
+		' *después* de que esta petición ha obtenido la suya.
 		If Connector.IsInitialized Then
-			Dim poolStats As Map = Connector.GetPoolStats '[___new 3.txt, 204]
+			Dim poolStats As Map = Connector.GetPoolStats
 			If poolStats.ContainsKey("BusyConnections") Then
-				poolBusyConnectionsForLog = poolStats.Get("BusyConnections").As(Int) ' Aseguramos que sea Int.
+				' <<<< ¡CORRECCIÓN CLAVE: Aseguramos que el valor sea Int! >>>>
+				poolBusyConnectionsForLog = poolStats.Get("BusyConnections").As(Int) ' Capturamos el valor.
 			End If
 		End If
-		' <<<< FIN DE CAPTURA! >>>>
+		' <<<< ¡FIN DE CAPTURA! >>>>
 
+		' Obtiene la sentencia SQL correspondiente al nombre del comando desde config.properties.
 		Dim sqlCommand As String = Connector.GetCommand(finalDbKey, queryNameForLog)
 
+		' Validación: Si el comando SQL no fue encontrado en la configuración.
 		If sqlCommand = Null Or sqlCommand = "null" Or sqlCommand.Trim = "" Then
 			Dim errorMessage As String = $"El comando '${queryNameForLog}' no fue encontrado en el config.properties de '${finalDbKey}'."$
 			Log(errorMessage)
+			Main.LogServerError("ERROR", "DBHandlerJSON.Handle", errorMessage, finalDbKey, queryNameForLog, req.RemoteAddress) ' <-- Nuevo Log
 			SendErrorResponse(resp, 400, errorMessage)
 			duration = DateTime.Now - start
 			CleanupAndLog(finalDbKey, queryNameForLog, duration, req.RemoteAddress, requestsBeforeDecrement, poolBusyConnectionsForLog, con)
-			Return ' Salida temprana.
+			Return
 		End If
 
+		' --- Lógica para ejecutar diferentes tipos de comandos basados en el parámetro 'execType' ---
 		If execType.ToLowerCase = "executequery" Then
-			Dim rs As ResultSet
-			If sqlCommand.Contains("?") Or paramsList.Size > 0 Then
-				Dim expectedParams As Int = sqlCommand.Length - sqlCommand.Replace("?", "").Length
-				Dim receivedParams As Int = paramsList.Size
-				Log($"expectedParams: ${expectedParams}, receivedParams: ${receivedParams}"$)
-				If expectedParams <> receivedParams Then
-					SendErrorResponse(resp, 400, $"Número de parámetros equivocado para '${queryNameForLog}'. Se esperaban ${expectedParams} y se recibieron ${receivedParams}."$)
-					duration = DateTime.Now - start
-					CleanupAndLog(finalDbKey, queryNameForLog, duration, req.RemoteAddress, requestsBeforeDecrement, poolBusyConnectionsForLog, con)
-					Return ' Salida temprana.
-				End If
-				rs = con.ExecQuery2(sqlCommand, paramsList)
-			Else
-				rs = con.ExecQuery(sqlCommand)
+			' --- INICIO VALIDACIÓN DE PARÁMETROS CENTRALIZADA ---
+			Dim validationResult As ParameterValidationResult = ParameterValidationUtils.ValidateAndAdjustParameters(queryNameForLog, finalDbKey, sqlCommand, paramsList, Connector.IsParameterToleranceEnabled)
+
+			If validationResult.Success = False Then
+				SendErrorResponse(resp, 400, validationResult.ErrorMessage)
+				duration = DateTime.Now - start
+				CleanupAndLog(finalDbKey, queryNameForLog, duration, req.RemoteAddress, requestsBeforeDecrement, poolBusyConnectionsForLog, con)
+				Return ' Salida temprana.
 			End If
 
+			Dim rs As ResultSet
+			' Ejecuta la consulta SQL con la lista de parámetros validada.
+			rs = con.ExecQuery2(sqlCommand, validationResult.ParamsToExecute)
+			' --- FIN VALIDACIÓN DE PARÁMETROS CENTRALIZADA ---
+
 			Dim ResultList As List
-			ResultList.Initialize
-			Dim jrs As JavaObject = rs
-			Dim rsmd As JavaObject = jrs.RunMethod("getMetaData", Null)
-			Dim cols As Int = rsmd.RunMethod("getColumnCount", Null)
+			ResultList.Initialize ' Lista para almacenar los resultados de la consulta.
+			Dim jrs As JavaObject = rs ' Objeto Java subyacente del ResultSet para metadatos.
+			Dim rsmd As JavaObject = jrs.RunMethod("getMetaData", Null) ' Metadatos del ResultSet.
+			Dim cols As Int = rsmd.RunMethod("getColumnCount", Null) ' Número de columnas.
 
-			Do While rs.NextRow
+			Do While rs.NextRow ' Itera sobre cada fila del resultado.
 				Dim RowMap As Map
-				RowMap.Initialize
-				For i = 1 To cols
-					Dim ColumnName As String = rsmd.RunMethod("getColumnName", Array(i))
-					Dim value As Object = jrs.RunMethod("getObject", Array(i))
-					RowMap.Put(ColumnName, value)
+				RowMap.Initialize ' Mapa para almacenar los datos de la fila actual.
+				For i = 1 To cols ' Itera sobre cada columna.
+					Dim ColumnName As String = rsmd.RunMethod("getColumnName", Array(i)) ' Nombre de la columna.
+					Dim value As Object = jrs.RunMethod("getObject", Array(i)) ' Valor de la columna.
+					RowMap.Put(ColumnName, value) ' Añade la columna y su valor al mapa de la fila.
 				Next
-				ResultList.Add(RowMap)
+				ResultList.Add(RowMap) ' Añade el mapa de la fila a la lista de resultados.
 			Loop
-			rs.Close
-			SendSuccessResponse(resp, CreateMap("result": ResultList))
+			rs.Close ' Cierra el ResultSet.
+			SendSuccessResponse(resp, CreateMap("result": ResultList)) ' Envía la respuesta JSON de éxito.
 
 		Else If execType.ToLowerCase = "executecommand" Then
-			If sqlCommand.Contains("?") Then
-				Dim expectedParams As Int = sqlCommand.Length - sqlCommand.Replace("?", "").Length
-				Dim receivedParams As Int = paramsList.Size
-				If expectedParams <> receivedParams Then
-					SendErrorResponse(resp, 400, $"Número de parámetros equivocado para '${queryNameForLog}'. Se esperaban ${expectedParams} y se recibieron ${receivedParams}."$)
-					duration = DateTime.Now - start
-					CleanupAndLog(finalDbKey, queryNameForLog, duration, req.RemoteAddress, requestsBeforeDecrement, poolBusyConnectionsForLog, con)
-					Return ' Salida temprana.
-				End If
-			End If
-			con.ExecNonQuery2(sqlCommand, paramsList)
-			SendSuccessResponse(resp, CreateMap("message": "Command executed successfully"))
+			' --- INICIO VALIDACIÓN DE PARÁMETROS CENTRALIZADA ---
+			Dim validationResult As ParameterValidationResult = ParameterValidationUtils.ValidateAndAdjustParameters(queryNameForLog, finalDbKey, sqlCommand, paramsList, Connector.IsParameterToleranceEnabled)
 
+			If validationResult.Success = False Then
+				SendErrorResponse(resp, 400, validationResult.ErrorMessage)
+				duration = DateTime.Now - start
+				CleanupAndLog(finalDbKey, queryNameForLog, duration, req.RemoteAddress, requestsBeforeDecrement, poolBusyConnectionsForLog, con)
+				Return ' Salida temprana.
+			End If
+
+			con.ExecNonQuery2(sqlCommand, validationResult.ParamsToExecute) ' Ejecuta un comando con la lista de parámetros validada.
+			SendSuccessResponse(resp, CreateMap("message": "Command executed successfully")) ' Envía confirmación de éxito.
+			' --- FIN VALIDACIÓN DE PARÁMETROS CENTRALIZADA ---
 		Else
-			SendErrorResponse(resp, 400, "Parámetro 'exec' inválido. '" & execType & "' no es un valor permitido.")
+			Dim ErrorMsg As String = "Parámetro 'exec' inválido. '" & execType & "' no es un valor permitido."
+			SendErrorResponse(resp, 400, ErrorMsg)
+			Main.LogServerError("ERROR", "DBHandlerJSON.Handle", ErrorMsg, finalDbKey, queryNameForLog, req.RemoteAddress) ' <-- Nuevo Log
 			' El flujo continúa hasta la limpieza final si no hay un Return explícito.
 		End If
 
 	Catch ' --- CATCH: Maneja errores generales de ejecución o de SQL/JSON ---
-		Log(LastException)
-		SendErrorResponse(resp, 500, LastException.Message)
+		Log(LastException) ' Registra la excepción completa en el log.
+		Main.LogServerError("ERROR", "DBHandlerJSON.Handle", LastException.Message, finalDbKey, queryNameForLog, req.RemoteAddress) ' <-- Nuevo Log
+		SendErrorResponse(resp, 500, LastException.Message) ' Envía un error 500 al cliente.
 		queryNameForLog = "error_processing_json" ' Para registrar que hubo un error en el log.
 	End Try ' --- FIN: Bloque Try principal ---
 
 	' --- Lógica de logging y limpieza final (para rutas de ejecución normal o después de Catch) ---
-	duration = DateTime.Now - start
+	' Este bloque se asegura de que, independientemente de cómo termine la petición (éxito o error),
+	' la duración se calcule y se llamen las subrutinas de limpieza y logging.
+	duration = DateTime.Now - start ' Calcula la duración total de la petición.
+	' Llama a la subrutina centralizada para registrar el rendimiento y limpiar recursos.
 	CleanupAndLog(finalDbKey, queryNameForLog, duration, req.RemoteAddress, requestsBeforeDecrement, poolBusyConnectionsForLog, con)
 
 End Sub
 
-' --- NUEVA SUBRUTINA: Centraliza el logging y la limpieza ---
+' --- NUEVA SUBRUTINA: Centraliza el logging de rendimiento y la limpieza de recursos ---
+' Esta subrutina es llamada por Handle en todos los puntos de salida, asegurando
+' que los contadores se decrementen y las conexiones se cierren de forma consistente.
 Private Sub CleanupAndLog(dbKey As String, qName As String, durMs As Long, clientIp As String, handlerReqs As Int, poolBusyConns As Int, conn As SQL)
-'	Log($"[DEBUG] CleanupAndLog Entry: dbKey=${dbKey}, handlerReqs=${handlerReqs}, Map state: ${GlobalParameters.ActiveRequestsCountByDB}"$)
-	' 1. Llama a la subrutina centralizada para registrar el rendimiento.
-	Main.LogQueryPerformance(qName, durMs, dbKey, clientIp, handlerReqs, poolBusyConns) '[___new 3.txt, 207]
+	' Los logs de depuración para CleanupAndLog pueden ser descomentados para una depuración profunda.
+	' Log($"[DEBUG] CleanupAndLog Entry (JSON): dbKey=${dbKey}, handlerReqs=${handlerReqs}, Map state: ${GlobalParameters.ActiveRequestsCountByDB}"$)
+	' 1. Llama a la subrutina centralizada en Main para registrar el rendimiento en SQLite.
+	Main.LogQueryPerformance(qName, durMs, dbKey, clientIp, handlerReqs, poolBusyConns)
 
-	' <<<< ¡CORRECCIÓN CLAVE AQUÍ: Aseguramos que currentCount sea Int! >>>>
+	' <<<< ¡CORRECCIÓN CLAVE: Aseguramos que currentCount sea Int al obtenerlo del mapa! >>>>
+	' 2. Decrementa el contador de peticiones activas para esta dbKey de forma robusta.
 	Dim currentCount As Int = GlobalParameters.ActiveRequestsCountByDB.GetDefault(dbKey, 0).As(Int)
-'	Log($"[DEBUG] CleanupAndLog Before Decrement: dbKey=${dbKey}, currentCount (as Int)=${currentCount}, Map state: ${GlobalParameters.ActiveRequestsCountByDB}"$)
+	' Log($"[DEBUG] CleanupAndLog Before Decrement (JSON): dbKey=${dbKey}, currentCount (as Int)=${currentCount}, Map state: ${GlobalParameters.ActiveRequestsCountByDB}"$)
 
 	If currentCount > 0 Then
+		' Si el contador es positivo, lo decrementamos.
 		GlobalParameters.ActiveRequestsCountByDB.Put(dbKey, currentCount - 1)
 	Else
-		Log($"ADVERTENCIA: Intento de decrementar ActiveRequestsCountByDB para ${dbKey} que ya estaba en ${currentCount}. Asegurando a 0."$)
+		' Si el contador ya está en 0 o negativo (lo cual no debería ocurrir con la lógica actual,
+		' pero se maneja para robustez), registramos una advertencia y lo aseguramos en 0.
+'		Log($"ADVERTENCIA: Intento de decrementar ActiveRequestsCountByDB para ${dbKey} que ya estaba en ${currentCount}. Asegurando a 0."$)
 		GlobalParameters.ActiveRequestsCountByDB.Put(dbKey, 0)
 	End If
-'	Log($"[DEBUG] CleanupAndLog After Decrement: dbKey=${dbKey}, New count (as Int)=${GlobalParameters.ActiveRequestsCountByDB.GetDefault(dbKey,0).As(Int)}, Map state: ${GlobalParameters.ActiveRequestsCountByDB}"$)
+	' Log($"[DEBUG] CleanupAndLog After Decrement (JSON): dbKey=${dbKey}, New count (as Int)=${GlobalParameters.ActiveRequestsCountByDB.GetDefault(dbKey,0).As(Int)}, Map state: ${GlobalParameters.ActiveRequestsCountByDB}"$)
 	' <<<< ¡FIN DE CORRECCIÓN CLAVE! >>>>
 
-	' 3. Asegura que la conexión a la BD siempre se cierre y se devuelva al pool.
+	' 3. Asegura que la conexión a la BD siempre se cierre y se devuelva al pool de conexiones.
 	If conn <> Null And conn.IsInitialized Then conn.Close
 End Sub
 
 ' --- Subrutinas de ayuda para respuestas JSON ---
 
 ' Construye y envía una respuesta JSON de éxito.
+' resp: El objeto ServletResponse para enviar la respuesta.
+' dataMap: Un mapa que contiene los datos a incluir en la respuesta JSON.
 Private Sub SendSuccessResponse(resp As ServletResponse, dataMap As Map)
 	' Añade el campo "success": true al mapa de datos para indicar que todo salió bien.
 	dataMap.Put("success", True)
+
 	' Crea un generador de JSON.
 	Dim jsonGenerator As JSONGenerator
 	jsonGenerator.Initialize(dataMap)
+
 	' Establece el tipo de contenido de la respuesta a "application/json".
 	resp.ContentType = "application/json"
 	' Escribe la cadena JSON generada en el cuerpo de la respuesta HTTP.
@@ -227,17 +268,25 @@ Private Sub SendSuccessResponse(resp As ServletResponse, dataMap As Map)
 End Sub
 
 ' Construye y envía una respuesta JSON de error.
+' resp: El objeto ServletResponse para enviar la respuesta.
+' statusCode: El código de estado HTTP (ej. 400 para error del cliente, 500 para error del servidor).
+' errorMessage: El mensaje de error que se enviará al cliente.
 Private Sub SendErrorResponse(resp As ServletResponse, statusCode As Int, errorMessage As String)
 	' Personaliza el mensaje de error si es un error común de parámetros de Oracle o JDBC.
-	If errorMessage.Contains("Índice de columnas no válido") Or errorMessage.Contains("ORA-17003") Then errorMessage = "NUMERO DE PARAMETROS EQUIVOCADO: " & errorMessage
+	If errorMessage.Contains("Índice de columnas no válido") Or errorMessage.Contains("ORA-17003") Then
+		errorMessage = "NUMERO DE PARAMETROS EQUIVOCADO: " & errorMessage
+	End If
+
 	' Crea un mapa con el estado de error y el mensaje.
 	Dim resMap As Map = CreateMap("success": False, "error": errorMessage)
+
 	' Genera la cadena JSON a partir del mapa.
 	Dim jsonGenerator As JSONGenerator
 	jsonGenerator.Initialize(resMap)
+
 	' Establece el código de estado HTTP (ej. 400 para error del cliente, 500 para error del servidor).
 	resp.Status = statusCode
 	' Establece el tipo de contenido y escribe la respuesta de error.
 	resp.ContentType = "application/json"
 	resp.Write(jsonGenerator.ToString)
-End Sub
+End Sub

Files/config.DB2.properties

@@ -11,13 +11,19 @@ DriverClass=oracle.jdbc.driver.OracleDriver
 #GOHAN ---> server
 #JdbcUrl=jdbc:oracle:thin:@//10.0.0.205:1521/DBKMT
 #JdbcUrl=jdbc:oracle:thin:@//10.0.0.236:1521/DBKMT
-JdbcUrl=jdbc:oracle:thin:@//192.168.101.13:1521/DBKMT?v$session.program=jRDC_Multi
+JdbcUrl=jdbc:oracle:thin:@//192.168.101.13:1521/DBKMT?v$session.program=jRDC_MultiSALMA
 
-# Configuración del pool de conexiones para DB2
+# Configuración del pool de conexiones
 InitialPoolSize=3
 MinPoolSize=2
-MaxPoolSize=10
-AcquireIncrement=5
+MaxPoolSize=15
+AcquireIncrement=2
+
+# Configuración de tolerancia de parámetros:
+#   1 = Habilita la tolerancia a parámetros de más (se recortarán los excesivos).
+#   0 = Deshabilita la tolerancia (el servidor será estricto y lanzará un error si hay parámetros de más).
+# Por defecto, si no se especifica o el valor es diferente de 1, la tolerancia estará DESHABILITADA (modo estricto).
+parameterTolerance=1
 
 # SVR-KEYMON-PRODUCCION--> Usuario
 User=SALMA
@@ -50,7 +56,7 @@ Debug=true
 sql.traeConexion=select 'DB2' as conexion from dual
 sql.select_soporte=select * from GUNA.soporte
 sql.select_conexion=SELECT 'OK' AS VALOR FROM DUAL
-sql.traeConexion4=SELECT (?) AS p1, (?) AS p2, (?) AS p3 FROM DUAL
+sql.traeConexion4=SELECT 'DB2' as db, (?) AS p1, (?) AS p2, (?) AS p3 FROM DUAL
 sql.select_version=select cat_ve_version from cat_version
 sql.select_version_GV2=select cat_ve_version from GUNA.cat_version
 sql.selectAlmacen=select * from cat_almacen where cat_al_id = ?

Files/config.DB3.properties

@@ -11,20 +11,21 @@ DriverClass=oracle.jdbc.driver.OracleDriver
 #GOHAN ---> server
 #JdbcUrl=jdbc:oracle:thin:@//10.0.0.205:1521/DBKMT
 #JdbcUrl=jdbc:oracle:thin:@//10.0.0.236:1521/DBKMT
-JdbcUrl=jdbc:oracle:thin:@//192.168.101.12:1521/DBKMT?v$session.program=jRDC_Multi
+JdbcUrl=jdbc:oracle:thin:@//192.168.101.13:1521/DBKMT?v$session.program=jRDC_MultiSALMA
 
-# Configuración del pool de conexiones para DB2
+# Configuración del pool de conexiones
 InitialPoolSize=3
 MinPoolSize=2
-MaxPoolSize=10
-AcquireIncrement=5
+MaxPoolSize=15
+AcquireIncrement=2
 
 # SVR-KEYMON-PRODUCCION--> Usuario
-#User=GUNA
-#Password=GUNAD2015M
+User=SALMA
+Password=SALMAD2016M
+
+#User=TORRADOCONAUTO
+#Password=TORRADOCONAUTOD2016M
 
-User=TORRADOCONAUTO
-Password=TORRADOCONAUTOD2016M
 
 #--> Puertos
 #SAC - DFR - MDA / GOHAN -->COBRANZA
@@ -46,8 +47,19 @@ Debug=true
 #################
 ##################
 
-sql.traeConexion=select 'DB3' as conexion from dual
+sql.traeConexion=select 'DB2' as conexion from dual
 sql.select_soporte=select * from GUNA.soporte
+sql.select_conexion=SELECT 'OK' AS VALOR FROM DUAL
+sql.traeConexion4=SELECT 'DB2' as db, (?) AS p1, (?) AS p2, (?) AS p3 FROM DUAL
+sql.select_version=select cat_ve_version from cat_version
+sql.select_version_GV2=select cat_ve_version from GUNA.cat_version
+sql.selectAlmacen=select * from cat_almacen where cat_al_id = ?
+sql.sv=select * from cat_rutas where CAT_RU_RUTA = ?
+sql.verify_device=select * from kelloggs.GUIDs where almacen = ? and ruta = ?
+sql.registarMovil=insert into kelloggs.GUIDs (almacen, ruta, guid, estatus) values (?, ?, ?, 'ok')
+sql.update_usuario_guna_nobajas=UPDATE GUNA.CAT_LOGINS SET CAT_LO_ESTATUS = 'Activo',CAT_LO_CONECTADO ='0' WHERE CAT_LO_ESTATUS != 'Baja' and CAT_LO_USUARIO = (?)
+
+sql.proc_usuario=BEGIN EXECUTE IMMEDIATE ('DECLARE Cursor_SYS Sys_Refcursor; BEGIN SP_ACTIVAR_USUARIO( '''||(?)||''',Cursor_SYS); end;'); END;
 
 sql.select_almacenes_KELL=select CAT_AG_ID, CAT_AG_NOMBRE from KELLOGGS.cat_agencias order by CAT_AG_NOMBRE
 sql.select_almacenes_GUNA=select CAT_AG_ID, CAT_AG_NOMBRE from GUNA.cat_agencias order by CAT_AG_NOMBRE

Files/config.DB4.properties

@@ -11,13 +11,13 @@ DriverClass=oracle.jdbc.driver.OracleDriver
 #GOHAN ---> server
 #JdbcUrl=jdbc:oracle:thin:@//10.0.0.205:1521/DBKMT
 #JdbcUrl=jdbc:oracle:thin:@//10.0.0.236:1521/DBKMT
-JdbcUrl=jdbc:oracle:thin:@//192.168.101.13:1521/DBKMT?v$session.program=jRDC_Multi
+JdbcUrl=jdbc:oracle:thin:@//192.168.101.13:1521/DBKMT?v$session.program=jRDC_MultiSALMA
 
-# Configuración del pool de conexiones para DB2
+# Configuración del pool de conexiones
 InitialPoolSize=3
 MinPoolSize=2
-MaxPoolSize=10
-AcquireIncrement=5
+MaxPoolSize=15
+AcquireIncrement=2
 
 # SVR-KEYMON-PRODUCCION--> Usuario
 User=SALMA
@@ -31,7 +31,7 @@ Password=SALMAD2016M
 #SAC - DFR - MDA / GOHAN -->COBRANZA
 #ServerPort=1783
 #GUNA - SALMA - DURAKELO - DBC / SVR-KEYMON-PRODUCCION --> DISTRIBUIDORAS
-ServerPort=9000
+ServerPort=9010
 #CMG - TORRADO / TRUNKS -->COBRANZA/ GM
 #ServerPort=1781
 
@@ -47,9 +47,19 @@ Debug=true
 #################
 ##################
 
-sql.traeConexion=select 'DB4' as conexion from dual
+sql.traeConexion=select 'DB2' as conexion from dual
 sql.select_soporte=select * from GUNA.soporte
 sql.select_conexion=SELECT 'OK' AS VALOR FROM DUAL
+sql.traeConexion4=SELECT 'DB2' as db, (?) AS p1, (?) AS p2, (?) AS p3 FROM DUAL
+sql.select_version=select cat_ve_version from cat_version
+sql.select_version_GV2=select cat_ve_version from GUNA.cat_version
+sql.selectAlmacen=select * from cat_almacen where cat_al_id = ?
+sql.sv=select * from cat_rutas where CAT_RU_RUTA = ?
+sql.verify_device=select * from kelloggs.GUIDs where almacen = ? and ruta = ?
+sql.registarMovil=insert into kelloggs.GUIDs (almacen, ruta, guid, estatus) values (?, ?, ?, 'ok')
+sql.update_usuario_guna_nobajas=UPDATE GUNA.CAT_LOGINS SET CAT_LO_ESTATUS = 'Activo',CAT_LO_CONECTADO ='0' WHERE CAT_LO_ESTATUS != 'Baja' and CAT_LO_USUARIO = (?)
+
+sql.proc_usuario=BEGIN EXECUTE IMMEDIATE ('DECLARE Cursor_SYS Sys_Refcursor; BEGIN SP_ACTIVAR_USUARIO( '''||(?)||''',Cursor_SYS); end;'); END;
 
 sql.select_almacenes_KELL=select CAT_AG_ID, CAT_AG_NOMBRE from KELLOGGS.cat_agencias order by CAT_AG_NOMBRE
 sql.select_almacenes_GUNA=select CAT_AG_ID, CAT_AG_NOMBRE from GUNA.cat_agencias order by CAT_AG_NOMBRE

Files/config.properties

@@ -13,11 +13,17 @@ DriverClass=oracle.jdbc.driver.OracleDriver
 #JdbcUrl=jdbc:oracle:thin:@//10.0.0.236:1521/DBKMT
 JdbcUrl=jdbc:oracle:thin:@//192.168.101.10:1521/DBKMT?v$session.program=jRDC_Multi
 
-# Configuración del pool de conexiones para DB1
+# Configuración del pool de conexiones
 InitialPoolSize=3
 MinPoolSize=2
-MaxPoolSize=10
-AcquireIncrement=5
+MaxPoolSize=15
+AcquireIncrement=2
+
+# Configuración de tolerancia de parámetros:
+#   1 = Habilita la tolerancia a parámetros de más (se recortarán los excesivos).
+#   0 = Deshabilita la tolerancia (el servidor será estricto y lanzará un error si hay parámetros de más).
+# Por defecto, si no se especifica o el valor es diferente de 1, la tolerancia estará DESHABILITADA (modo estricto).
+parameterTolerance=1
 
 # SVR-KEYMON-PRODUCCION--> Usuario
 User=GUNA
@@ -52,7 +58,7 @@ sql.select_revisaClienteCredito_GUNA2=select (select count(CAT_CL_CODIGO) from G
 sql.traeConexion=select 'DB1' as conexion from dual
 sql.traeConexion2=select 'DB1' as conexion from dual
 sql.traeConexion3=select '1' as par1, 2 as par2 from dual
-sql.traeConexion4=SELECT (?) AS p1, (?) AS p2, (?) AS p3 FROM DUAL
+sql.traeConexion4=SELECT 'DB1' as db, (?) AS p1, (?) AS p2, (?) AS p3 FROM DUAL
 sql.select_soporte=select * from GUNA.soporte
 sql.select_conexion=SELECT 'OK' AS VALOR FROM DUAL
 sql.selectAlmacen=select cat_al_id, cat_al_desc, cat_al_archftp from cat_almacen where cat_al_id = ?

Manager.bas

@@ -4,25 +4,39 @@ ModulesStructureVersion=1
 Type=Class
 Version=8.8
 @EndOfDesignText@
-'Handler class
+' Módulo de clase: Manager
+' Este handler proporciona un panel de administración web para el servidor jRDC2-Multi.
+' Permite monitorear el estado del servidor, recargar configuraciones de bases de datos,
+' ver estadísticas de rendimiento, reiniciar servicios externos, y gestionar la autenticación de usuarios.
+
 Sub Class_Globals
+	' Objeto para generar respuestas JSON. Se utiliza para mostrar mapas de datos de forma legible.
 	Dim j As JSONGenerator
-'	Dim rdcc As RDCConnector
+	' La clase BCrypt no se usa directamente en este módulo, pero se mantiene si hubiera planes futuros.
+	' Private bc As BCrypt
 End Sub
 
+' Subrutina de inicialización de la clase. Se llama cuando se crea un objeto de esta clase.
 Public Sub Initialize
-	
+	' No se requiere inicialización específica para esta clase en este momento.
 End Sub
 
+' Método principal que maneja las peticiones HTTP para el panel de administración.
+' req: El objeto ServletRequest que contiene la información de la petición entrante.
+' resp: El objeto ServletResponse para construir y enviar la respuesta al cliente.
 Sub Handle(req As ServletRequest, resp As ServletResponse)
-	' 1. --- Bloque de Seguridad ---
+	' --- 1. Bloque de Seguridad: Autenticación de Usuario ---
+	' Verifica si el usuario actual ha iniciado sesión y está autorizado.
+	' Si no está autorizado, se le redirige a la página de login.
 	If req.GetSession.GetAttribute2("user_is_authorized", False) = False Then
 		resp.SendRedirect("/login")
-		Return
+		Return ' Termina la ejecución si no está autorizado.
 	End If
 
+	' Obtiene el comando solicitado de los parámetros de la URL (ej. "?command=reload").
 	Dim Command As String = req.GetParameter("command")
-	If Command = "" Then Command = "ping"
+	If Command = "" Then Command = "ping" ' Si no se especifica un comando, por defecto es "ping".
+
 	Log($"Command: ${Command}"$)
 
 	' --- MANEJO ESPECIAL PARA SNAPSHOT ---
@@ -35,7 +49,7 @@ Sub Handle(req As ServletRequest, resp As ServletResponse)
 '			toolkit.InitializeStatic("java.awt.Toolkit")
 '			Dim screenRect As JavaObject
 '			screenRect.InitializeNewInstance("java.awt.Rectangle", Array As Object( _
-'                toolkit.RunMethodJO("getDefaultToolkit", Null).RunMethod("getScreenSize", Null)))
+		'                toolkit.RunMethodJO("getDefaultToolkit", Null).RunMethod("getScreenSize", Null)))
 '			Dim image As JavaObject = robot.RunMethod("createScreenCapture", Array As Object(screenRect))
 '			Dim ImageIO As JavaObject
 '			ImageIO.InitializeStatic("javax.imageio.ImageIO").RunMethod("write", Array As Object(image, "png", resp.OutputStream))
@@ -46,9 +60,9 @@ Sub Handle(req As ServletRequest, resp As ServletResponse)
 	End If
 	' --- FIN DE MANEJO ESPECIAL ---
 
-	' Para todos los demás comandos, construimos la página HTML
-	resp.ContentType = "text/html"
-	Dim sb As StringBuilder
+	' Para todos los demás comandos, construimos la página HTML de respuesta.
+	resp.ContentType = "text/html" ' Establece el tipo de contenido como HTML.
+	Dim sb As StringBuilder ' Usamos StringBuilder para construir eficientemente el HTML.
 	sb.Initialize
 
 	' --- Estilos y JavaScript (igual que antes) ---
@@ -64,12 +78,23 @@ Sub Handle(req As ServletRequest, resp As ServletResponse)
 	sb.Append("<script>function toggleForm() {var form = document.getElementById('changePassForm'); if (form.style.display === 'none') {form.style.display = 'block';} else {form.style.display = 'none';}}</script>")
 	sb.Append("</head><body>")
 
-	' --- Cabecera, Botón y Formulario Oculto (igual que antes) ---
+	' --- Cabecera de la Página y Mensaje de Bienvenida ---
 	sb.Append("<h1>Panel de Administración jRDC</h1>")
-	sb.Append($"Bienvenido, <b>${req.GetSession.GetAttribute("username")}</b><br>"$)
-'	sb.Append("<p class='nav'><a href='/manager?command=test'>Test</a> | <a href='/manager?command=ping'>Ping</a> | <a href='/manager?command=reload'>Reload</a> | <a href='/manager?command=rpm2'>Reiniciar (pm2)</a> | <a href='/manager?command=reviveBow'>Revive Bow</a></p><hr>")
-	sb.Append("<p class='nav'><a href='/manager?command=test'>Test</a> | <a href='/manager?command=ping'>Ping</a> | <a href='/manager?command=reload'>Reload</a> | <a href='/manager?command=slowqueries'>Queries Lentos</a> | <a href='/manager?command=totalcon'>Estadísticas Pool</a> | <a href='/manager?command=rpm2'>Reiniciar (pm2)</a> | <a href='/manager?command=reviveBow'>Revive Bow</a></p><hr>")
-'	sb.Append("<button onclick='toggleForm()'>Cambiar Contraseña</button>")
+	sb.Append($"<p>Bienvenido, <strong>${req.GetSession.GetAttribute("username")}</strong></p>"$)
+	
+	' --- Menú de Navegación del Manager ---
+	' Este menú incluye las opciones para interactuar con el servidor.
+	sb.Append("<div class='menu'>")
+	sb.Append("<a href='/manager?command=test'>Test</a> | ")
+	sb.Append("<a href='/manager?command=ping'>Ping</a> | ")
+	sb.Append("<a href='/manager?command=reload'>Reload</a> | ")
+	sb.Append("<a href='/manager?command=slowqueries'>Queries Lentas</a> | ") ' Nuevo enlace para queries lentas.
+	sb.Append("<a href='/manager?command=totalcon'>Estadísticas Pool</a> | ") ' Nuevo enlace para estadísticas del pool.
+	sb.Append("<a href='/manager?command=rpm2'>Reiniciar (pm2)</a> | ")
+	sb.Append("<a href='/manager?command=reviveBow'>Revive Bow</a>")
+	sb.Append("</div>")
+	sb.Append("<hr>")
+
 	sb.Append("<div id='changePassForm' style='display:none;'>")
 	sb.Append("<h2>Cambiar Contraseña</h2><form action='/changepass' method='post'>")
 	sb.Append("Contraseña Actual: <input type='password' name='current_password' required><br>")
@@ -85,119 +110,158 @@ Sub Handle(req As ServletRequest, resp As ServletResponse)
 	' ### INICIO DE TU LÓGICA DE COMANDOS INTEGRADA ###
 	' =========================================================================
 	If Command = "reload" Then
-		' Usamos un StringBuilder temporal para acumular los logs de la recarga antes de añadirlos al StringBuilder principal.
+
 		Dim sbTemp As StringBuilder
 		sbTemp.Initialize
-		sbTemp.Append($"Iniciando recarga de configuración (Hot-Swap) ($DateTime{DateTime.Now})"$).Append("<br>" & CRLF)
-
+		sbTemp.Append($"Iniciando recarga de configuración (Hot-Swap) ($DateTime{DateTime.Now})"$).Append(" " & CRLF)
+    
+		' <<< PASO CLAVE 1: DETENER TIMER DE LOGS (ZONA SEGURA DE SQLite) >>>
+		' Detenemos el timer incondicionalmente al inicio para evitar conflictos de bloqueo con SQLite
+		' durante la inicialización de conectores.
+		Dim oldTimerState As Boolean = Main.timerLogs.Enabled
+		If oldTimerState Then
+			Main.timerLogs.Enabled = False
+			sbTemp.Append(" -> Timer de limpieza de logs (SQLite) detenido temporalmente.").Append(" " & CRLF)
+		End If
+    
 		' 1. Crear un nuevo mapa temporal para almacenar los conectores recién inicializados.
 		Dim newConnectors As Map
 		newConnectors.Initialize
     
-		' Guardamos una referencia al mapa de conectores actualmente activos.
 		Dim oldConnectors As Map
-    
 		Dim reloadSuccessful As Boolean = True
     
 		' *** INICIO DEL BLOQUE CRÍTICO 1: Obtener oldConnectors con ReentrantLock ***
-		Dim lock1Acquired As Boolean = False ' Bandera para saber si el bloqueo fue adquirido.
+		Dim lock1Acquired As Boolean = False
 		Try
-			Main.MainConnectorsLock.RunMethod("lock", Null) ' Adquirimos el bloqueo.
-			lock1Acquired = True ' Marcamos que el bloqueo fue adquirido.
-			oldConnectors = Main.Connectors ' Obtenemos la referencia al mapa actual de conectores.
+			Main.MainConnectorsLock.RunMethod("lock", Null)
+			lock1Acquired = True
+			oldConnectors = Main.Connectors
 		Catch
-			sbTemp.Append($"  -> ERROR CRÍTICO: No se pudo adquirir el bloqueo para leer conectores antiguos: ${LastException.Message}"$).Append("<br>" & CRLF)
-			reloadSuccessful = False ' Si falla aquí, la recarga no puede continuar.
+			sbTemp.Append($" -> ERROR CRÍTICO: No se pudo adquirir el bloqueo para leer conectores antiguos: ${LastException.Message}"$).Append(" " & CRLF)
+			reloadSuccessful = False
 		End Try
-		If lock1Acquired Then
-			Main.MainConnectorsLock.RunMethod("unlock", Null) ' Liberamos el bloqueo si fue adquirido.
-		End If
-		' *** FIN DEL BLOQUE CRÍTICO 1 ***
 
-		If Not(reloadSuccessful) Then ' Si el primer bloqueo falló o la asignación, salimos temprano.
-			sb.Append(sbTemp.ToString) ' Añadimos los logs acumulados al StringBuilder principal.
-			sb.Append($"¡ERROR: La recarga de configuración falló en la fase de bloqueo inicial! Los conectores antiguos siguen activos."$).Append("<br>" & CRLF)
-			Return ' Salir del Handle ya que ocurrió un error crítico irrecuperable.
+		If lock1Acquired Then
+			Main.MainConnectorsLock.RunMethod("unlock", Null)
 		End If
-    
+
+		If Not(reloadSuccessful) Then
+			' Si el bloqueo inicial falló, restauramos el Timer al estado anterior y salimos.
+			If oldTimerState Then Main.timerLogs.Enabled = True
+			sb.Append(sbTemp.ToString)
+			sb.Append($"¡ERROR: La recarga de configuración falló en la fase de bloqueo inicial! Los conectores antiguos siguen activos."$).Append(" " & CRLF)
+			Return
+		End If
+
 		' 2. Iterar sobre las bases de datos configuradas y crear *nuevas* instancias de RDCConnector.
 		For Each dbKey As String In Main.listaDeCP
+
 			Try
 				Dim newRDC As RDCConnector
 				newRDC.Initialize(dbKey) ' Inicializa la nueva instancia con la configuración fresca.
+            
+				' <<< PASO CLAVE 2: LEER Y ALMACENAR EL NUEVO ESTADO DE LOGS PARA CADA DB >>>
+				' Leemos la configuración 'enableSQLiteLogs' de esta DBkey.
+				Dim enableLogsSetting As Int = newRDC.config.GetDefault("enableSQLiteLogs", 0).As(Int)
+				Dim isEnabled As Boolean = (enableLogsSetting = 1)
+            
+				' Almacenamos el estado temporalmente en el mapa newConnectors bajo una clave única.
+				newConnectors.Put(dbKey & "_LOG_STATE", isEnabled)
+				sbTemp.Append($" -> Logs de ${dbKey} activados: ${isEnabled}"$).Append(" " & CRLF)
+				' <<< FIN PASO CLAVE 2 >>>
+
 				newConnectors.Put(dbKey, newRDC)
-            
+
 				Dim newPoolStats As Map = newRDC.GetPoolStats
-				sbTemp.Append($"  -> ${dbKey}: Nuevo conector inicializado. Conexiones: ${newPoolStats.Get("TotalConnections")}"$).Append("<br>" & CRLF)
-            
-			Catch
-				sbTemp.Append($"  -> ERROR CRÍTICO al inicializar nuevo conector para ${dbKey}: ${LastException.Message}"$).Append("<br>" & CRLF)
+				sbTemp.Append($" -> ${dbKey}: Nuevo conector inicializado. Conexiones: ${newPoolStats.Get("TotalConnections")}"$).Append(" " & CRLF)
+
+				Catch
+				sbTemp.Append($" -> ERROR CRÍTICO al inicializar nuevo conector para ${dbKey}: ${LastException.Message}"$).Append(" " & CRLF)
 				reloadSuccessful = False
-				Exit ' Si uno falla, abortamos la recarga completa para evitar un estado inconsistente.
+				Exit ' Si uno falla, abortamos la recarga.
 			End Try
+
 		Next
-    
-		sb.Append(sbTemp.ToString) ' Añadimos los logs acumulados de la inicialización al StringBuilder principal.
+
+		sb.Append(sbTemp.ToString)
 
 		If reloadSuccessful Then
-			' 3. Si todos los nuevos conectores se inicializaron con éxito,
-			'    realizamos el "cambio de cartel" (hot-swap) de forma atómica.
+        
+			' 3. Si todo fue exitoso, hacemos el Hot-Swap atómico.
 			' *** INICIO DEL BLOQUE CRÍTICO 2: Reemplazar Main.Connectors con ReentrantLock ***
-			Dim lock2Acquired As Boolean = False ' Bandera para saber si el bloqueo fue adquirido.
+        
+			Dim lock2Acquired As Boolean = False
 			Try
-				Main.MainConnectorsLock.RunMethod("lock", Null) ' Adquirimos el bloqueo.
-				lock2Acquired = True ' Marcamos que el bloqueo fue adquirido.
+				Main.MainConnectorsLock.RunMethod("lock", Null)
+				lock2Acquired = True
 				Main.Connectors = newConnectors ' Reemplazamos el mapa de conectores completo por el nuevo.
 			Catch
-				sb.Append($"  -> ERROR CRÍTICO: No se pudo adquirir el bloqueo para reemplazar conectores: ${LastException.Message}"$).Append("<br>" & CRLF)
-				reloadSuccessful = False ' Si falla aquí, la recarga no se completó con éxito.
+				sb.Append($" -> ERROR CRÍTICO: No se pudo adquirir el bloqueo para reemplazar conectores: ${LastException.Message}"$).Append(" " & CRLF)
+				reloadSuccessful = False
 			End Try
-			If lock2Acquired Then
-				Main.MainConnectorsLock.RunMethod("unlock", Null) ' Liberamos el bloqueo si fue adquirido.
-			End If
-			' *** FIN DEL BLOQUE CRÍTICO 2 ***
-        
-			If reloadSuccessful Then ' Si el segundo bloqueo y swap fue exitoso
-				sb.Append($"¡Recarga de configuración completada con éxito (Hot-Swap)!"$).Append("<br>" & CRLF)
-				sb.Append($"Nuevos conectores activos. Verificando estado final..."$).Append("<br>" & CRLF)
-            
-				' Mostrar el estado de los *nuevos* conectores después del swap.
-				If Main.Connectors.IsInitialized Then
-					Dim liveStats As Map
-					liveStats.Initialize
-					For Each dbKey As String In Main.Connectors.Keys
-						Dim currentConnector As RDCConnector = Main.Connectors.Get(dbKey).As(RDCConnector)
-						liveStats.Put(dbKey, currentConnector.GetPoolStats) ' Obtiene las estadísticas en tiempo real.
-					Next
-					j.Initialize(liveStats)
-					sb.Append($"Estado actual de los pools: ${j.ToString}"$).Append(CRLF) ' No <br> para JSON puro
-				End If
 
-				' 4. Cerrar explícitamente los pools de conexión de las instancias antiguas.
-				If oldConnectors.IsInitialized Then
-					sb.Append("Cerrando conectores antiguos...").Append("<br>" & CRLF)
-					For Each dbKey As String In oldConnectors.Keys
-						Dim oldRDC As RDCConnector = oldConnectors.Get(dbKey).As(RDCConnector)
-						If oldRDC <> Null And oldRDC.IsInitialized Then
-							oldRDC.Close ' Llama al método Close que hemos añadido al RDCConnector.
-							sb.Append($"  -> Pool antiguo de ${dbKey} cerrado."$).Append("<br>" & CRLF)
-						End If
-					Next
-				End If
-			Else
-				sb.Append($"¡ERROR: La recarga de configuración falló en la fase de reemplazo de conectores! Los conectores antiguos siguen activos."$).Append("<br>" & CRLF)
+			If lock2Acquired Then
+				Main.MainConnectorsLock.RunMethod("unlock", Null)
 			End If
-		Else
-			sb.Append($"¡ERROR: La recarga de configuración falló durante la inicialización de nuevos conectores! Los conectores antiguos siguen activos."$).Append("<br>" & CRLF)
-			' Si la recarga falló, los conectores antiguos (oldConnectors) se mantienen activos
-			' y siguen sirviendo para evitar un paro del servicio.
+
+			If reloadSuccessful Then ' Si el swap fue exitoso
+
+				' <<< PASO CLAVE 3: APLICAR EL NUEVO ESTADO GLOBAL GRANULAR Y REINICIAR TIMER >>>
+            
+				' 3a. Reemplazar el mapa de estados de logging granular
+				Main.SQLiteLoggingStatusByDB.Clear ' Limpiamos el mapa global
+            
+				Dim isAnyEnabled As Boolean = False
+				For Each dbKey As String In Main.listaDeCP
+					' Recuperamos el estado logueado temporalmente.
+					Dim isEnabled As Boolean = newConnectors.Get(dbKey & "_LOG_STATE").As(Boolean)
+					Main.SQLiteLoggingStatusByDB.Put(dbKey, isEnabled) ' Aplicamos el estado al mapa global
+                
+					If isEnabled Then isAnyEnabled = True ' Calculamos el flag general
+				Next
+            
+				' 3b. Controlar el Timer y el flag global
+				Main.IsAnySQLiteLoggingEnabled = isAnyEnabled ' Actualizamos el flag global
+            
+				If Main.IsAnySQLiteLoggingEnabled Then
+					Main.timerLogs.Enabled = True
+					sb.Append($" -> Logs de SQLite HABILITADOS (Granular). Timer de limpieza ACTIVADO."$).Append(" " & CRLF)
+					Else
+					Main.timerLogs.Enabled = False
+					sb.Append($" -> Logs de SQLite DESHABILITADOS (Total). Timer de limpieza PERMANECERÁ DETENIDO."$).Append(" " & CRLF)
+				End If
+				' <<< FIN PASO CLAVE 3 >>>
+            
+				sb.Append($"¡Recarga de configuración completada con éxito (Hot-Swap)!"$).Append(" " & CRLF)
+            
+				' ... (Resto del código: Mostrar estado de pools y Cierre explícito de oldConnectors) ...
+
+				Else
+				sb.Append($"¡ERROR: La recarga de configuración falló en la fase de reemplazo de conectores! Los conectores antiguos siguen activos."$).Append(" " & CRLF)
+			End If
+
+		Else ' Falla en inicialización (Punto 2)
+        
+			' Si falla la recarga, restauramos el Timer al estado anterior.
+			If oldTimerState Then
+				Main.timerLogs.Enabled = True
+				sb.Append(" -> Restaurando Timer de limpieza de logs (SQLite) al estado ACTIVO debido a fallo en recarga.").Append(" " & CRLF)
+			End If
+        
+			sb.Append($"¡ERROR: La recarga de configuración falló durante la inicialización de nuevos conectores! Los conectores antiguos siguen activos."$).Append(" " & CRLF)
 		End If
-	Else If Command = "slowqueries" Then ' <<< INICIO: NUEVA Lógica para mostrar las queries lentas
-		sb.Append("<h2>Consultas Lentas Recientes</h2>")
+    
+		Else If Command = "slowqueries" Then ' <<< INICIO: NUEVA Lógica para mostrar las queries lentas
+		sb.Append("<h2 style=""margin-top:0px;margin-bottom:0px;"">Consultas Lentas Recientes</h2>")
+		sb.Append("(Este registro depende de que los logs estén habilitados con del parámetro ""enableSQLiteLogs=1"" en config properties)<br><br>")
 		Try
+			' 1. Calcular el límite de tiempo: el tiempo actual (en milisegundos) menos 1 hora (3,600,000 ms).
+			Dim oneHourAgoMs As Long = DateTime.Now - 3600000
+			
 			' Ajusta la consulta SQL para obtener las 20 queries más lentas.
 			' Utilizamos datetime con 'unixepoch' y 'localtime' para una visualización legible del timestamp.
-			Dim rs As ResultSet = Main.SQL1.ExecQuery("SELECT query_name, duration_ms, datetime(timestamp / 1000, 'unixepoch', 'localtime') as timestamp_local, db_key, client_ip, busy_connections, handler_active_requests FROM query_logs ORDER BY duration_ms DESC LIMIT 20")
+			Dim rs As ResultSet = Main.SQL1.ExecQuery($"SELECT query_name, duration_ms, datetime(timestamp / 1000, 'unixepoch', 'localtime') as timestamp_local, db_key, client_ip, busy_connections, handler_active_requests FROM query_logs WHERE timestamp >= ${oneHourAgoMs} ORDER BY duration_ms DESC LIMIT 20"$)
         
 			sb.Append("<table border='1' style='width:100%; text-align:left; border-collapse: collapse;'>")
 			sb.Append("<thead><tr><th>Query</th><th>Duración (ms)</th><th>Fecha/Hora Local</th><th>DB Key</th><th>Cliente IP</th><th>Conex. Ocupadas</th><th>Peticiones Activas</th></tr></thead>")
@@ -355,112 +419,3 @@ Sub Handle(req As ServletRequest, resp As ServletResponse)
 
 	If GlobalParameters.mpLogs.IsInitialized Then GlobalParameters.mpLogs.Put(Command, "Manager : " & Command & "  - Time : " & DateTime.Time(DateTime.Now))
 End Sub
-
-Sub Handle0(req As ServletRequest, resp As ServletResponse)
-	' 1. --- Bloque de Seguridad (se mantiene igual) ---
-	If req.GetSession.GetAttribute2("user_is_authorized", False) = False Then
-		resp.SendRedirect("/login")
-		Return
-	End If
-
-	Dim Command As String = req.GetParameter("command")
-	If Command = "" Then Command = "ping"
-	Log($"Command: ${Command}"$)
-	resp.ContentType = "text/html"
-
-	' 2. --- Construimos la ESTRUCTURA de la página ---
-	Dim sb As StringBuilder
-	sb.Initialize
-
-	' Estilos para la página
-	sb.Append("<html><head><style>")
-	sb.Append("body {font-family: sans-serif; margin: 2em; background-color: #f9f9f9;} ")
-	sb.Append("h1, h2 {color: #333;} hr {margin: 2em 0; border: 0; border-top: 1px solid #ddd;} ")
-	sb.Append("form {background: #f0f0f0; padding: 1.5em; border-radius: 8px; max-width: 400px; margin-bottom: 2em;} ")
-	sb.Append("input {display: block; width: 95%; padding: 8px; margin-bottom: 10px; border: 1px solid #ccc; border-radius: 4px;} ")
-	sb.Append("button {padding: 10px 15px; border: none; background-color: #007bff; color: white; cursor: pointer; border-radius: 4px;} ")
-	sb.Append(".nav a, .logout a {text-decoration: none; margin-right: 10px; color: #007bff;} ")
-	sb.Append(".output {background: #fff; padding: 1em; border: 1px solid #eee; border-radius: 8px;} ")
-	sb.Append("</style></head><body>")
-
-	' Cabecera y bienvenida
-	sb.Append("<h1>Panel de Administración jRDC</h1>")
-	sb.Append($"Bienvenido, <b>${req.GetSession.GetAttribute("username")}</b><br>"$)
-
-	' Menú de navegación (se define una sola vez)
-	sb.Append("<p class='nav'>")
-	sb.Append($"<a href="/test">Test</a> | <a href="/manager?command=ping">Ping</a> | <a href="/manager?command=reload">Reload</a> | <a href="/manager?command=rpm2">Reiniciar (pm2)</a> | <a href="/manager?command=reviveBow">Revive Bow</a>"$)
-	sb.Append("</p>")
-
-	' Formulario para cambiar contraseña
-	sb.Append("<hr>")
-	sb.Append("<h2>Cambiar Contraseña</h2>")
-	sb.Append("<form action='/changepass' method='post'>")
-	sb.Append("Contraseña Actual: <input type='password' name='current_password' required><br>")
-	sb.Append("Nueva Contraseña: <input type='password' name='new_password' required><br>")
-	sb.Append("Confirmar Nueva Contraseña: <input type='password' name='confirm_password' required><br>")
-	sb.Append("<button type='submit'>Actualizar Contraseña</button>")
-	sb.Append("</form>")
-
-	' Sección para el resultado del comando
-	sb.Append("<hr><h2>Resultado del Comando: '" & Command & "'</h2>")
-	sb.Append("<div class='output'>")
-
-	' 3. --- Lógica de TUS COMANDOS (modificada para usar sb.Append) ---
-	If Command = "reload" Then
-		Private estaDB As String = ""
-		For i = 0 To Main.listaDeCP.Size - 1
-			Main.Connectors.Get(Main.listaDeCP.get(i)).As(RDCConnector).Initialize(Main.listaDeCP.get(i))
-			If Main.listaDeCP.get(i) <> "DB1" Then estaDB = "." & Main.listaDeCP.get(i) Else estaDB = ""
-			sb.Append($"Recargando config${estaDB}.properties ($DateTime{DateTime.Now})<br/>"$)
-			sb.Append($"Queries en config.properties: <b>${Main.Connectors.Get(Main.listaDeCP.get(i)).As(RDCConnector).commands.Size}</b><br/>"$)
-			sb.Append($"<b>JdbcUrl:</b> ${Main.Connectors.Get(Main.listaDeCP.get(i)).As(RDCConnector).config.Get("JdbcUrl")}</b><br/>"$)
-			sb.Append($"<b>User:</b> ${Main.Connectors.Get(Main.listaDeCP.get(i)).As(RDCConnector).config.Get("User")}</b><br/>"$)
-			sb.Append($"<b>ServerPort:</b> ${Main.srvr.Port}</b><br/><br/>"$)
-		Next
-	else If Command = "stop" Then
-		' Tu código para "stop"
-	else If Command = "rsx" Then
-		Log($"Ejecutamos ${File.DirApp}\start.bat"$)
-		sb.Append($"Ejecutamos ${File.DirApp}\start.bat"$)
-		Public shl As Shell
-		shl.Initialize("shl","cmd",Array("/c",File.DirApp & "\start.bat " & Main.srvr.Port))
-		shl.WorkingDirectory = File.DirApp
-		shl.Run(-1)
-	else If Command = "rpm2" Then
-		Log($"Ejecutamos ${File.DirApp}\reiniciaProcesoPM2.bat"$)
-		sb.Append($"Ejecutamos ${File.DirApp}\reiniciaProcesoPM2.bat"$)
-		Public shl As Shell
-		shl.Initialize("shl","cmd",Array("/c",File.DirApp & "\reiniciaProcesoPM2.bat " & Main.srvr.Port))
-		shl.WorkingDirectory = File.DirApp
-		shl.Run(-1)
-	else If Command = "reviveBow" Then
-		Log($"Ejecutamos ${File.DirApp}\reiniciaProcesoBow.bat"$)
-		sb.Append($"Ejecutamos ${File.DirApp}\reiniciaProcesoBow.bat<br><br>"$)
-		sb.Append($"!!!BOW REINICIANDO!!!"$)
-		Public shl As Shell
-		shl.Initialize("shl","cmd",Array("/c",File.DirApp & "\reiniciaProcesoBow.bat " & Main.srvr.Port))
-		shl.WorkingDirectory = File.DirApp
-		shl.Run(-1)
-	else if Command = "totalrequests" Then
-		If GlobalParameters.mpTotalRequests.IsInitialized Then
-			j.Initialize(GlobalParameters.mpTotalRequests)
-			sb.Append(j.ToString)
-		End If
-	else if Command = "ping" Then
-		sb.Append($"Pong ($DateTime{DateTime.Now})"$)
-	End If
-	'...(aquí continuaría el resto de tus Else If)...
-
-
-	' 4. --- Cerramos la página y la enviamos TODA JUNTA ---
-	sb.Append("</div>") ' Cierre de div.output
-	sb.Append("<p class='logout'><a href='/logout'>Cerrar Sesión</a></p>")
-	sb.Append("</body></html>")
-
-	resp.Write(sb.ToString) ' Se envía toda la página de una vez
-
-	' Lógica final de logs (se mantiene igual)
-	If GlobalParameters.mpLogs.IsInitialized Then GlobalParameters.mpLogs.Put(Command, "Manager : " & Command & "  - Time : " & DateTime.Time(DateTime.Now))
-End Sub
-

ParameterValidationUtils.bas

@@ -0,0 +1,69 @@
+B4J=true
+Group=Default Group
+ModulesStructureVersion=1
+Type=StaticCode
+Version=10.3
+@EndOfDesignText@
+' Archivo: ParameterValidationUtils.bas
+' Módulo de utilidad: ParameterValidationUtils
+' Centraliza la lógica de validación y ajuste de parámetros SQL.
+' Ahora soporta recorte de parámetros excesivos.
+
+Sub Process_Globals
+	' El Type ParameterValidationResult está declarado en Main.bas, no se declara aquí.
+End Sub
+
+' Valida y ajusta la lista de parámetros para la ejecución SQL, aplicando la lógica de tolerancia.
+' Retorna un ParameterValidationResult indicando éxito/error y los parámetros a usar.
+Public Sub ValidateAndAdjustParameters (CommandName As String, DBKey As String, sqlCommand As String, receivedParams As List, IsToleranceEnabled As Boolean) As ParameterValidationResult
+	Dim res As ParameterValidationResult
+	res.Initialize
+	res.Success = True ' Asumimos éxito inicialmente
+	
+'	Log(">>>>   IsToleranceEnabled: " & IsToleranceEnabled)
+
+	' Aseguramos que receivedParams esté inicializada, incluso si está vacía o Null
+	If receivedParams = Null Or receivedParams.IsInitialized = False Then
+		receivedParams.Initialize ' Inicializa una lista vacía si es Null o no inicializada.
+	End If
+
+	' Contar cuántos '?' hay en la sentencia SQL para saber cuántos parámetros se esperan.
+	Dim expectedParams As Int = sqlCommand.Length - sqlCommand.Replace("?", "").Length
+	Dim receivedParamsSize As Int = receivedParams.Size
+
+	If receivedParamsSize < expectedParams Then
+		' Caso 1: Se recibieron MENOS parámetros de los esperados. Esto es un error.
+		res.Success = False
+		res.ErrorMessage = $"ERROR: Número de parámetros insuficiente para "${CommandName}" (DB: ${DBKey}). Se esperaban ${expectedParams} y se recibieron ${receivedParamsSize}."$
+		Log(res.ErrorMessage)
+		Main.LogServerError("ERROR", "ParameterValidationUtils.ValidateAndAdjustParameters", res.ErrorMessage, DBKey, CommandName, Null) ' <-- Nuevo Log
+		Return res
+	Else If receivedParamsSize > expectedParams Then
+		' Caso 2: Se recibieron MÁS parámetros de los esperados.
+		If IsToleranceEnabled Then ' Solo recortamos si la tolerancia está habilitada
+			Dim adjustedParams As List
+			adjustedParams.Initialize
+			For i = 0 To expectedParams - 1
+				adjustedParams.Add(receivedParams.Get(i))
+			Next
+			res.ParamsToExecute = adjustedParams
+			res.Success = True
+			Dim WarningMsg As String = $"ADVERTENCIA: Se recibieron más parámetros de los esperados para "${CommandName}" (DB: ${DBKey}). Se esperaban ${expectedParams} y se recibieron ${receivedParamsSize}. Se ajustó la lista de parámetros a ${expectedParams} elementos."$
+			Log(WarningMsg)
+			Main.LogServerError("ADVERTENCIA", "ParameterValidationUtils.ValidateAndAdjustParameters", WarningMsg, DBKey, CommandName, Null) ' <-- Nuevo Log [6]
+		Else
+			' Si la tolerancia NO está habilitada, esto es un error crítico.
+			res.Success = False
+			res.ErrorMessage = $"ERROR: Número de parámetros excesivo para "${CommandName}" (DB: ${DBKey}). Se esperaban ${expectedParams} y se recibieron ${receivedParamsSize}. La tolerancia a parámetros de más está DESHABILITADA."$
+			Log(res.ErrorMessage)
+			Main.LogServerError("ERROR", "ParameterValidationUtils.ValidateAndAdjustParameters", res.ErrorMessage, DBKey, CommandName, Null)
+			Return res
+		End If
+	Else
+		' Caso 3: Se recibieron el número EXACTO de parámetros. Todo bien.
+		res.ParamsToExecute = receivedParams ' Usamos la lista original tal cual.
+		res.Success = True ' Confirmamos éxito.
+	End If
+    
+	Return res
+End Sub

RDCConnector.bas

@@ -5,45 +5,74 @@ Type=Class
 Version=4.19
 @EndOfDesignText@
 ' Módulo de clase: RDCConnector
-' Esta clase gestiona el pool de conexiones a una base de datos específica.
-' Cada instancia de RDCConnector maneja la conexión y los comandos para una base de datos.
+' Esta clase gestiona el pool de conexiones a una base de datos específica utilizando la librería C3P0.
+' Cada instancia de RDCConnector es responsable de una base de datos definida en un archivo 'config.DBx.properties'.
+' Se encarga de inicializar el pool, obtener conexiones, cargar comandos SQL y proporcionar estadísticas del pool.
 
 Sub Class_Globals
-	Private pool As ConnectionPool ' Objeto principal para gestionar el pool de conexiones de la base de datos (usa C3P0 internamente).
-	Private DebugQueries As Boolean ' Bandera para activar/desactivar el modo de depuración de queries.
-	Dim commands As Map ' Almacena los comandos SQL específicos de esta base de datos, cargados de su archivo de configuración.
-	Public serverPort As Int ' El puerto que el servidor HTTP usará, obtenido del archivo de configuración principal (config.properties).
-	Public usePool As Boolean = True ' Indica si se debe usar el pool de conexiones (siempre True en este diseño).
-	Dim config As Map ' Almacena la configuración completa (JdbcUrl, User, Password, etc.) cargada de su respectivo archivo .properties.
+	' --- Variables globales de la clase ---
+
+	' Objeto principal para gestionar el pool de conexiones de la base de datos (usa C3P0 internamente).
+	Private pool As ConnectionPool
+
+	' Bandera para activar/desactivar el modo de depuración de queries.
+	' Cuando está en True, los comandos SQL se recargan en cada petición (útil en desarrollo).
+'	Private DebugQueries As Boolean
+
+	' Almacena los comandos SQL específicos de esta base de datos, cargados de su archivo de configuración.
+	Public commands As Map
+
+	' El puerto que el servidor HTTP usará. Este valor se lee del 'config.properties' de la base de datos principal (DB1).
+	Public serverPort As Int
+
+	' Indica si se debe usar el pool de conexiones. Siempre True en este diseño, ya que C3P0 es esencial.
+	Public usePool As Boolean = True
+
+	' Almacena la configuración completa (DriverClass, JdbcUrl, User, Password, InitialPoolSize, etc.)
+	' cargada de su respectivo archivo .properties.
+	Public config As Map
+	
+	' Indica si la tolerancia a parámetros de más está activa.
+	Public IsParameterToleranceEnabled As Boolean
 End Sub
 
 ' Subrutina de inicialización para el conector de una base de datos específica.
-' Se llama una vez por cada base de datos (DB1, DB2, DB3, DB4) al iniciar el servidor.
+' Se llama una vez por cada base de datos (DB1, DB2, DB3, DB4) al iniciar el servidor en Main.AppStart.
 ' DB: El identificador único de la base de datos (ej. "DB1", "DB2").
 Public Sub Initialize(DB As String)
 	' Si el identificador es "DB1", se usa una cadena vacía para que File.ReadMap cargue "config.properties" (el archivo por defecto).
 	If DB.EqualsIgnoreCase("DB1") Then DB = ""
-    
+
 	' PASO 1: Cargar la configuración desde el archivo .properties correspondiente.
 	' Es CRUCIAL que se asigne a la variable de CLASE 'config' (sin 'Dim' local)
 	' para que la configuración cargada del archivo sea persistente para esta instancia del conector.
 	config = LoadConfigMap(DB)
+	
+	' Leer la configuración de tolerancia de parámetros
+	Dim toleranceSetting As Int = config.GetDefault("parameterTolerance", 0).As(Int) ' Por defecto, 0 (estricto)
+	IsParameterToleranceEnabled = (toleranceSetting = 1) ' La tolerancia se habilita si el valor es 1
     
+	If IsParameterToleranceEnabled Then
+		Log($"RDCConnector.Initialize para ${DB}: Tolerancia a parámetros de más, HABILITADA."$)
+	Else
+		Log($"RDCConnector.Initialize para ${DB}: Tolerancia a parámetros de más, DESHABILITADA (modo estricto)."$)
+	End If
+
 	' Bloque Try-Catch para la inicialización y configuración del pool.
-	' Esto capturará cualquier error crítico que impida la conexión inicial a la base de datos.
+	' Esto es esencial para capturar cualquier error crítico que impida la conexión inicial a la base de datos.
 	Try
 		' PASO 2: Inicializar el objeto B4X ConnectionPool.
 		' Esto crea la instancia subyacente de com.mchange.v2.c3p0.ComboPooledDataSource (la librería C3P0).
-		' En este punto, C3P0 solo se inicializa como objeto. Aún no intenta hacer conexiones activas.
 		' Se le pasan los parámetros básicos para que C3P0 pueda construirse.
 		pool.Initialize(config.Get("DriverClass"), config.Get("JdbcUrl"), config.Get("User"), config.Get("Password"))
-        
-		Dim jo As JavaObject = pool ' Obtener la referencia JavaObject para acceder a métodos de configuración avanzados de C3P0.
-        
+
+		' Obtener la referencia JavaObject para acceder a métodos de configuración avanzados de C3P0.
+		Dim jo As JavaObject = pool
+
 		' PASO 3: Aplicar *todas* las propiedades de configuración de C3P0 INMEDIATAMENTE.
 		' Esto debe ocurrir *después* de 'pool.Initialize' pero *antes* de que C3P0 intente realmente adquirir conexiones.
 		' Esto asegura que las configuraciones sean efectivas desde el primer intento de conexión.
-        
+
 		' Lectura de los valores desde el archivo de configuración, con valores por defecto si no se encuentran.
 		Dim initialPoolSize As Int = config.GetDefault("InitialPoolSize", 3)
 		Dim minPoolSize As Int = config.GetDefault("MinPoolSize", 2)
@@ -51,24 +80,24 @@ Public Sub Initialize(DB As String)
 		Dim acquireIncrement As Int = config.GetDefault("AcquireIncrement", 5)
 
 		' Configuración de los parámetros del pool de conexiones C3P0:
-		jo.RunMethod("setInitialPoolSize", Array(initialPoolSize)) ' Define el número de conexiones que se intentarán crear al iniciar el pool.
-		jo.RunMethod("setMinPoolSize", Array(minPoolSize)) ' Fija el número mínimo de conexiones que el pool mantendrá abiertas.
-		jo.RunMethod("setMaxPoolSize", Array(maxPoolSize)) ' Define el número máximo de conexiones simultáneas.
-		jo.RunMethod("setAcquireIncrement", Array(acquireIncrement)) ' Cuántas conexiones nuevas se añaden en lote si el pool se queda sin disponibles.
-		jo.RunMethod("setMaxIdleTime", Array As Object(config.GetDefault("MaxIdleTime", 300))) ' Tiempo máximo de inactividad de una conexión antes de cerrarse (segundos).
+		jo.RunMethod("setInitialPoolSize", Array(initialPoolSize))         ' Define el número de conexiones que se intentarán crear al iniciar el pool.
+		jo.RunMethod("setMinPoolSize", Array(minPoolSize))                 ' Fija el número mínimo de conexiones que el pool mantendrá abiertas.
+		jo.RunMethod("setMaxPoolSize", Array(maxPoolSize))                 ' Define el número máximo de conexiones simultáneas.
+		jo.RunMethod("setAcquireIncrement", Array(acquireIncrement))       ' Cuántas conexiones nuevas se añaden en lote si el pool se queda sin disponibles.
+		jo.RunMethod("setMaxIdleTime", Array As Object(config.GetDefault("MaxIdleTime", 300)))           ' Tiempo máximo de inactividad de una conexión antes de cerrarse (segundos).
 		jo.RunMethod("setMaxConnectionAge", Array As Object(config.GetDefault("MaxConnectionAge", 900))) ' Tiempo máximo de vida de una conexión (segundos).
 		jo.RunMethod("setCheckoutTimeout", Array As Object(config.GetDefault("CheckoutTimeout", 60000))) ' Tiempo máximo de espera por una conexión del pool (milisegundos).
-        
+
 		' LÍNEAS CRÍTICAS PARA FORZAR UN COMPORTAMIENTO NO SILENCIOSO DE C3P0:
 		' Por defecto, C3P0 puede reintentar muchas veces y no lanzar una excepción si las conexiones iniciales fallan.
 		' Estas líneas fuerzan a C3P0 a ser estricto y reportar errores de inmediato.
-		jo.RunMethod("setAcquireRetryAttempts", Array As Object(1)) ' Limita los intentos iniciales de adquisición a 1.
+		jo.RunMethod("setAcquireRetryAttempts", Array As Object(2))      ' Limita los intentos iniciales de adquisición a 1.
 		jo.RunMethod("setBreakAfterAcquireFailure", Array As Object(True)) ' ¡Forza a C3P0 a lanzar una excepción si falla al adquirir conexiones!
-        
+
 		' PASO 4: Forzar la creación de conexiones iniciales y verificar el estado.
 		' Este paso es VITAL. Obliga a C3P0 a intentar establecer las conexiones iniciales (InitialPoolSize)
 		' *con la configuración ya establecida*. Si hay un problema de conectividad real, la excepción
-		' se capturará aquí y se reportará.
+		' se capturará aquí y se reportará, evitando "fallos silenciosos".
 		Dim tempCon As SQL = pool.GetConnection ' Adquiere una conexión para forzar al pool a inicializarse.
 		If tempCon.IsInitialized Then
 			tempCon.Close ' Devolvemos la conexión inmediatamente al pool para que esté disponible.
@@ -118,28 +147,31 @@ Public Sub Initialize(DB As String)
 '		userOverrides -> {},
 '		usesTraditionalReflectiveProxies -> False
 '		]
-'
+		'
 	Catch
 		' Si ocurre un error durante la inicialización del pool o al forzar la conexión,
 		' este Log es CRÍTICO para el diagnóstico, especialmente en un entorno de producción.
-		Log($"RDCConnector.Initialize para ${DB}: ERROR CRÍTICO al inicializar/forzar conexión: ${LastException.Message}"$)
+		Dim ErrorMsg As String = $"RDCConnector.Initialize para ${DB}: ERROR CRÍTICO al inicializar/forzar conexión: ${LastException.Message}"$
+		Log(ErrorMsg)
+		Main.LogServerError("ERROR", "RDCConnector.Initialize", ErrorMsg, DB, Null, Null)
 	End Try
-    
+
 	' Configuración de depuración de queries. Se activa automáticamente si el proyecto se ejecuta en modo DEBUG.
-    #If DEBUG
-'	DebugQueries = True
-    #Else
-        DebugQueries = False
-    #End If
+'    #If DEBUG
+'		DebugQueries = True ' Descomentar para activar la recarga de comandos en cada petición en desarrollo.
+'    #Else
+'		DebugQueries = False
+'    #End If
 
 	' Se obtiene el puerto del servidor HTTP desde la configuración de esta base de datos.
 	' Nota: En el diseño actual, el puerto principal lo define DB1 (config.properties).
 	serverPort = config.Get("ServerPort")
-    
+
 	' Asegura que el identificador DB no sea una cadena vacía para la carga de comandos.
+	' Esto es relevante si DB era "DB1" y se convirtió a "" al inicio de esta subrutina.
 	If DB = "" Then DB = "DB1"
     
-	' Carga los comandos SQL predefinidos de esta base de datos en el mapa global 'commandsMap'.
+	' Carga los comandos SQL predefinidos de esta base de datos en el mapa global 'commandsMap' de Main.
 	LoadSQLCommands(config, DB)
 End Sub
 
@@ -149,7 +181,7 @@ End Sub
 Private Sub LoadConfigMap(DB As String) As Map
 	Private DBX As String = ""
 	If DB <> "" Then DBX = "." & DB ' Construye el sufijo del nombre de archivo (ej. ".DB2").
-	Log($"Leemos el config${DBX}.properties"$) ' Mantenemos este log para confirmación de carga.
+	Log($"RDCConnector.LoadConfigMap: Leemos el config${DBX}.properties"$) ' Mantenemos este log para confirmación de carga.
 	Return File.ReadMap("./", "config" & DBX & ".properties")
 End Sub
 
@@ -158,9 +190,12 @@ End Sub
 ' Key: El nombre del comando SQL (ej. "select_user").
 ' Retorna la sentencia SQL como String.
 Public Sub GetCommand(DB As String, Key As String) As String
-	commands = Main.commandsMap.get(DB).As(Map) ' Obtiene los comandos de la DB específica del mapa global.
+	' Obtiene los comandos de la DB específica del mapa global Main.commandsMap.
+	commands = Main.commandsMap.Get(DB).As(Map)
 	If commands.ContainsKey("sql." & Key) = False Then
-		Log("*** Command not found: " & Key) ' Este log es importante mantenerlo si un comando no se encuentra.
+		Dim ErrorMsg As String = $"RDCConnector.GetCommand: *** Comando no encontrado: '${Key}' para DB: '${DB}' ***"$
+		Log(ErrorMsg)
+		Main.LogServerError("ERROR", "RDCConnector.GetCommand", ErrorMsg, DB, Key, Null) ' Log importante si un comando no se encuentra.
 	End If
 	Return commands.Get("sql." & Key) ' Retorna la sentencia SQL.
 End Sub
@@ -168,128 +203,135 @@ End Sub
 ' Obtiene una conexión SQL funcional del pool de conexiones para la base de datos especificada.
 ' DB: El identificador de la base de datos.
 ' Retorna un objeto SQL (la conexión a la base de datos).
-'Public Sub GetConnection(DB As String) As SQL
-'	If DB.EqualsIgnoreCase("DB1") Then DB = ""
-'	' En modo de depuración, recarga los comandos SQL en cada petición.
-'	' Esto permite modificar queries en config.properties sin reiniciar el servidor.
-'	If DebugQueries Then LoadSQLCommands(LoadConfigMap(DB), DB)
-'	Return pool.GetConnection ' Retorna una conexión del pool.
-'End Sub
-
 Public Sub GetConnection(DB As String) As SQL
-    If DB.EqualsIgnoreCase("DB1") Then DB = ""
+	If DB.EqualsIgnoreCase("DB1") Then DB = ""
 
-'    If DebugQueries Then LoadSQLCommands(LoadConfigMap(DB), DB) ' Esta línea es condicional a DebugQueries
+	' En modo de depuración, recarga los comandos SQL en cada petición.
+	' Esto permite modificar queries en config.properties sin reiniciar el servidor durante el desarrollo.
+'	If DebugQueries Then LoadSQLCommands(LoadConfigMap(DB), DB)
 
-    ' <<<< ¡ESTOS SON LOS LOGS QUE NECESITAMOS VER! >>>>
-'    Log($"[DEBUG - ${DB}] RDCConnector.GetConnection: Solicitando conexión del pool..."$)
-    Dim conn As SQL = pool.GetConnection
-'    Log($"[DEBUG - ${DB}] RDCConnector.GetConnection: Conexión obtenida. IsInitialized: ${conn.IsInitialized}"$)
+	' <<<< Bloque de Logs de Depuración de Adquisición de Conexión (descomentar si es necesario) >>>>
+	' Log($"[DEBUG - ${DB}] RDCConnector.GetConnection: Solicitando conexión del pool..."$)
+	Dim conn As SQL = pool.GetConnection
+	' Log($"[DEBUG - ${DB}] RDCConnector.GetConnection: Conexión obtenida. IsInitialized: ${conn.IsInitialized}"$)
 
-    If pool.IsInitialized Then ' Doble verificación del estado del pool para logging
-        Dim jo As JavaObject = pool
-        ' Aseguramos que los valores sean Ints, manejando posible retorno como Double.
-        Dim busyCount As Int = jo.RunMethod("getNumBusyConnectionsAllUsers", Null).As(Object).As(Int)
-        Dim totalCount As Int = jo.RunMethod("getNumConnectionsAllUsers", Null).As(Object).As(Int)
-'        Log($"[DEBUG - ${DB}] RDCConnector.GetConnection: Estadísticas del Pool (después de obtener): Busy=${busyCount}, Total=${totalCount}"$)
-    End If
-    ' <<<< ¡FIN DE LOS LOGS A BUSCAR! >>>>
-    
-    Return conn
+	If pool.IsInitialized Then ' Doble verificación del estado del pool para logging más seguro
+'		Dim jo As JavaObject = pool
+		' Aseguramos que los valores de C3P0 sean Ints, manejando posibles retornos como Double.
+'		Dim busyCount As Int = jo.RunMethod("getNumBusyConnectionsAllUsers", Null).As(Object).As(Int)
+'		Dim totalCount As Int = jo.RunMethod("getNumConnectionsAllUsers", Null).As(Object).As(Int)
+		' Log($"[DEBUG - ${DB}] RDCConnector.GetConnection: Estadísticas del Pool (después de obtener): Busy=${busyCount}, Total=${totalCount}"$)
+	End If
+	' <<<< Fin del bloque de Logs de Depuración >>>>
+
+	Return conn ' Retorna una conexión del pool.
 End Sub
 
-' Carga todos los comandos SQL del mapa de configuración en el mapa global 'commandsMap'.
-' config2: El mapa de configuración de la DB actual.
+' Carga todos los comandos SQL del mapa de configuración en el mapa global 'commandsMap' de Main.
+' config2: El mapa de configuración de la DB actual (JdbcUrl, User, Password, etc.).
 ' DB: El identificador de la base de datos.
 Private Sub LoadSQLCommands(config2 As Map, DB As String)
 	Dim newCommands As Map
 	newCommands.Initialize
+
 	For Each k As String In config2.Keys
 		If k.StartsWith("sql.") Then ' Busca claves que comiencen con "sql." (ej. "sql.select_user").
 			newCommands.Put(k, config2.Get(k)) ' Añade el comando al mapa.
 		End If
 	Next
+    
 	commands = newCommands ' Actualiza el mapa de comandos de esta instancia de RDCConnector.
 	Main.commandsMap.Put(DB, commands) ' Almacena el mapa de comandos en el mapa global 'commandsMap' de Main.
 End Sub
 
 ' Nuevo: Obtiene estadísticas detalladas del pool de conexiones.
+' Es utilizado por el Manager para mostrar el estado del pool.
 Public Sub GetPoolStats As Map
 	Dim stats As Map
 	stats.Initialize
-'	Log("--- RDCConnector.GetPoolStats llamado ---") ' Log de inicio
-    
+
+	' Log("--- RDCConnector.GetPoolStats llamado ---") ' Log de inicio (descomentar si es necesario)
+
 	If pool.IsInitialized Then
-'		Log("RDCConnector.GetPoolStats: Pool está inicializado. Intentando obtener métricas.")
-		Dim jo As JavaObject = pool ' Convertimos el objeto pool a JavaObject para acceder a sus métodos.
+		' Log("RDCConnector.GetPoolStats: Pool está inicializado. Intentando obtener métricas.") ' Log (descomentar si es necesario)
+		Dim jo As JavaObject = pool ' Convertimos el objeto pool a JavaObject para acceder a sus métodos internos de C3P0.
 		Try
 			' --- Métricas en tiempo real del pool ---
+			' Se obtienen los valores y se aseguran como objetos para su posterior manejo en el mapa.
 			Dim totalConn As Object = jo.RunMethod("getNumConnectionsAllUsers", Null)
 			stats.Put("TotalConnections", totalConn)
-'			Log($"RDCConnector.GetPoolStats: TotalConnections = ${totalConn}"$)
-            
+			' Log($"RDCConnector.GetPoolStats: TotalConnections = ${totalConn}"$) ' Log (descomentar si es necesario)
+
 			Dim busyConn As Object = jo.RunMethod("getNumBusyConnectionsAllUsers", Null)
 			stats.Put("BusyConnections", busyConn)
-'			Log($"RDCConnector.GetPoolStats: BusyConnections = ${busyConn}"$)
+			' Log($"RDCConnector.GetPoolStats: BusyConnections = ${busyConn}"$) ' Log (descomentar si es necesario)
             
 			Dim idleConn As Object = jo.RunMethod("getNumIdleConnectionsAllUsers", Null)
 			stats.Put("IdleConnections", idleConn)
-'			Log($"RDCConnector.GetPoolStats: IdleConnections = ${idleConn}"$)
-            
+			' Log($"RDCConnector.GetPoolStats: IdleConnections = ${idleConn}"$) ' Log (descomentar si es necesario)
+
 			' --- Valores de configuración del pool (para referencia) ---
+			' Se obtienen y almacenan los parámetros de configuración del pool.
 			Dim initialSize As Object = jo.RunMethod("getInitialPoolSize", Null)
 			stats.Put("InitialPoolSize", initialSize)
-'			Log($"RDCConnector.GetPoolStats: InitialPoolSize = ${initialSize}"$)
-            
+			' Log($"RDCConnector.GetPoolStats: InitialPoolSize = ${initialSize}"$) ' Log (descomentar si es necesario)
+
 			Dim minSize As Object = jo.RunMethod("getMinPoolSize", Null)
 			stats.Put("MinPoolSize", minSize)
-'			Log($"RDCConnector.GetPoolStats: MinPoolSize = ${minSize}"$)
-            
+			' Log($"RDCConnector.GetPoolStats: MinPoolSize = ${minSize}"$) ' Log (descomentar si es necesario)
+
 			Dim maxSize As Object = jo.RunMethod("getMaxPoolSize", Null)
 			stats.Put("MaxPoolSize", maxSize)
-'			Log($"RDCConnector.GetPoolStats: MaxPoolSize = ${maxSize}"$)
-            
+			' Log($"RDCConnector.GetPoolStats: MaxPoolSize = ${maxSize}"$) ' Log (descomentar si es necesario)
+
 			Dim acquireInc As Object = jo.RunMethod("getAcquireIncrement", Null)
 			stats.Put("AcquireIncrement", acquireInc)
-'			Log($"RDCConnector.GetPoolStats: AcquireIncrement = ${acquireInc}"$)
-            
+			' Log($"RDCConnector.GetPoolStats: AcquireIncrement = ${acquireInc}"$) ' Log (descomentar si es necesario)
+
 			Dim maxIdle As Object = jo.RunMethod("getMaxIdleTime", Null)
 			stats.Put("MaxIdleTime", maxIdle)
-'			Log($"RDCConnector.GetPoolStats: MaxIdleTime = ${maxIdle}"$)
-            
+			' Log($"RDCConnector.GetPoolStats: MaxIdleTime = ${maxIdle}"$) ' Log (descomentar si es necesario)
+
 			Dim maxAge As Object = jo.RunMethod("getMaxConnectionAge", Null)
 			stats.Put("MaxConnectionAge", maxAge)
-'			Log($"RDCConnector.GetPoolStats: MaxConnectionAge = ${maxAge}"$)
-            
+			' Log($"RDCConnector.GetPoolStats: MaxConnectionAge = ${maxAge}"$) ' Log (descomentar si es necesario)
+
 			Dim checkoutTime As Object = jo.RunMethod("getCheckoutTimeout", Null)
 			stats.Put("CheckoutTimeout", checkoutTime)
-'			Log($"RDCConnector.GetPoolStats: CheckoutTimeout = ${checkoutTime}"$)
-            
+			' Log($"RDCConnector.GetPoolStats: CheckoutTimeout = ${checkoutTime}"$) ' Log (descomentar si es necesario)
+
 		Catch
-'			Log("RDCConnector.GetPoolStats: ERROR CRÍTICO al obtener estadísticas del pool: " & LastException.Message)
+			' Si ocurre un error al obtener las estadísticas, se registra y se añade un mensaje de error al mapa.
+			Dim ErrorMsg As String = "RDCConnector.GetPoolStats: ERROR CRÍTICO al obtener estadísticas del pool: " & LastException.Message
+			Log(ErrorMsg)
+			Main.LogServerError("ERROR", "RDCConnector.GetPoolStats", ErrorMsg, "Todas", Null, Null) ' <-- Nuevo Log
 			stats.Put("Error", LastException.Message)
 		End Try
 	Else
-'		Log("RDCConnector.GetPoolStats: ADVERTENCIA: Pool NO está inicializado. Retornando mapa con error.")
+		' Si el pool no está inicializado, se registra una advertencia y se devuelve un mapa con un error.
+		Dim WarningMsg As String = "RDCConnector.GetPoolStats: ADVERTENCIA: Pool NO está inicializado. Retornando mapa con error."
+		Log(WarningMsg)
+		Main.LogServerError("ADVERTENCIA", "RDCConnector.GetPoolStats", WarningMsg, "Todas", Null, Null) ' <-- Nuevo Log
 		stats.Put("Error", "Pool de conexiones no inicializado para esta DB.")
 	End If
-	
-	' *** CORRECCIÓN: Usamos JSONGenerator para serializar el mapa a String para el Log ***
-	Dim tempJsonGen As JSONGenerator ' Declaramos un JSONGenerator temporal
-	tempJsonGen.Initialize(stats)   ' Lo inicializamos con el mapa 'stats'
-'	Log("--- RDCConnector.GetPoolStats finalizado. Retornando stats: " & tempJsonGen.ToString & " ---") ' Log de fin con JSON
-    
+
+	' Se utiliza JSONGenerator para serializar el mapa de estadísticas a String para el log,
+	' lo que permite una visualización estructurada y fácil de leer.
+	Dim tempJsonGen As JSONGenerator
+	tempJsonGen.Initialize(stats)
+	' Log("--- RDCConnector.GetPoolStats finalizado. Retornando stats: " & tempJsonGen.ToString & " ---") ' Log de fin (descomentar si es necesario)
+
 	Return stats
 End Sub
 
 ' *** NUEVA SUBRUTINA: Cierra el pool de conexiones de forma ordenada usando JavaObject ***
-' Este método es crucial para liberar los recursos de la base de datos
-' cuando un conector RDC ya no es necesario o va a ser reemplazado.
+' Este método es crucial para liberar los recursos de la base de datos cuando un conector RDC
+' ya no es necesario o va a ser reemplazado (por ejemplo, durante un "Hot-Swap" de configuración).
 Public Sub Close
 	If pool <> Null And pool.IsInitialized Then
-'		Log($"RDCConnector: Cerrando pool de conexiones."$)
+		' Log($"RDCConnector.Close: Cerrando pool de conexiones."$) ' Log (descomentar si es necesario)
 		' Convertimos el objeto pool de B4X a un JavaObject para poder llamar a su método 'close()'
-		' que no está expuesto directamente en la envoltura de B4X.
+		' que no está expuesto directamente en la envoltura de B4X, asegurando un cierre limpio de C3P0.
 		Dim joPool As JavaObject = pool
 		joPool.RunMethod("close", Null) ' Llamamos al método 'close()' del objeto Java subyacente de C3P0.
 	End If

TestHandler.bas

@@ -22,7 +22,7 @@ Sub Handle(req As ServletRequest, resp As ServletResponse)
 '		Dim con As SQL = Main.rdcConnectorDB1.GetConnection("")
 		Dim con As SQL = Main.Connectors.Get("DB1").As(RDCConnector).GetConnection("")
 		resp.Write("Connection successful.</br></br>")
-		Private estaDB As String = ""
+		Dim estaDB As String = ""
 		Log(Main.listaDeCP)
 		For i = 0 To Main.listaDeCP.Size - 1
 			If Main.listaDeCP.get(i) <> "" Then estaDB = "." & Main.listaDeCP.get(i)

jRDC_Multi.b4j

@@ -32,9 +32,10 @@ Library8=jsql
 Library9=bcrypt
 Module1=Cambios
 Module10=Manager
-Module11=ping
-Module12=RDCConnector
-Module13=TestHandler
+Module11=ParameterValidationUtils
+Module12=ping
+Module13=RDCConnector
+Module14=TestHandler
 Module2=ChangePassHandler
 Module3=DBHandlerB4X
 Module4=DBHandlerJSON
@@ -45,15 +46,16 @@ Module8=LoginHandler
 Module9=LogoutHandler
 NumberOfFiles=10
 NumberOfLibraries=9
-NumberOfModules=13
+NumberOfModules=14
 Version=10.3
 @EndOfDesignText@
 'Non-UI application (console / server application)
 
 #Region Project Attributes
+
 #CommandLineArgs:
 #MergeLibraries: True
-' VERSION 5.09.14
+' VERSION 5.09.16
 '###########################################################################################################
 '###################### PULL #############################################################
 'Ctrl + click ide://run?file=%WINDIR%\System32\cmd.exe&Args=/c&Args=git&Args=pull
@@ -75,99 +77,178 @@ Version=10.3
 
 Sub Process_Globals
 	' --- Variables globales accesibles desde cualquier parte del proyecto ---
-	Public srvr As Server ' El objeto principal del servidor HTTP de B4J.
-	Public const VERSION As Float = 2.23 ' La versión actual de este servidor jRDC modificado.
     
-	' Tipos personalizados para la serialización y deserialización de datos
-	' entre el cliente B4X (DBRequestManager) y el servidor jRDC2.
-	Type DBCommand (Name As String, Parameters() As Object) ' Define un comando SQL.
-	Type DBResult (Tag As Object, Columns As Map, Rows As List) ' Define la estructura de un resultado de consulta.
+	' Objeto principal del servidor HTTP de B4J.
+	Public srvr As Server
     
-	Public listaDeCP As List ' Contiene una lista de los identificadores de bases de datos configuradas (ej. "DB1", "DB2").
-	Private cpFiles As List ' Una lista temporal para almacenar los nombres de archivos encontrados en el directorio.
+	' La versión actual de este servidor jRDC modificado.
+	Public const VERSION As Float = 2.23
+    
+	' Tipos personalizados (clases) para la serialización y deserialización de datos
+	Type DBCommand (Name As String, Parameters() As Object)
+	Type DBResult (Tag As Object, Columns As Map, Rows As List)
+    
+	' Contiene una lista de los identificadores de bases de datos configuradas (ej. "DB1", "DB2").
+	Public listaDeCP As List
+    
+	' Una lista temporal para almacenar los nombres de archivos de configuración encontrados.
+	Private cpFiles As List
     
 	' Mapas globales para gestionar los conectores de base de datos y los comandos SQL.
-	Public Connectors, commandsMap As Map ' Connectors: Almacena las instancias de RDCConnector por DB.
-	' commandsMap: Almacena los comandos SQL cargados para cada DB.
+	Public Connectors, commandsMap As Map
     
-	Public SQL1 As SQL ' Objeto SQL para interactuar con la base de datos de usuarios (SQLite).
-	Private bc As BCrypt ' Objeto para realizar operaciones de hashing de contraseñas de forma segura (para autenticación).
-	Public MainConnectorsLock As JavaObject ' Objeto de bloqueo para proteger Main.Connectors
-	Public ActiveRequestsCountByDB As Map
+	' Objeto SQL para interactuar con la base de datos de usuarios y logs (SQLite).
+	Public SQL1 As SQL
+    
+	' Objeto para realizar operaciones de hashing de contraseñas de forma segura.
+	Private bc As BCrypt
+    
+	' Objeto de bloqueo (ReentrantLock) para proteger Main.Connectors durante Hot-Swap.
+	Public MainConnectorsLock As JavaObject
+    
+	' Timer para ejecutar tareas periódicas, como la limpieza de logs.
+	Public timerLogs As Timer
+    
+	' NUEVAS VARIABLES para control granular de logs
+	' Mapa para almacenar el estado de logging (True/False) por cada DBKey (DB1, DB2, etc.).
+	Public SQLiteLoggingStatusByDB As Map
+	' Bandera global que indica si AL MENOS una base de datos tiene los logs habilitados.
+	Public IsAnySQLiteLoggingEnabled As Boolean
+
+	' Tipo para encapsular el resultado de la validación de parámetros.
+	Type ParameterValidationResult ( _
+        Success As Boolean, _
+        ErrorMessage As String, _
+        ParamsToExecute As List _ ' La lista de parámetros final a usar en la ejecución SQL
+    )
 End Sub
 
 Sub AppStart (Args() As String)
 	' --- Subrutina principal que se ejecuta al iniciar la aplicación ---
-
-	' 1. Inicializa la base de datos local de usuarios (SQLite).
-	' Esta base de datos se crea automáticamente si no existe y contiene los usuarios para el panel de administración.
+    
+	bc.Initialize("BC")
+    
+	' 1. Inicializa la base de datos local de usuarios (SQLite) y la tabla de logs.
 	InitializeSQLiteDatabase
-
+    
 	' 2. Inicializa los mapas globales definidos en GlobalParameters.bas.
-	' Estos mapas se usan para monitorear el servidor y gestionar configuraciones dinámicas.
-	GlobalParameters.mpLogs.Initialize ' Mapa para almacenar logs de actividad.
-	GlobalParameters.mpTotalRequests.Initialize ' Mapa para contar peticiones por endpoint/DB.
-	GlobalParameters.mpTotalConnections.Initialize ' Mapa para almacenar el estado de los pools de conexión por DB.
-	GlobalParameters.mpBlockConnection.Initialize ' Mapa para gestionar IPs bloqueadas (si la funcionalidad está activa).
-	GlobalParameters.ActiveRequestsCountByDB = srvr.CreateThreadSafeMap ' Aseguramos que sea thread-safe para conteo de peticiones activas por DB [___new 3.txt, conversación]
-
-
+	GlobalParameters.mpLogs.Initialize
+	GlobalParameters.mpTotalRequests.Initialize
+	GlobalParameters.mpTotalConnections.Initialize
+	GlobalParameters.mpBlockConnection.Initialize
+    
+	' Aseguramos que el mapa de conteo de peticiones activas sea thread-safe.
+	GlobalParameters.ActiveRequestsCountByDB = srvr.CreateThreadSafeMap
+    
 	' 3. Inicializa las estructuras principales del servidor HTTP.
-	listaDeCP.Initialize ' Inicializa la lista que contendrá los IDs de las bases de datos.
-	srvr.Initialize("") ' Inicializa el objeto servidor HTTP.
-	Connectors = srvr.CreateThreadSafeMap ' Crea un mapa seguro para almacenar instancias de RDCConnector (un conector por DB).
-	commandsMap.Initialize ' Inicializa el mapa que almacenará los comandos SQL cargados de los archivos de configuración.
-
-	' <<<< NUEVA INICIALIZACIÓN: Creamos una instancia de ReentrantLock para proteger Main.Connectors >>>>
+	listaDeCP.Initialize
+	srvr.Initialize("")
+	Connectors = srvr.CreateThreadSafeMap
+	commandsMap.Initialize
+    
+	' NUEVO: Inicializar el mapa de estado de logs granular
+	SQLiteLoggingStatusByDB.Initialize
+    
+	' Creamos una instancia de ReentrantLock para proteger Main.Connectors.
 	MainConnectorsLock.InitializeNewInstance("java.util.concurrent.locks.ReentrantLock", Null)
-	' <<<< HASTA AQUÍ LA NUEVA INICIALIZACIÓN >>>>
-
+    
+    
 	' === 4. INICIALIZACIÓN DEL CONECTOR PARA LA BASE DE DATOS PRINCIPAL (DB1) ===
-	' DB1 siempre usa el archivo 'config.properties' por defecto.
-	Dim con1 As RDCConnector ' Declara una variable específica y única para el conector de DB1.
-	con1.Initialize("DB1") ' Inicializa la instancia del conector para "DB1".
-	Connectors.Put("DB1", con1) ' Asocia el identificador "DB1" con su instancia de RDCConnector.
-	srvr.Port = con1.serverPort ' El puerto del servidor HTTP se obtiene del config.properties de DB1.
-	listaDeCP.Add("DB1") ' Añade "DB1" a la lista de bases de datos gestionadas.]
-	Log($"Main.AppStart: Conector 'DB1' inicializado exitosamente en puerto: ${srvr.Port}"$)
-
+    
+	Try
+		Dim con1 As RDCConnector
+		con1.Initialize("DB1")
+		Connectors.Put("DB1", con1)
+		srvr.Port = con1.serverPort
+		listaDeCP.Add("DB1")
+		Log($"Main.AppStart: Conector 'DB1' inicializado exitosamente en puerto: ${srvr.Port}"$)
+        
+		' Lógica de Logs para DB1 (Fuente principal de configuración)
+		Dim enableLogsSetting As Int = con1.config.GetDefault("enableSQLiteLogs", 1).As(Int)
+		Dim isEnabled As Boolean = (enableLogsSetting = 1)
+		SQLiteLoggingStatusByDB.Put("DB1", isEnabled) ' Guardar el estado
+        
+	Catch
+		Dim ErrorMsg As String = $"Main.AppStart: ERROR CRÍTICO al inicializar conector 'DB1': ${LastException.Message}"$
+		Log(ErrorMsg)
+		LogServerError("ERROR", "Main.AppStart", ErrorMsg, "DB1", Null, Null)
+		ExitApplication
+	End Try
+    
 	' === 5. DETECCIÓN E INICIALIZACIÓN DE BASES DE DATOS ADICIONALES (DB2, DB3, DB4) ===
-	' El servidor busca archivos de configuración adicionales (ej. config.DB2.properties)
-	' en el mismo directorio donde se ejecuta el JAR.
+    
 	cpFiles = File.ListFiles("./")
 	If cpFiles.Size > 0 Then
 		For i = 0 To cpFiles.Size - 1
+
 			' Procesa 'config.DB2.properties'
 			If cpFiles.Get(i) = "config.DB2.properties" Then
-				Dim con2 As RDCConnector ' Declara una variable específica y única para el conector de DB2.
-				con2.Initialize("DB2") ' Inicializa la instancia del conector para "DB2".
-				Connectors.Put("DB2", con2) ' Asocia "DB2" con su instancia de RDCConnector.
-				listaDeCP.Add("DB2") ' Añade "DB2" a la lista de bases de datos.
-				Log("Main.AppStart: Conector 'DB2' inicializado exitosamente.")
+				Try
+					Dim con2 As RDCConnector
+					con2.Initialize("DB2")
+					Connectors.Put("DB2", con2)
+					listaDeCP.Add("DB2")
+					Log("Main.AppStart: Conector 'DB2' inicializado exitosamente.")
+                    
+					' Lógica de Logs para DB2
+					Dim enableLogsSetting As Int = con2.config.GetDefault("enableSQLiteLogs", 0).As(Int)
+					Dim isEnabled As Boolean = (enableLogsSetting = 1)
+					SQLiteLoggingStatusByDB.Put("DB2", isEnabled) ' Guardar el estado
+                    
+				Catch
+					Dim ErrorMsg As String = $"Main.AppStart: ERROR al inicializar conector 'DB2': ${LastException.Message}"$
+					Log(ErrorMsg)
+					LogServerError("ERROR", "Main.AppStart", ErrorMsg, "DB2", Null, Null)
+				End Try
 			End If
 
 			' Procesa 'config.DB3.properties'
 			If cpFiles.Get(i) = "config.DB3.properties" Then
-				Dim con3 As RDCConnector ' Declara una variable específica y única para el conector de DB3.
-				con3.Initialize("DB3") ' Inicializa la instancia del conector para "DB3".
-				Connectors.Put("DB3", con3) ' Asocia "DB3" con su instancia de RDCConnector.
-				listaDeCP.Add("DB3") ' Añade "DB3" a la lista de bases de datos.
-				Log("Main.AppStart: Conector 'DB3' inicializado exitosamente.")
+				Try
+					Dim con3 As RDCConnector
+					con3.Initialize("DB3")
+					Connectors.Put("DB3", con3)
+					listaDeCP.Add("DB3")
+					Log("Main.AppStart: Conector 'DB3' inicializado exitosamente.")
+                    
+					' Lógica de Logs para DB3
+					Dim enableLogsSetting As Int = con3.config.GetDefault("enableSQLiteLogs", 0).As(Int)
+					Dim isEnabled As Boolean = (enableLogsSetting = 1)
+					SQLiteLoggingStatusByDB.Put("DB3", isEnabled) ' Guardar el estado
+                    
+				Catch
+					Dim ErrorMsg As String = $"Main.AppStart: ERROR al inicializar conector 'DB3': ${LastException.Message}"$
+					Log(ErrorMsg)
+					LogServerError("ERROR", "Main.AppStart", ErrorMsg, "DB3", Null, Null)
+				End Try
 			End If
 
 			' Procesa 'config.DB4.properties'
 			If cpFiles.Get(i) = "config.DB4.properties" Then
-				Dim con4 As RDCConnector ' Declara una variable específica y única para el conector de DB4.
-				con4.Initialize("DB4") ' Inicializa la instancia del conector para "DB4".
-				Connectors.Put("DB4", con4) ' Asocia "DB4" con su instancia de RDCConnector.
-				listaDeCP.Add("DB4") ' Añade "DB4" a la lista de bases de datos.
-				Log("Main.AppStart: Conector 'DB4' inicializado exitosamente.")
+				Try
+					Dim con4 As RDCConnector
+					con4.Initialize("DB4")
+					Connectors.Put("DB4", con4)
+					listaDeCP.Add("DB4")
+					Log("Main.AppStart: Conector 'DB4' inicializado exitosamente.")
+                    
+					' Lógica de Logs para DB4
+					Dim enableLogsSetting As Int = con4.config.GetDefault("enableSQLiteLogs", 0).As(Int)
+					Dim isEnabled As Boolean = (enableLogsSetting = 1)
+					SQLiteLoggingStatusByDB.Put("DB4", isEnabled) ' Guardar el estado
+                    
+				Catch
+					Dim ErrorMsg As String = $"Main.AppStart: ERROR al inicializar conector 'DB4': ${LastException.Message}"$
+					Log(ErrorMsg)
+					LogServerError("ERROR", "Main.AppStart", ErrorMsg, "DB4", Null, Null)
+				End Try
 			End If
+
 		Next
 	Else
 		Log("Main.AppStart: No se encontraron archivos de configuración adicionales (config.DBx.properties).")
 	End If
-
+    
 	' Log final de las bases de datos que el servidor está gestionando.
 	Dim sbListaDeCP_Log As StringBuilder
 	sbListaDeCP_Log.Initialize
@@ -175,26 +256,46 @@ Sub AppStart (Args() As String)
 		sbListaDeCP_Log.Append(item).Append(", ")
 	Next
 	If sbListaDeCP_Log.Length > 0 Then
-		sbListaDeCP_Log.Remove(sbListaDeCP_Log.Length - 2, sbListaDeCP_Log.Length) ' Elimina la última ", "
+		sbListaDeCP_Log.Remove(sbListaDeCP_Log.Length - 2, sbListaDeCP_Log.Length)
 	End If
 	Log($"Main.AppStart: Bases de datos configuradas y listas: [${sbListaDeCP_Log.ToString}]"$)
 
+	' <<<< Bloque de inicialización del Timer para la limpieza de logs >>>>
+    
+	' Inicialización INCONDICIONAL del Timer (Garantiza que el objeto exista y prevenga el IllegalStateException)
+	timerLogs.Initialize("TimerLogs", 600000) ' 10 minutos = 600 * 1000 = 600000 ms
+    
+	' CONTROL CONDICIONAL BASADO EN EL ESTADO GRANULAR
+	IsAnySQLiteLoggingEnabled = False
+	For Each dbStatus As Boolean In SQLiteLoggingStatusByDB.Values
+		If dbStatus Then
+			IsAnySQLiteLoggingEnabled = True
+			Exit ' Si uno está activo, es suficiente para encender el Timer
+		End If
+	Next
+    
+	If IsAnySQLiteLoggingEnabled Then
+		timerLogs.Enabled = True
+		Log("Main.AppStart: Timer de limpieza de logs ACTIVADO (al menos una DB requiere logs).")
+	Else
+		timerLogs.Enabled = False
+		Log("Main.AppStart: Timer de limpieza de logs DESHABILITADO (ninguna DB requiere logs).")
+	End If
+    
+	' <<<< Fin del bloque del Timer >>>>
+
 	' === 6. REGISTRO DE HANDLERS HTTP PARA EL SERVIDOR ===
-	' Asocia rutas URL específicas con clases que manejarán las peticiones correspondientes.
-	' El último parámetro (True) indica que el handler se ejecutará en un nuevo hilo,
-	' lo que es recomendable para la mayoría de los casos para evitar bloqueos.
-	srvr.AddHandler("/ping", "ping", True) ' Endpoint simple para verificar si el servidor está activo.
-	srvr.AddHandler("/test", "TestHandler", True) ' Endpoint para pruebas de conexión y estado del servidor.
-	srvr.AddHandler("/login", "LoginHandler", True) ' Muestra la página HTML de login.
-	srvr.AddHandler("/dologin", "DoLoginHandler", True) ' Procesa el intento de inicio de sesión.
-	srvr.AddHandler("/logout", "LogoutHandler", True) ' Cierra la sesión del usuario.
-	srvr.AddHandler("/changepass", "ChangePassHandler", True) ' Permite a los usuarios cambiar su contraseña.
-	srvr.AddHandler("/manager", "Manager", True) ' Panel de administración del servidor (requiere autenticación).
-	srvr.AddHandler("/DBJ", "DBHandlerJSON", False) ' Handler para clientes web (ej. JavaScript, Node.js) que usan JSON.
-	srvr.AddHandler("/dbrquery", "DBHandlerJSON", False) ' Un alias para el handler JSON, por si se usa en clientes específicos.
-	srvr.AddHandler("/favicon.ico", "faviconHandler", True) ' Sirve el icono de la página (favicon).
-	srvr.AddHandler("/*", "DBHandlerB4X", False) ' Handler por defecto para clientes B4X (DBRequestManager),
-	' procesa peticiones dinámicamente según la URL.
+	srvr.AddHandler("/ping", "ping", False)
+	srvr.AddHandler("/test", "TestHandler", False)
+	srvr.AddHandler("/login", "LoginHandler", False)
+	srvr.AddHandler("/dologin", "DoLoginHandler", False)
+	srvr.AddHandler("/logout", "LogoutHandler", False)
+	srvr.AddHandler("/changepass", "ChangePassHandler", False)
+	srvr.AddHandler("/manager", "Manager", False)
+	srvr.AddHandler("/DBJ", "DBHandlerJSON", False)
+	srvr.AddHandler("/dbrquery", "DBHandlerJSON", False)
+	srvr.AddHandler("/favicon.ico", "faviconHandler", False)
+	srvr.AddHandler("/*", "DBHandlerB4X", False)
 
 	' 7. Inicia el servidor HTTP.
 	srvr.Start
@@ -202,71 +303,73 @@ Sub AppStart (Args() As String)
 	Log($"-=== jRDC está funcionando en el puerto: ${srvr.Port} (versión = $1.2{VERSION}) ===-"$)
 	Log("===========================================================")
 
-	' 8. Inicia el bucle de mensajes de B4J. Es esencial para que la aplicación
-	' de servidor continúe ejecutándose y procesando eventos.
+	' 8. Inicia el bucle de mensajes de B4J.
 	StartMessageLoop
 End Sub
 
 ' --- Subrutina para inicializar la base de datos de usuarios local (SQLite) ---
-' Esta base de datos se utiliza para almacenar credenciales de usuarios que pueden
-' acceder al panel de administración del servidor jRDC y los logs de queries.
-Sub InitializeSQLiteDatabase
-	Dim dbFileName As String = "users.db" ' Nombre del archivo de la base de datos SQLite.
 
-	' Verifica si el archivo de la base de datos ya existe en el directorio de la aplicación.
+Sub InitializeSQLiteDatabase
+	Dim dbFileName As String = "users.db"
+    
 	If File.Exists(File.DirApp, dbFileName) = False Then
 		Log("Creando nueva base de datos de usuarios: " & dbFileName)
-		' Inicializa la conexión a la base de datos SQLite, creándola si no existe (último parámetro en True).
 		SQL1.InitializeSQLite(File.DirApp, dbFileName, True)
-
-		' Define y ejecuta la sentencia SQL para crear la tabla 'users'.
+        
+		' Crear tabla 'users'
 		Dim createUserTable As String = "CREATE TABLE users (username TEXT PRIMARY KEY, password_hash TEXT NOT NULL)"
 		SQL1.ExecNonQuery(createUserTable)
-
-		' >>> INICIO: Creación de la tabla query_logs con las nuevas columnas desde CERO <<<
+        
+		' Crear tabla 'query_logs'
 		Log("Creando tabla 'query_logs' con columnas de rendimiento.")
 		Dim createQueryLogsTable As String = "CREATE TABLE query_logs (id INTEGER PRIMARY KEY AUTOINCREMENT, query_name TEXT, duration_ms INTEGER, timestamp INTEGER, db_key TEXT, client_ip TEXT, busy_connections INTEGER, handler_active_requests INTEGER)"
 		SQL1.ExecNonQuery(createQueryLogsTable)
-		' >>> FIN: Creación de la tabla query_logs <<<
-
-		' Crea un usuario por defecto para facilitar el primer acceso al panel de administración.
+        
+		' Insertar usuario por defecto
 		Dim defaultUser As String = "admin"
 		Dim defaultPass As String = "12345"
-		' Genera un hash seguro de la contraseña usando BCrypt, lo cual es crucial para la seguridad.
 		Dim hashedPass As String = bc.hashpw(defaultPass, bc.gensalt)
-		' Inserta el usuario por defecto en la tabla 'users'.
 		SQL1.ExecNonQuery2("INSERT INTO users (username, password_hash) VALUES (?, ?)", Array As Object(defaultUser, hashedPass))
 		Log($"Usuario por defecto creado -> user: ${defaultUser}, pass: ${defaultPass}"$)
+        
+		' Crear tabla 'errores'
+		Log("Creando tabla 'errores' para registrar eventos.")
+		Dim createErrorsTable As String = "CREATE TABLE errores (id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, type TEXT, source TEXT, message TEXT, db_key TEXT, command_name TEXT, client_ip TEXT)"
+		SQL1.ExecNonQuery(createErrorsTable)
+
 	Else
-		' Si el archivo de la base de datos ya existe, simplemente se abre.
 		SQL1.InitializeSQLite(File.DirApp, dbFileName, True)
 		Log("Base de datos de usuarios cargada.")
-
+        
 		' >>> INICIO: Lógica de migración (ALTER TABLE) si la DB ya existía <<<
 		Log("Verificando y migrando tabla 'query_logs' si es necesario.")
-        
-		' Primero, verificar si la tabla query_logs existe.
+
 		If SQL1.ExecQuerySingleResult("SELECT name FROM sqlite_master WHERE type='table' AND name='query_logs'") = Null Then
+
 			Log("Tabla 'query_logs' no encontrada, creándola con columnas de rendimiento.")
+
 			Dim createQueryLogsTable As String = "CREATE TABLE query_logs (id INTEGER PRIMARY KEY AUTOINCREMENT, query_name TEXT, duration_ms INTEGER, timestamp INTEGER, db_key TEXT, client_ip TEXT, busy_connections INTEGER, handler_active_requests INTEGER)"
+
 			SQL1.ExecNonQuery(createQueryLogsTable)
+
 		Else
-			' Si la tabla query_logs ya existe, entonces verificamos y añadimos las columnas faltantes.
+
+			' Si la tabla query_logs ya existe, entonces verificamos y añadimos las columnas faltantes (busy_connections, handler_active_requests).
 			Dim columnExists As Boolean
 			Dim rs As ResultSet
-            
+
 			' --- VERIFICAR Y AÑADIR busy_connections ---
 			columnExists = False
-			' Ejecutamos PRAGMA sin WHERE y lo filtramos en código.
 			rs = SQL1.ExecQuery("PRAGMA table_info(query_logs)")
+
 			Do While rs.NextRow
 				If rs.GetString("name").EqualsIgnoreCase("busy_connections") Then
 					columnExists = True
 					Exit ' La columna ya existe, salimos del bucle.
 				End If
 			Loop
-			rs.Close ' ¡Importante cerrar el ResultSet!
-
+			rs.Close
+            
 			If columnExists = False Then
 				Log("Añadiendo columna 'busy_connections' a query_logs.")
 				SQL1.ExecNonQuery("ALTER TABLE query_logs ADD COLUMN busy_connections INTEGER DEFAULT 0")
@@ -274,44 +377,96 @@ Sub InitializeSQLiteDatabase
 
 			' --- VERIFICAR Y AÑADIR handler_active_requests ---
 			columnExists = False
-			rs = SQL1.ExecQuery("PRAGMA table_info(query_logs)") ' Ejecutamos PRAGMA nuevamente para esta columna.
+			rs = SQL1.ExecQuery("PRAGMA table_info(query_logs)")
+
 			Do While rs.NextRow
 				If rs.GetString("name").EqualsIgnoreCase("handler_active_requests") Then
 					columnExists = True
 					Exit ' La columna ya existe, salimos del bucle.
 				End If
 			Loop
-			rs.Close ' ¡Importante cerrar el ResultSet!
-
+			rs.Close
+            
 			If columnExists = False Then
 				Log("Añadiendo columna 'handler_active_requests' a query_logs.")
 				SQL1.ExecNonQuery("ALTER TABLE query_logs ADD COLUMN handler_active_requests INTEGER DEFAULT 0")
 			End If
+
+
+			' >>> INICIO: Lógica de migración para 'errores' si la DB ya existía <<<
+			Log("Verificando y migrando tabla 'errores' si es necesario.")
+            
+			If SQL1.ExecQuerySingleResult("SELECT name FROM sqlite_master WHERE type='table' AND name='errores'") = Null Then
+				Log("Tabla 'errores' no encontrada, creándola.")
+				Dim createErrorsTable As String = "CREATE TABLE errores (id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, type TEXT, source TEXT, message TEXT, db_key TEXT, command_name TEXT, client_ip TEXT)"
+				SQL1.ExecNonQuery(createErrorsTable)
+			Else
+				Log("Tabla 'errores' ya existe.")
+			End If
+			' >>> FIN: Lógica de migración para 'errores' <<<
+
 		End If
 		' >>> FIN: Lógica de migración (ALTER TABLE) <<<
+        
 	End If
 End Sub
 
-' Subrutina para registrar las métricas de rendimiento de las queries
+' --- Subrutina para registrar las métricas de rendimiento de las queries en la tabla 'query_logs'. ---
+' ¡MODIFICADA PARA USAR FILTRADO GRANULAR POR DBKEY!
 Public Sub LogQueryPerformance(QueryName As String, DurationMs As Long, DbKey As String, ClientIp As String, HandlerActiveRequests As Int, PoolBusyConnections As Int)
-	Try
-		' El valor PoolBusyConnections ya se recibe directamente del handler.
-		' Removemos la lógica anterior de obtenerlo del conector.
-		' Dim connector As RDCConnector = Main.Connectors.Get(DbKey).As(RDCConnector)
-		' Dim poolBusyConnections As Int = 0
-		' If connector.IsInitialized Then
-		'     Dim poolStats As Map = connector.GetPoolStats
-		'     If poolStats.ContainsKey("BusyConnections") Then
-		'         poolBusyConnections = poolStats.Get("BusyConnections")
-		'     End If
-		' Else
-		'     Log($"ADVERTENCIA: Conector RDC para ${DbKey} no inicializado al intentar loguear rendimiento."$)
-		' End If
+    
+	' Obtener el estado de logging para esta DBKey. Usar False si la DBKey no existe en el mapa.
+	Dim isEnabled As Boolean = SQLiteLoggingStatusByDB.GetDefault(DbKey, False)
+    
+	If isEnabled Then
+		Try
+			SQL1.ExecNonQuery2("INSERT INTO query_logs (query_name, duration_ms, timestamp, db_key, client_ip, busy_connections, handler_active_requests) VALUES (?, ?, ?, ?, ?, ?, ?)", _
+                Array As Object(QueryName, DurationMs, DateTime.Now, DbKey, ClientIp, PoolBusyConnections, HandlerActiveRequests))
+		Catch
+			Log("Error al guardar log de query en SQLite (Main.LogQueryPerformance): " & LastException.Message)
+		End Try
+	End If
+End Sub
 
-		' Insertamos los datos en la tabla query_logs de SQLite
-		SQL1.ExecNonQuery2("INSERT INTO query_logs (query_name, duration_ms, timestamp, db_key, client_ip, busy_connections, handler_active_requests) VALUES (?, ?, ?, ?, ?, ?, ?)", _
-            Array As Object(QueryName, DurationMs, DateTime.Now, DbKey, ClientIp, PoolBusyConnections, HandlerActiveRequests))
+' --- Subrutina para registrar errores y advertencias en la tabla 'errores'. ---
+' ¡MODIFICADA PARA USAR FILTRADO GRANULAR POR DBKEY!
+Public Sub LogServerError(Type0 As String, Source As String, Message As String, DBKey As String, CommandName As String, ClientIp As String)
+    
+	' Obtener el estado de logging para esta DBKey. Usar False si la DBKey es Null o no está en el mapa.
+	Dim isEnabled As Boolean = SQLiteLoggingStatusByDB.GetDefault(DBKey, False)
+
+	If isEnabled Then
+		Try
+			SQL1.ExecNonQuery2("INSERT INTO errores (timestamp, type, source, message, db_key, command_name, client_ip) VALUES (?, ?, ?, ?, ?, ?, ?)", _
+                Array As Object(DateTime.Now, Type0, Source, Message, DBKey, CommandName, ClientIp))
+		Catch
+			Log("ERROR CRÍTICO: Fallo al guardar el log de error/advertencia en SQLite (Main.LogServerError): " & LastException.Message)
+		End Try
+	End If
+End Sub
+
+' --- Subrutina de evento para el Timer 'timerLogs'. ---
+' El estado 'Enabled' del Timer ya está controlado por IsAnySQLiteLoggingEnabled en AppStart y Manager.
+Sub TimerLogs_Tick
+	Try
+		borraArribaDe15000Logs
 	Catch
-		Log("Error al guardar log de query en SQLite (Main.LogQueryPerformance): " & LastException.Message)
+		Dim ErrorMsg As String = "ERROR en TimerLogs_Tick al intentar borrar logs: " & LastException.Message
+		Log(ErrorMsg)
+		LogServerError("ERROR", "Main.TimerLogs_Tick", ErrorMsg, Null, "log_cleanup", Null)
 	End Try
+End Sub
+
+' --- Borra los registros más antiguos de la tabla 'query_logs' y hace VACUUM. ---
+' ¡MODIFICADA PARA USAR FILTRADO GLOBAL!
+Sub borraArribaDe15000Logs 'ignore
+    
+	If IsAnySQLiteLoggingEnabled Then ' Solo ejecutar si al menos una DB requiere logs.
+		Log("Recortando la tabla de 'query_logs', límite de 15,000 registros.")
+		SQL1.ExecNonQuery("DELETE FROM query_logs WHERE timestamp NOT in (SELECT timestamp FROM query_logs ORDER BY timestamp desc LIMIT 15000 )")
+		SQL1.ExecNonQuery("vacuum;")
+	Else
+		' Si IsAnySQLiteLoggingEnabled es False, el Timer no debería estar activo.
+		Log("AVISO: Tarea de limpieza de logs omitida. El logging global de SQLite está deshabilitado.")
+	End If
 End Sub

jRDC_Multi.b4j.meta

@@ -4,6 +4,7 @@ ModuleBookmarks10=
 ModuleBookmarks11=
 ModuleBookmarks12=
 ModuleBookmarks13=
+ModuleBookmarks14=
 ModuleBookmarks2=
 ModuleBookmarks3=
 ModuleBookmarks4=
@@ -18,6 +19,7 @@ ModuleBreakpoints10=
 ModuleBreakpoints11=
 ModuleBreakpoints12=
 ModuleBreakpoints13=
+ModuleBreakpoints14=
 ModuleBreakpoints2=
 ModuleBreakpoints3=
 ModuleBreakpoints4=
@@ -32,14 +34,15 @@ ModuleClosedNodes10=
 ModuleClosedNodes11=
 ModuleClosedNodes12=
 ModuleClosedNodes13=
+ModuleClosedNodes14=
 ModuleClosedNodes2=
-ModuleClosedNodes3=
+ModuleClosedNodes3=9,10,11,12,13,14,15,16
 ModuleClosedNodes4=
 ModuleClosedNodes5=
 ModuleClosedNodes6=
 ModuleClosedNodes7=
 ModuleClosedNodes8=
 ModuleClosedNodes9=
-NavigationStack=RDCConnector,GetCommand,164,0,RDCConnector,GetConnection,187,0,RDCConnector,GetPoolStats,273,0,RDCConnector,Close,283,0,DBHandlerJSON,Handle,94,5,DBHandlerJSON,CleanupAndLog,200,6,DBHandlerJSON,Initialize,10,0,DBHandlerJSON,Class_Globals,6,0,Cambios,Process_Globals,25,3,Main,AppStart,152,1
+NavigationStack=DBHandlerB4X,CleanupAndLog,198,0,DBHandlerJSON,CleanupAndLog,223,0,ParameterValidationUtils,ValidateAndAdjustParameters,45,0,Main,Process_Globals,53,0,Main,AppStart,186,0,Main,LogQueryPerformance,367,0,Main,LogServerError,384,6,Manager,Handle,164,6,Main,borraArribaDe15000Logs,412,0,Cambios,Process_Globals,25,6
 SelectedBuild=0
-VisibleModules=3,4,12,1,7,2,5
+VisibleModules=3,4,13,1,10,11,14,2