Update documentation: added dashboard module, memory context for IA, and preparation for further sync_mysql_remote improvements

Author: JoseLVillaronga

README.md

@@ -0,0 +1,89 @@
+# MySQL-Admin Project
+
+## Descripción del Proyecto
+
+El proyecto **MySQL-Admin** es una solución integral destinada a la administración, sincronización y migración de bases de datos MySQL. La arquitectura del sistema está diseñada para soportar múltiples flujos de datos:
+
+- **Sincronización de bases de datos MySQL remotas a locales**: A través del script `sync_mysql_remote.py`, en fase de pruebas, se replican datos de bases MySQL remotas al entorno local para facilitar pruebas y migraciones iniciales.
+
+- **Monitoreo en producción**: El script `mysql_monitor.py` se ejecuta en producción generando registros cada minuto para realizar análisis en tiempo real, detectar anomalías y mantener la salud de la base de datos.
+
+- **Migración y sincronización hacia MongoDB**: Con `sync_mysql_mongo.py`, se permite la migración automática de una o varias bases de datos MySQL a MongoDB. Además, está diseñado para ejecutarse de forma iterativa, de modo que la base de datos sincronizada en MongoDB pueda servir, en futuras iteraciones, como fuente para sincronizar otra base MySQL remota y así desacoplar el motor MySQL local de tareas adicionales.
+
+## Arquitectura y Flujo de Datos
+
+El proyecto sigue una arquitectura modular que permite separar los roles y responsabilidades de cada componente:
+
+1. **Sincronización Local y Remota**: Replicar tablas de bases de datos MySQL de un entorno remoto al local.
+2. **Monitoreo Continuo**: Recolección de datos y generación de logs periódicos para análisis y alertas.
+3. **Migración a MongoDB**: Consolidar datos de MySQL en MongoDB, ofreciendo flexibilidad y escalabilidad en el manejo de datos, con la posibilidad de servir como puente para sincronizaciones posteriores.
+
+## Módulos del Proyecto
+
+### Módulos Terminados y en Producción
+
+- **`mysql_monitor.py`**: En ejecución en producción. Este módulo genera registros (logs) una vez por minuto para monitorizar el estado y rendimiento de la base de datos MySQL local.
+- **`sync_mysql_mongo.py`**: Funciona correctamente según lo esperado. Inicialmente permite la migración automática de bases de datos MySQL a MongoDB. Además, su diseño iterativo posibilita, en futuras versiones, que la base sincronizada en MongoDB se utilice para sincronizar otra base MySQL remota, permitiendo un desacople del motor MySQL local.
+- **`mongo_analytics.py`**: En producción. Se encarga del análisis y procesamiento de datos provenientes de MongoDB para generar reportes y métricas adicionales.
+- **`monitor_cron.py`**: En producción. Este script se ejecuta periódicamente para almacenar métricas en MongoDB y garantizar la supervisión continua de los datos.
+- **`dashboard.py`**: En producción. Proporciona un dashboard interactivo accesible vía navegador, visualizando métricas de MySQL (uso de CPU, uso de memoria y transacciones) en tiempo real con gráficos interactivos y responsive. Permite seleccionar múltiples intervalos de tiempo para el análisis.
+
+> **Nota para IA:** Los módulos mencionados arriba están terminados y en funcionamiento. No se deben realizar modificaciones sobre estos módulos a menos que exista una autorización y acuerdo explícito por parte del desarrollador humano.
+
+### Módulos en Fase de Prueba
+
+- **`sync_mysql_remote.py`**: Actualmente en fase de prueba, se encarga de sincronizar bases de datos MySQL de un entorno remoto al local. Este módulo es utilizado para validar la replicación y sirve como base para migraciones iniciales o pruebas de concepto.
+
+## Configuración
+
+1. **Variables de Entorno**: El proyecto utiliza un archivo `.env` para gestionar parámetros críticos de conexión, tales como:
+   - Para conexiones remotas: `DBR_HOST`, `DBR_PORT`, `DBR_USERNAME`, `DBR_PASSWORD`.
+   - Para conexiones locales: `DB_HOST`, `DB_PORT`, `DB_USERNAME`, `DB_PASSWORD`.
+   - Listado de bases de datos a sincronizar: `MYSQL_DATABASES` (una lista separada por comas).
+
+2. **Instalación de Dependencias**: Asegúrate de tener instaladas las librerías requeridas (por ejemplo, `mysql-connector-python` y `python-dotenv`). Puedes instalarlas utilizando:
+
+```bash
+pip install mysql-connector-python python-dotenv
+```
+
+## Uso
+
+- **Pruebas de Sincronización:** Ejecuta `sync_mysql_remote.py` para validar la sincronización entre bases de datos MySQL remotas y locales.
+- **Monitoreo en Producción:** El script `mysql_monitor.py` se ejecuta de manera continua para generar logs y vigilar el estado de la base de datos local.
+- **Migración a MongoDB:** Utiliza `sync_mysql_mongo.py` para migrar y mantener sincronizadas las bases de datos MySQL con su contraparte en MongoDB.
+
+## Consideraciones Generales
+
+- **Seguridad:** La construcción dinámica de consultas SQL requiere especial atención para evitar inyección SQL. Se asume que las variables de entorno están gestionadas de forma segura.
+
+- **Integridad de Datos:** Durante la sincronización, se deshabilitan temporalmente las restricciones de claves foráneas para permitir el truncado de tablas. Se recomienda evaluar la restauración de estas restricciones post-sincronización si es necesaria para garantizar la integridad referencial.
+
+- **Colaboración IA-Humano:** Este documento está pensado para servir tanto de guía para desarrolladores humanos como de referencia para sistemas IA. Las decisiones técnicas, metodológicas y el historial de cambios se documentan aquí para facilitar la colaboración continua y conservar la memoria de los procesos del proyecto.
+
+## Memoria y Contexto para IA
+
+Esta sección está destinada exclusivamente para el uso interno de la IA y como mecanismo de apoyo para reconstruir la memoria contextual del proyecto en futuras sesiones. Se recomienda que, en cualquier interacción, la IA utilice la información contenida en este README.md junto con las MEMORIES previas para mantener una perspectiva integral del proyecto.
+
+- **Arquitectura General:** El proyecto integra sincronización de datos entre MySQL y MongoDB, así como monitoreo en tiempo real de las bases de datos. 
+- **Módulos Clave:** 
+   - `sync_mysql_remote.py`: Sincronización de bases MySQL remotas a locales (en fase de prueba).
+   - `mysql_monitor.py`: Monitoreo en producción, generando logs cada minuto.
+   - `sync_mysql_mongo.py`: Migración y sincronización de datos desde MySQL hacia MongoDB, con posibles usos futuros para desacoplar procesos.
+   - `mongo_analytics.py`: Análisis y procesamiento de datos provenientes de MongoDB en producción.
+   - `monitor_cron.py`: Ejecución periódica para almacenar métricas en MongoDB y garantizar la supervisión continua.
+   - `dashboard.py`: Proporciona un dashboard interactivo para visualizar métricas de MySQL en tiempo real.
+
+- **Decisiones Técnicas:** Las variables de entorno y la modularidad en los scripts permiten un manejo flexible y seguro de las conexiones a bases de datos, asegurando la integridad de los datos durante la migración y sincronización.
+
+- **Directrices para Colaboración IA-Humano:** Los módulos que se encuentran en producción no deben ser modificados sin autorización explícita del desarrollador humano. El documento README.md, junto con las MEMORIES, sirve para conservar la historia de decisiones y facilitar el trabajo colaborativo.
+
+## Próximos Pasos
+
+- Revisión de los parámetros de sincronización y migración.
+- Experimentación controlada para desacoplar el motor MySQL local utilizando la base consolidada en MongoDB.
+- Incrementar pruebas y validaciones en el módulo `sync_mysql_remote.py` antes de avanzar a producción.
+
+---
+
+*Documentación dual para procesos institucionales y colaboración entre IA y desarrollador humano.*

__pycache__/mysql_monitor.cpython-312.pyc

@@ -0,0 +1,54 @@
+import os
+import sys
+import datetime
+from pymongo import MongoClient
+from dotenv import load_dotenv
+
+# Cargar variables de entorno
+load_dotenv()
+
+
+def get_db_connection():
+    """
+    Establece la conexión a la base de datos MongoDB utilizando las credenciales del entorno.
+    """
+    mongo_uri = f"mongodb://{os.getenv('MONGO_USERNAME')}:{os.getenv('MONGO_PASSWORD')}@{os.getenv('MONGO_HOST')}:27017/"
+    try:
+        client = MongoClient(mongo_uri)
+        db = client['mysql_monitor']
+        return db
+    except Exception as e:
+        sys.exit(f"Error al conectar a MongoDB: {e}")
+
+
+def analyze_metrics(limit=10):
+    """
+    Recupera y muestra las métricas más recientes almacenadas en la colección 'metrics' de la base 'mysql_monitor'.
+    
+    Parámetros:
+    - limit: Número máximo de documentos a recuperar (por defecto 10).
+    """
+    db = get_db_connection()
+    collection = db['metrics']
+
+    # Recuperar los documentos de métricas ordenados de forma descendente por timestamp
+    try:
+        docs = list(collection.find().sort("timestamp", -1).limit(limit))
+    except Exception as e:
+        sys.exit(f"Error al obtener métricas: {e}")
+
+    if not docs:
+        print("No se encontraron métricas en la base de datos.")
+        return
+
+    print(f"Mostrando las {len(docs)} métricas más recientes:\n")
+    for doc in docs:
+        ts = datetime.datetime.fromtimestamp(doc.get("timestamp", 0), datetime.timezone.utc)
+        # Excluimos el _id para una salida más limpia
+        metrics_info = { key: value for key, value in doc.items() if key != '_id' }
+        print(f"Timestamp: {ts.isoformat()}\nMétricas: {metrics_info}\n{'-'*40}")
+
+
+if __name__ == "__main__":
+    # Se puede extender con argumentos de línea de comando para análisis más avanzados
+    analyze_metrics()

analyze_metrics.py

@@ -0,0 +1,104 @@
+import os
+import datetime
+from flask import Flask, request
+from pymongo import MongoClient
+import plotly.graph_objs as go
+import plotly.offline as opy
+from dotenv import load_dotenv
+
+# Cargar variables de entorno
+deprecated_load = load_dotenv()
+
+app = Flask(__name__)
+
+
+def get_db_connection():
+    """Establece la conexión a la base de datos MongoDB usando las credenciales del entorno."""
+    mongo_uri = f"mongodb://{os.getenv('MONGO_USERNAME')}:{os.getenv('MONGO_PASSWORD')}@{os.getenv('MONGO_HOST')}:27017/"
+    client = MongoClient(mongo_uri)
+    db = client['mysql_monitor']
+    return db
+
+
+@app.route('/')
+def index():
+    # Obtener el intervalo deseado a través de parámetros de URL; por defecto 1h
+    interval = request.args.get('interval', '1h')
+    now = datetime.datetime.now(datetime.timezone.utc)
+    
+    # Determinar el tiempo de inicio en función del intervalo
+    if interval == '1h':
+        start_time = now - datetime.timedelta(hours=1)
+    elif interval == '6h':
+        start_time = now - datetime.timedelta(hours=6)
+    elif interval == '24h':
+        start_time = now - datetime.timedelta(hours=24)
+    elif interval == '30d':
+        start_time = now - datetime.timedelta(days=30)
+    else:
+        start_time = now - datetime.timedelta(hours=1)
+
+    start_ts = start_time.timestamp()
+    
+    # Conexión a la base de datos y recuperación de métricas
+    db = get_db_connection()
+    collection = db['metrics']
+    data = list(collection.find({"timestamp": {"$gte": start_ts}}).sort("timestamp", 1))
+    
+    if not data:
+        return f"No se encontraron métricas para el intervalo {interval}" 
+
+    # Extraer datos
+    times = [datetime.datetime.fromtimestamp(doc['timestamp'], datetime.timezone.utc) for doc in data]
+    cpu = [doc.get("mysql_cpu_usage_percent", 0) for doc in data]
+    memory = [doc.get("mysql_memory_used_bytes", 0) for doc in data]
+    # Utilizar el campo 'Questions' para calcular las transacciones
+    questions = [doc.get("Questions", 0) for doc in data]
+
+    # Calcular transacciones por intervalo (diferencia entre registros consecutivos)
+    transactions = [0]  # primer registro no tiene comparación
+    for i in range(1, len(questions)):
+        transactions.append(questions[i] - questions[i - 1])
+
+    # Crear trazas para cada métrica
+    trace_cpu = go.Scatter(x=times, y=cpu, mode='lines+markers', name='CPU Usage (%)')
+    trace_memory = go.Scatter(x=times, y=memory, mode='lines+markers', name='Memory Used (Bytes)')
+    trace_transactions = go.Scatter(x=times, y=transactions, mode='lines+markers', name='Transactions per Interval')
+
+    layout = go.Layout(
+        title=f'Métricas de MySQL - Intervalo {interval}',
+        xaxis=dict(title='Tiempo'),
+        yaxis=dict(title='Valores'),
+        hovermode='closest'
+    )
+
+    fig = go.Figure(data=[trace_cpu, trace_memory, trace_transactions], layout=layout)
+    graph_div = opy.plot(fig, auto_open=False, output_type='div')
+
+    # HTML simple con instrucciones y el gráfico interactivo
+    html = f"""
+    <html>
+        <head>
+            <title>Dashboard MySQL Monitor</title>
+            <meta name='viewport' content='width=device-width, initial-scale=1'>
+        </head>
+        <body>
+            <h1>Dashboard MySQL Monitor</h1>
+            <p>Intervalo de datos: {interval}</p>
+            {graph_div}
+            <p>Usa el parámetro <code>interval</code> en la URL para cambiar el rango de datos. Ejemplos:</p>
+            <ul>
+                <li><a href='/?interval=1h'>Última hora</a></li>
+                <li><a href='/?interval=6h'>Últimas 6 horas</a></li>
+                <li><a href='/?interval=24h'>Último día</a></li>
+                <li><a href='/?interval=30d'>Último mes</a></li>
+            </ul>
+        </body>
+    </html>
+    """
+    return html
+
+
+if __name__ == '__main__':
+    # Ejecutar la aplicación en modo debug y en el puerto 5000
+    app.run(debug=True, host='0.0.0.0', port=5306)

dashboard.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+import os
+import sys
+import json
+from dotenv import load_dotenv
+from pymongo import MongoClient
+
+# Cargar variables de entorno
+load_dotenv()
+
+def generate_report(mongo_uri, exclude_db="sync_status"):
+    """
+    Conecta a MongoDB y genera un reporte con estadísticas básicas de cada base de datos
+    (excepto la base de sincronización 'sync_status'). Para cada base de datos se listan las
+    colecciones y se reporta, por ejemplo, la cantidad de documentos.
+    """
+    client = MongoClient(mongo_uri)
+    report = {}
+
+    # Obtener la lista de bases de datos
+    databases = client.list_database_names()
+    # Excluir la base usada para almacenar el estado de sincronización
+    databases = [db for db in databases if db != exclude_db]
+
+    for db_name in databases:
+        db = client[db_name]
+        collections = db.list_collection_names()
+        db_report = {}
+        for coll in collections:
+            # Usamos estimated_document_count para obtener un conteo rápido
+            count = db[coll].estimated_document_count()
+            db_report[coll] = {
+                "record_count": count
+                # Aquí podrías agregar otros parámetros, por ejemplo,
+                # última fecha de actualización si la incluyeras en los documentos,
+                # tamaño de la colección, etc.
+            }
+        report[db_name] = db_report
+
+    return report
+
+def main():
+    # Construir la URI de MongoDB a partir de las variables de entorno
+    mongo_uri = f"mongodb://{os.getenv('MONGO_USERNAME')}:{os.getenv('MONGO_PASSWORD')}@{os.getenv('MONGO_HOST')}:27017/"
+    
+    report = generate_report(mongo_uri)
+    # Imprimir el reporte en formato JSON para facilitar su lectura o procesamiento
+    print(json.dumps(report, indent=4))
+
+if __name__ == "__main__":
+    main()

mongo_analytics.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+import os
+from dotenv import load_dotenv
+import sys
+import datetime
+import json
+
+# Cargar variables de entorno
+load_dotenv()
+
+# Se asume que ya tienes la función get_mysql_metrics definida en mysql_monitor.py,
+# la cual obtiene las métricas de MySQL y las devuelve como diccionario.
+try:
+    from mysql_monitor import get_mysql_metrics
+except ImportError:
+    sys.exit("No se encontró el módulo mysql_monitor. Asegúrate de tenerlo en tu PYTHONPATH.")
+
+# Intentamos importar pymongo y, si no está instalado, lo instalamos automáticamente.
+try:
+    from pymongo import MongoClient
+except ImportError:
+    import subprocess
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "pymongo"])
+    from pymongo import MongoClient
+
+def store_metrics_in_mongodb(metrics, mongo_uri=f"mongodb://{os.getenv('MONGO_USERNAME')}:{os.getenv('MONGO_PASSWORD')}@{os.getenv('MONGO_HOST')}:27017/", 
+                               db_name="mysql_monitor", collection_name="metrics"):
+    """
+    Almacena el diccionario de métricas en MongoDB agregándole un timestamp.
+    """
+    client = MongoClient(mongo_uri)
+    db = client[db_name]
+    collection = db[collection_name]
+    
+    # Agregamos el timestamp de la medición (en UTC)
+    metrics["timestamp"] = datetime.datetime.now(datetime.timezone.utc).timestamp()
+    
+    # Insertamos el documento en la colección
+    result = collection.insert_one(metrics)
+    print(f"Datos almacenados con _id: {result.inserted_id}")
+
+def main():
+    # Reemplaza estos parámetros según tu configuración de MySQL
+    host = os.getenv('DB_HOST')
+    port = os.getenv('DB_PORT')
+    user = os.getenv('DB_USERNAME')
+    password = os.getenv('DB_PASSWORD')
+    
+    # Obtener métricas desde MySQL
+    metrics = get_mysql_metrics(host=host, port=port, user=user, password=password)
+    
+    # Almacenar en MongoDB
+    store_metrics_in_mongodb(metrics)
+    
+    # También puedes imprimir en JSON para depuración o para redireccionar la salida
+    print(json.dumps(metrics, indent=4, default=str))
+
+if __name__ == "__main__":
+    main()