scripts/log_analysis/setup.py

#!/usr/bin/env python3
"""
Script de Configuração - Scripts de Análise de Logs

Este script configura e valida o ambiente para uso dos
scripts de análise de logs, criando aliases e verificando dependências.

Autor: Sistema de Análise de Mercado
Versão: 1.0.0
"""

import os
import sys
import json
import sqlite3
from pathlib import Path
from datetime import datetime
import argparse

class LogAnalysisSetup:
    """Configurador dos scripts de análise de logs"""
    
    def __init__(self):
        self.project_root = Path.cwd()
        self.scripts_dir = self.project_root / "scripts" / "log_analysis"
        self.logs_dir = self.project_root / "logs"
        self.config_file = self.scripts_dir / "config.json"
        
    def print_header(self, title: str):
        """Imprime cabeçalho formatado"""
        print("\n" + "="*60)
        print(f" {title}")
        print("="*60)
    
    def print_step(self, step: str, status: str = "INFO"):
        """Imprime passo com status"""
        icons = {
            "INFO": "ℹ️",
            "SUCCESS": "✅",
            "WARNING": "⚠️",
            "ERROR": "❌"
        }
        print(f"{icons.get(status, 'ℹ️')} {step}")
    
    def check_environment(self) -> bool:
        """Verifica o ambiente do projeto"""
        self.print_header("VERIFICAÇÃO DO AMBIENTE")
        
        checks = [
            ("Diretório do projeto", self.project_root.exists()),
            ("Diretório de scripts", self.scripts_dir.exists()),
            ("Diretório de logs", self.logs_dir.exists()),
            ("Arquivo app.py", (self.project_root / "app.py").exists()),
            ("Arquivo config.py", (self.project_root / "config.py").exists())
        ]
        
        all_good = True
        for check_name, result in checks:
            status = "SUCCESS" if result else "ERROR"
            self.print_step(f"{check_name}: {'OK' if result else 'FALHOU'}", status)
            if not result:
                all_good = False
        
        return all_good
    
    def check_log_database(self) -> dict:
        """Verifica o banco de dados de logs"""
        self.print_header("VERIFICAÇÃO DO BANCO DE LOGS")
        
        db_path = self.logs_dir / "application.db"
        result = {
            "exists": db_path.exists(),
            "path": str(db_path),
            "tables": [],
            "log_count": 0,
            "latest_log": None
        }
        
        if not result["exists"]:
            self.print_step(f"Banco de dados não encontrado: {db_path}", "WARNING")
            self.print_step("Execute a aplicação para gerar logs", "INFO")
            return result
        
        try:
            conn = sqlite3.connect(db_path)
            cursor = conn.cursor()
            
            # Verifica tabelas
            cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
            result["tables"] = [row[0] for row in cursor.fetchall()]
            
            # Conta logs se a tabela existe
            if "logs" in result["tables"]:
                cursor.execute("SELECT COUNT(*) FROM logs")
                result["log_count"] = cursor.fetchone()[0]
                
                # Pega o log mais recente
                cursor.execute("SELECT timestamp, level, message FROM logs ORDER BY timestamp DESC LIMIT 1")
                latest = cursor.fetchone()
                if latest:
                    result["latest_log"] = {
                        "timestamp": latest[0],
                        "level": latest[1],
                        "message": latest[2][:100] + "..." if len(latest[2]) > 100 else latest[2]
                    }
            
            conn.close()
            
            self.print_step(f"Banco de dados encontrado: {db_path}", "SUCCESS")
            self.print_step(f"Tabelas: {', '.join(result['tables'])}", "INFO")
            self.print_step(f"Total de logs: {result['log_count']}", "INFO")
            
            if result["latest_log"]:
                self.print_step(f"Último log: {result['latest_log']['timestamp']} - {result['latest_log']['level']}", "INFO")
            
        except Exception as e:
            self.print_step(f"Erro ao verificar banco: {str(e)}", "ERROR")
            result["error"] = str(e)
        
        return result
    
    def create_config(self, db_info: dict):
        """Cria arquivo de configuração"""
        self.print_header("CRIAÇÃO DA CONFIGURAÇÃO")
        
        config = {
            "version": "1.0.0",
            "created_at": datetime.now().isoformat(),
            "project_root": str(self.project_root),
            "database": {
                "path": db_info["path"],
                "exists": db_info["exists"],
                "tables": db_info["tables"],
                "last_check": datetime.now().isoformat()
            },
            "defaults": {
                "analysis_hours": 24,
                "monitor_interval": 5,
                "alert_threshold": 5
            },
            "patterns": {
                "critical_keywords": ["ERROR", "CRITICAL", "Exception", "Failed"],
                "performance_threshold_ms": 1000,
                "import_error_keywords": ["ImportError", "ModuleNotFoundError", "not defined"]
            }
        }
        
        try:
            with open(self.config_file, 'w', encoding='utf-8') as f:
                json.dump(config, f, indent=2, ensure_ascii=False)
            
            self.print_step(f"Configuração salva em: {self.config_file}", "SUCCESS")
            return True
            
        except Exception as e:
            self.print_step(f"Erro ao salvar configuração: {str(e)}", "ERROR")
            return False
    
    def create_aliases(self):
        """Cria aliases para facilitar o uso"""
        self.print_header("CRIAÇÃO DE ALIASES")
        
        aliases_file = self.scripts_dir / "aliases.sh"
        
        aliases_content = f"""#!/bin/bash
# Aliases para Scripts de Análise de Logs
# Gerado automaticamente em {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}

# Diretório base do projeto
PROJECT_ROOT="{self.project_root}"

# Aliases principais
alias log-analyze="python $PROJECT_ROOT/scripts/log_analysis/advanced_log_analyzer.py"
alias log-monitor="python $PROJECT_ROOT/scripts/log_analysis/realtime_monitor.py"
alias log-demo="python $PROJECT_ROOT/scripts/log_analysis/demo.py"

# Aliases com parâmetros comuns
alias log-quick="python $PROJECT_ROOT/scripts/log_analysis/advanced_log_analyzer.py --hours 1 --quiet"
alias log-errors="python $PROJECT_ROOT/scripts/log_analysis/advanced_log_analyzer.py --hours 6 | grep -A10 'ERROS ENCONTRADOS'"
alias log-performance="python $PROJECT_ROOT/scripts/log_analysis/advanced_log_analyzer.py --hours 12 | grep -A10 'PROBLEMAS DE PERFORMANCE'"
alias log-watch="python $PROJECT_ROOT/scripts/log_analysis/realtime_monitor.py --verbose --interval 3"

# Aliases para relatórios
alias log-report-daily="python $PROJECT_ROOT/scripts/log_analysis/advanced_log_analyzer.py --hours 24 --output daily_report.txt"
alias log-report-weekly="python $PROJECT_ROOT/scripts/log_analysis/advanced_log_analyzer.py --hours 168 --output weekly_report.txt"
alias log-export-json="python $PROJECT_ROOT/scripts/log_analysis/advanced_log_analyzer.py --json logs_export.json --quiet"

echo "✅ Aliases de análise de logs carregados!"
echo "📚 Comandos disponíveis:"
echo "  log-analyze    - Análise completa (24h)"
echo "  log-monitor    - Monitor em tempo real"
echo "  log-quick      - Análise rápida (1h)"
echo "  log-errors     - Foca apenas em erros"
echo "  log-performance- Problemas de performance"
echo "  log-watch      - Monitor detalhado"
echo "  log-demo       - Demonstração dos scripts"
echo ""
echo "💡 Para usar: source scripts/log_analysis/aliases.sh"
"""
        
        try:
            with open(aliases_file, 'w', encoding='utf-8') as f:
                f.write(aliases_content)
            
            # Torna o arquivo executável
            aliases_file.chmod(0o755)
            
            self.print_step(f"Aliases criados em: {aliases_file}", "SUCCESS")
            self.print_step("Para usar: source scripts/log_analysis/aliases.sh", "INFO")
            return True
            
        except Exception as e:
            self.print_step(f"Erro ao criar aliases: {str(e)}", "ERROR")
            return False
    
    def create_batch_scripts(self):
        """Cria scripts batch para Windows"""
        self.print_header("CRIAÇÃO DE SCRIPTS BATCH (WINDOWS)")
        
        batch_dir = self.scripts_dir / "batch"
        batch_dir.mkdir(exist_ok=True)
        
        scripts = {
            "analyze.bat": f"@echo off\npython \"{self.project_root}\\scripts\\log_analysis\\advanced_log_analyzer.py\" %*",
            "monitor.bat": f"@echo off\npython \"{self.project_root}\\scripts\\log_analysis\\realtime_monitor.py\" %*",
            "demo.bat": f"@echo off\npython \"{self.project_root}\\scripts\\log_analysis\\demo.py\" %*",
            "quick-check.bat": f"@echo off\npython \"{self.project_root}\\scripts\\log_analysis\\advanced_log_analyzer.py\" --hours 1 --quiet"
        }
        
        created_count = 0
        for script_name, content in scripts.items():
            script_path = batch_dir / script_name
            try:
                with open(script_path, 'w', encoding='utf-8') as f:
                    f.write(content)
                created_count += 1
                self.print_step(f"Criado: {script_name}", "SUCCESS")
            except Exception as e:
                self.print_step(f"Erro ao criar {script_name}: {str(e)}", "ERROR")
        
        if created_count > 0:
            self.print_step(f"Scripts batch criados em: {batch_dir}", "INFO")
            self.print_step("Adicione o diretório ao PATH para usar globalmente", "INFO")
        
        return created_count > 0
    
    def validate_scripts(self):
        """Valida se os scripts principais existem e são executáveis"""
        self.print_header("VALIDAÇÃO DOS SCRIPTS")
        
        scripts = [
            "advanced_log_analyzer.py",
            "realtime_monitor.py",
            "demo.py",
            "setup.py"
        ]
        
        all_valid = True
        for script in scripts:
            script_path = self.scripts_dir / script
            exists = script_path.exists()
            
            if exists:
                # Tenta importar para verificar sintaxe
                try:
                    import subprocess
                    result = subprocess.run(
                        [sys.executable, "-m", "py_compile", str(script_path)],
                        capture_output=True,
                        text=True
                    )
                    syntax_ok = result.returncode == 0
                except:
                    syntax_ok = False
                
                status = "SUCCESS" if syntax_ok else "WARNING"
                self.print_step(f"{script}: {'OK' if syntax_ok else 'Erro de sintaxe'}", status)
                
                if not syntax_ok:
                    all_valid = False
            else:
                self.print_step(f"{script}: Não encontrado", "ERROR")
                all_valid = False
        
        return all_valid
    
    def run_setup(self, create_aliases: bool = True, create_batch: bool = True):
        """Executa configuração completa"""
        self.print_header("CONFIGURAÇÃO DOS SCRIPTS DE ANÁLISE DE LOGS")
        
        # Verifica ambiente
        if not self.check_environment():
            self.print_step("Ambiente inválido. Não é possível continuar.", "ERROR")
            return False
        
        # Verifica banco de logs
        db_info = self.check_log_database()
        
        # Cria configuração
        if not self.create_config(db_info):
            self.print_step("Falha ao criar configuração", "ERROR")
            return False
        
        # Valida scripts
        if not self.validate_scripts():
            self.print_step("Alguns scripts têm problemas", "WARNING")
        
        # Cria aliases se solicitado
        if create_aliases:
            self.create_aliases()
        
        # Cria scripts batch se solicitado
        if create_batch and os.name == 'nt':  # Windows
            self.create_batch_scripts()
        
        self.print_header("CONFIGURAÇÃO CONCLUÍDA")
        self.print_step("Scripts de análise configurados com sucesso!", "SUCCESS")
        
        # Instruções finais
        print("\n📋 Próximos passos:")
        print("  1. Execute 'python scripts/log_analysis/demo.py' para ver exemplos")
        print("  2. Use 'python scripts/log_analysis/advanced_log_analyzer.py --help' para ajuda")
        print("  3. Inicie o monitor com 'python scripts/log_analysis/realtime_monitor.py'")
        
        if create_aliases:
            print("  4. Carregue os aliases: source scripts/log_analysis/aliases.sh")
        
        if db_info["log_count"] == 0:
            print("\n⚠️ Aviso: Nenhum log encontrado. Execute a aplicação para gerar dados.")
        
        return True

def main():
    """Função principal"""
    parser = argparse.ArgumentParser(description='Configuração dos Scripts de Análise de Logs')
    parser.add_argument('--no-aliases', action='store_true', help='Não criar aliases')
    parser.add_argument('--no-batch', action='store_true', help='Não criar scripts batch')
    parser.add_argument('--validate-only', action='store_true', help='Apenas validar ambiente')
    
    args = parser.parse_args()
    
    setup = LogAnalysisSetup()
    
    if args.validate_only:
        # Apenas validação
        env_ok = setup.check_environment()
        db_info = setup.check_log_database()
        scripts_ok = setup.validate_scripts()
        
        if env_ok and scripts_ok:
            print("\n✅ Ambiente validado com sucesso!")
            return 0
        else:
            print("\n❌ Problemas encontrados na validação")
            return 1
    else:
        # Configuração completa
        success = setup.run_setup(
            create_aliases=not args.no_aliases,
            create_batch=not args.no_batch
        )
        
        return 0 if success else 1

if __name__ == "__main__":
    exit(main())