feat: Implementar sistema de logging avançado com SQLite3

- Adicionar DatabaseLogger com armazenamento persistente em SQLite3
- Criar interface web para visualização de logs com filtros e estatísticas
- Implementar decoradores automáticos (@log_execution, @log_api_call, @log_ai_model_usage)
- Adicionar gerenciador de contexto LoggingContext
- Criar sistema de métricas de performance em tempo real
- Implementar rastreamento de eventos do sistema
- Adicionar limpeza automática de logs antigos
- Criar 8 categorias de logs organizadas (SYSTEM, API, AI_MODEL, etc.)
- Adicionar testes completos para todo o sistema
- Atualizar documentação e README com novas funcionalidades

CHANGELOG.md

@@ -5,13 +5,35 @@ Todas as mudanças notáveis neste projeto serão documentadas neste arquivo.
 O formato é baseado em [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 e este projeto adere ao [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.0] - 2024-01-28
+
+### 🎉 Adicionado
+- **Sistema de Logging Avançado com SQLite3**: Armazenamento persistente de logs estruturados
+- **Interface Web de Logs**: Visualizador interativo com filtros, estatísticas e gráficos
+- **Decoradores de Logging**: Logging automático com `@log_execution`, `@log_api_call`, `@log_ai_model_usage`
+- **Gerenciador de Contexto**: `LoggingContext` para logging de blocos de código
+- **Métricas de Performance**: Monitoramento em tempo real com armazenamento em banco
+- **Eventos do Sistema**: Rastreamento de eventos críticos e alertas
+- **Limpeza Automática**: Gerenciamento automático de logs antigos
+- **Categorização Inteligente**: 8 categorias de logs (SYSTEM, API, AI_MODEL, etc.)
+- **Testes Completos**: Suite de testes para todo o sistema de logging
+
+### 🔄 Alterado
+- **Documentação**: Atualizada com sistema de logging avançado
+- **README.md**: Incluídas novas funcionalidades e exemplos de uso
+- **Arquitetura**: Integração completa do logging com todos os módulos
+
+### 🐛 Corrigido
+- **Compatibilidade de Parâmetros**: Correções nos métodos de logging
+- **Tratamento de Erros**: Melhor handling de exceções no sistema de logging
+
 ## [2.0.0] - 2024-01-27
 
 ### 🎉 Adicionado
 - **Sistema Ensemble de IA**: Implementação de múltiplos modelos (FinBERT, RoBERTa, Custom)
 - **Votação Inteligente**: Sistema de consenso entre modelos para maior precisão
 - **Análise de Mercado Avançada**: Detecção de swing points, zonas de confluência e padrões harmônicos
-- **Sistema de Logging Completo**: Rastreamento detalhado de requisições e respostas
+- **Sistema de Logging Básico**: Rastreamento detalhado de requisições e respostas
 - **Estrutura Refatorada**: Organização modular em `src/` com separação clara de responsabilidades
 - **Documentação Completa**: Guias de instalação, API, desenvolvimento e troubleshooting
 - **Testes Automatizados**: Suite de testes para garantir qualidade do código

README.md

@@ -34,9 +34,13 @@ Um sistema completo de análise financeira que combina múltiplos modelos de IA
 - **Contexto Financeiro**: Especializado em terminologia do mercado financeiro
 
 ### 📝 Sistema de Logging Avançado
-- **Rastreamento Completo**: Log detalhado de todas as requisições e respostas
-- **Monitoramento de Performance**: Métricas em tempo real dos modelos
-- **Debugging**: Logs estruturados para facilitar manutenção
+- **Armazenamento SQLite3**: Banco de dados estruturado para logs persistentes
+- **Interface Web**: Visualizador de logs com filtros avançados e estatísticas
+- **Decoradores Automáticos**: Logging automático com decoradores Python
+- **Métricas de Performance**: Monitoramento em tempo real com gráficos
+- **Categorização Inteligente**: Logs organizados por categoria e nível
+- **Limpeza Automática**: Gerenciamento automático de logs antigos
+- **Eventos do Sistema**: Rastreamento de eventos críticos e alertas
 
 ## 🏗️ Arquitetura do Sistema
 
@@ -62,7 +66,9 @@ Um sistema completo de análise financeira que combina múltiplos modelos de IA
 - **Transformers**: Modelos de linguagem (FinBERT, RoBERTa)
 - **NumPy/Pandas**: Processamento de dados
 - **Scikit-learn**: Machine learning
-- **Logging**: Sistema de logs estruturado
+- **SQLite3**: Banco de dados para logging avançado
+- **Plotly**: Gráficos interativos para métricas
+- **Threading**: Processamento assíncrono
 
 ## 📋 Pré-requisitos
 
@@ -98,6 +104,7 @@ Documentação completa disponível em:
 - [Referência da API](docs/api-reference.md)
 - [Guia do Desenvolvedor](docs/developer-guide.md)
 - [Arquitetura do Sistema](docs/architecture.md)
+- [Sistema de Logging](docs/logging_system.md)
 - [Solução de Problemas](docs/troubleshooting.md)
 
 ## 🔧 Configuração
@@ -139,6 +146,30 @@ result = processor.process_market_data(prices, volumes)
 print(f"Estrutura do mercado: {result['market_structure']}")
 ```
 
+### Sistema de Logging
+```python
+from src.utils.logging_decorators import log_execution, quick_log
+from src.core.database_logger import LogLevel, LogCategory
+
+# Logging automático com decorador
+@log_execution(LogCategory.MARKET_ANALYSIS, log_performance=True)
+def analyze_market():
+    # Sua análise aqui
+    return results
+
+# Logging rápido
+quick_log("Operação concluída", LogLevel.INFO, LogCategory.SYSTEM)
+```
+
+### Visualização de Logs
+```python
+from src.ui.log_viewer import create_log_viewer_interface
+
+# Criar interface de visualização
+interface = create_log_viewer_interface()
+interface.launch()
+```
+
 ## 🤝 Contribuição
 
 1. Fork o projeto

app.py

@@ -16,6 +16,15 @@ try:
     from src.integrations.real_time_integration import RealTimeIntegration, BotEvent
     from src.core.performance_monitor import PerformanceMonitor, measure_analysis_time
     from src.utils.request_logger import log_requests_responses, enable_logging, disable_logging
+    
+    # Sistema de logging avançado
+    from src.core.database_logger import get_logger, initialize_logger, LogLevel, LogCategory
+    from src.utils.logging_decorators import log_execution, log_api_call, log_ai_model_usage, LoggingContext, quick_log
+    from src.ui.log_viewer import create_log_viewer_interface
+    
+    # Inicializar o sistema de logging
+    db_logger = initialize_logger("logs/application.db")
+    
 except ImportError:
     # Fallback para modo standalone se módulos não existirem
     print("⚠️ Módulos refatorados não encontrados. Executando em modo standalone.")
@@ -35,6 +44,19 @@ except ImportError:
     log_requests_responses = None
     enable_logging = None
     disable_logging = None
+    
+    # Fallback para sistema de logging
+    get_logger = None
+    initialize_logger = None
+    LogLevel = None
+    LogCategory = None
+    log_execution = None
+    log_api_call = None
+    log_ai_model_usage = None
+    LoggingContext = None
+    quick_log = None
+    create_log_viewer_interface = None
+    db_logger = None
 
 # Engines de análise
 technical_engine = None
@@ -55,6 +77,10 @@ def initialize_engines():
     global technical_engine, sentiment_engine, model_info
     
     try:
+        # Log do início da inicialização
+        if quick_log:
+            quick_log("Iniciando inicialização dos engines", LogLevel.INFO, LogCategory.SYSTEM)
+        
         # Habilitar logging de requisições/respostas
         if enable_logging:
             enable_logging()
@@ -74,12 +100,40 @@ def initialize_engines():
             if LogUtils:
                 LogUtils.log_model_status(model_info)
             
+            # Log de sucesso
+            if quick_log:
+                quick_log("Engines inicializados com sucesso", LogLevel.INFO, LogCategory.SYSTEM, 
+                         metadata={'engines': ['Technical Analysis', 'Sentiment Analysis']})
+            
+            # Log evento do sistema
+            if db_logger:
+                db_logger.log_system_event(
+                    event_type="INITIALIZATION",
+                    event_name="ENGINES_STARTED",
+                    description="Todos os engines foram inicializados com sucesso",
+                    severity="INFO",
+                    metadata=model_info
+                )
+            
             print("✅ Engines inicializadas com sucesso")
         else:
             # Fallback para modo standalone
             initialize_standalone_mode()
             
     except Exception as e:
+        # Log de erro
+        if quick_log:
+            quick_log(f"Erro ao inicializar engines: {e}", LogLevel.ERROR, LogCategory.SYSTEM)
+        
+        if db_logger:
+            db_logger.log_system_event(
+                event_type="ERROR",
+                event_name="ENGINES_INITIALIZATION_FAILED",
+                description=f"Falha na inicialização dos engines: {str(e)}",
+                severity="ERROR",
+                metadata={'error': str(e)}
+            )
+        
         print(f"Erro na inicialização: {str(e)}")
         # Fallback para modo básico
         initialize_standalone_mode()
@@ -190,6 +244,7 @@ def parse_market_data(text):
         return None
 
 @log_requests_responses("analyze_sentiment") if log_requests_responses else lambda f: f
+@log_ai_model_usage("sentiment_analysis") if log_ai_model_usage else lambda f: f
 def analyze_sentiment(text):
     """Analisa o sentimento do texto usando engines ou fallback."""
     if sentiment_engine and hasattr(sentiment_engine, 'analyze_sentiment'):
@@ -250,6 +305,7 @@ def analyze_sentiment(text):
     }
 
 @measure_analysis_time if measure_analysis_time else lambda f: f
+@log_execution(LogCategory.MARKET_ANALYSIS, log_performance=True) if log_execution else lambda f: f
 def analyze_scalping_signals(market_data, original_text=""):
     """Analisa sinais para scalping usando engines ou fallback."""
     if technical_engine and hasattr(technical_engine, 'analyze_scalping_signals'):
@@ -501,6 +557,7 @@ def generate_trading_response(analysis):
     return response
 
 @log_requests_responses("process_trading_analysis") if log_requests_responses else lambda f: f
+@log_api_call("process_trading_analysis") if log_api_call else lambda f: f
 def process_trading_analysis(text):
     """Função principal que processa a análise de trading usando engines ou fallback."""
     
@@ -592,6 +649,7 @@ def process_trading_analysis_basic(text):
 
 # Função principal de análise para a interface
 @log_requests_responses("main_analysis_function") if log_requests_responses else lambda f: f
+@log_api_call("main_analysis_function") if log_api_call else lambda f: f
 def main_analysis_function(text: str) -> str:
     """Função principal de análise que será usada pela interface."""
     result = process_trading_analysis(text)
@@ -725,6 +783,12 @@ Notícias: Mercado otimista com dados do PIB"""
                          value="<div style='color: #666;'>Execute análises para obter sugestões</div>"
                      )
         
+        # Adicionar aba de logs se disponível
+        if create_log_viewer_interface:
+            with gr.Tab("📋 Logs do Sistema"):
+                log_viewer = create_log_viewer_interface(db_logger)
+                log_viewer.render()
+        
         analyze_btn.click(
             fn=main_analysis_function,
             inputs=[market_input],
@@ -794,6 +858,16 @@ Notícias: Mercado otimista com dados do PIB"""
             fn=get_optimization_suggestions_display,
             outputs=[optimization_suggestions]
         )
+        
+        # Log evento de inicialização da interface
+        if db_logger:
+            db_logger.log_system_event(
+                event_type="INITIALIZATION",
+                event_name="INTERFACE_CREATED",
+                description="Interface Gradio criada com sucesso",
+                severity="INFO",
+                metadata={'tabs': ['Análise de Mercado', 'Monitor do Bot', 'Performance', 'Logs do Sistema']}
+            )
     
     return interface
 

docs/logging_system.md

@@ -0,0 +1,324 @@
+# Sistema de Logging Avançado
+
+## Visão Geral
+
+O sistema de logging avançado foi projetado para fornecer monitoramento abrangente e análise detalhada de todas as operações do sistema de análise financeira. Utiliza SQLite3 para armazenamento persistente e oferece uma interface web para visualização e análise dos logs.
+
+## Arquitetura do Sistema
+
+### Componentes Principais
+
+1. **DatabaseLogger** (`src/core/database_logger.py`)
+   - Gerenciador principal do sistema de logging
+   - Conexão e operações com banco SQLite3
+   - Armazenamento estruturado de logs, métricas e eventos
+
+2. **Decoradores de Logging** (`src/utils/logging_decorators.py`)
+   - Decoradores para logging automático de funções
+   - Gerenciador de contexto para blocos de código
+   - Utilitários para logging rápido
+
+3. **Visualizador de Logs** (`src/ui/log_viewer.py`)
+   - Interface web para visualização de logs
+   - Filtros avançados e busca
+   - Estatísticas e gráficos
+   - Exportação de dados
+
+## Estrutura do Banco de Dados
+
+### Tabela: logs
+```sql
+CREATE TABLE logs (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp TEXT NOT NULL,
+    level TEXT NOT NULL,
+    category TEXT NOT NULL,
+    message TEXT NOT NULL,
+    function_name TEXT,
+    file_name TEXT,
+    line_number INTEGER,
+    execution_time REAL,
+    metadata TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+### Tabela: performance_metrics
+```sql
+CREATE TABLE performance_metrics (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp TEXT NOT NULL,
+    metric_name TEXT NOT NULL,
+    metric_value REAL NOT NULL,
+    unit TEXT,
+    category TEXT,
+    metadata TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+### Tabela: system_events
+```sql
+CREATE TABLE system_events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp TEXT NOT NULL,
+    event_type TEXT NOT NULL,
+    event_name TEXT NOT NULL,
+    description TEXT,
+    severity TEXT NOT NULL,
+    metadata TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+## Níveis de Log
+
+- **DEBUG**: Informações detalhadas para depuração
+- **INFO**: Informações gerais sobre operações
+- **WARNING**: Avisos sobre situações potencialmente problemáticas
+- **ERROR**: Erros que não impedem a execução
+- **CRITICAL**: Erros críticos que podem interromper o sistema
+
+## Categorias de Log
+
+- **SYSTEM**: Eventos do sistema (inicialização, configuração)
+- **API**: Chamadas de API e integrações externas
+- **AI_MODEL**: Uso de modelos de IA e análises
+- **MARKET_ANALYSIS**: Análises de mercado e trading
+- **USER_INTERACTION**: Interações do usuário com a interface
+- **PERFORMANCE**: Métricas de performance e otimização
+- **SECURITY**: Eventos relacionados à segurança
+- **DATABASE**: Operações de banco de dados
+
+## Uso dos Decoradores
+
+### @log_execution
+```python
+from src.utils.logging_decorators import log_execution
+from src.core.database_logger import LogCategory
+
+@log_execution(LogCategory.MARKET_ANALYSIS, log_performance=True)
+def analyze_market_data(data):
+    # Sua função aqui
+    return result
+```
+
+### @log_api_call
+```python
+from src.utils.logging_decorators import log_api_call
+
+@log_api_call("external_api")
+def call_external_service(params):
+    # Chamada para API externa
+    return response
+```
+
+### @log_ai_model_usage
+```python
+from src.utils.logging_decorators import log_ai_model_usage
+
+@log_ai_model_usage("sentiment_analysis")
+def analyze_sentiment(text):
+    # Análise de sentimento
+    return sentiment
+```
+
+### Gerenciador de Contexto
+```python
+from src.utils.logging_decorators import LoggingContext
+from src.core.database_logger import LogLevel, LogCategory
+
+with LoggingContext("Processamento de dados", LogLevel.INFO, LogCategory.SYSTEM):
+    # Seu código aqui
+    process_data()
+```
+
+## Logging Rápido
+
+```python
+from src.utils.logging_decorators import quick_log
+from src.core.database_logger import LogLevel, LogCategory
+
+# Log simples
+quick_log("Operação concluída", LogLevel.INFO, LogCategory.SYSTEM)
+
+# Log com metadados
+quick_log(
+    "Análise finalizada", 
+    LogLevel.INFO, 
+    LogCategory.MARKET_ANALYSIS,
+    metadata={'duration': 1.5, 'symbols': ['BTCUSDT', 'ETHUSDT']}
+)
+```
+
+## Interface de Visualização
+
+A interface web oferece:
+
+### Funcionalidades Principais
+- **Visualização de Logs**: Tabela paginada com filtros
+- **Estatísticas**: Contadores por nível e categoria
+- **Gráficos**: Métricas de performance e timeline
+- **Busca**: Pesquisa por termos específicos
+- **Exportação**: CSV, JSON e HTML
+
+### Filtros Disponíveis
+- **Nível de Log**: DEBUG, INFO, WARNING, ERROR, CRITICAL
+- **Categoria**: Todas as categorias disponíveis
+- **Período**: Últimas horas, dias ou intervalo personalizado
+- **Função**: Filtrar por nome da função
+- **Arquivo**: Filtrar por arquivo de origem
+
+## Configuração e Inicialização
+
+### Inicialização Básica
+```python
+from src.core.database_logger import DatabaseLogger
+
+# Inicializar logger
+db_logger = DatabaseLogger('logs/application.db')
+
+# Log simples
+db_logger.log(
+    level=LogLevel.INFO,
+    category=LogCategory.SYSTEM,
+    message="Sistema inicializado"
+)
+```
+
+### Configuração Avançada
+```python
+# Log com metadados
+db_logger.log(
+    level=LogLevel.INFO,
+    category=LogCategory.API,
+    message="Chamada API realizada",
+    function_name="call_api",
+    file_name="api_client.py",
+    line_number=45,
+    execution_time=0.250,
+    metadata={'endpoint': '/market/data', 'status': 200}
+)
+
+# Métrica de performance
+db_logger.log_performance_metric(
+    metric_name="response_time",
+    metric_value=0.150,
+    unit="seconds",
+    category="api_performance"
+)
+
+# Evento do sistema
+db_logger.log_system_event(
+    event_type="STARTUP",
+    event_name="SERVICE_STARTED",
+    description="Serviço de análise iniciado com sucesso",
+    severity="INFO"
+)
+```
+
+## Manutenção e Limpeza
+
+### Limpeza Automática
+```python
+# Remover logs mais antigos que 30 dias
+db_logger.cleanup_old_logs(days=30)
+
+# Remover métricas mais antigas que 7 dias
+db_logger.cleanup_old_metrics(days=7)
+
+# Remover eventos mais antigos que 90 dias
+db_logger.cleanup_old_events(days=90)
+```
+
+### Estatísticas do Sistema
+```python
+# Obter estatísticas gerais
+stats = db_logger.get_log_statistics()
+print(f"Total de logs: {stats['total_logs']}")
+print(f"Logs por nível: {stats['by_level']}")
+print(f"Logs por categoria: {stats['by_category']}")
+```
+
+## Monitoramento e Alertas
+
+### Detecção de Problemas
+O sistema automaticamente monitora:
+- **Erros Críticos**: Logs de nível CRITICAL
+- **Taxa de Erros**: Proporção de logs ERROR/WARNING
+- **Performance**: Métricas de tempo de execução
+- **Disponibilidade**: Eventos de sistema
+
+### Exemplo de Monitoramento
+```python
+# Verificar logs de erro nas últimas 24 horas
+error_logs = db_logger.get_logs(
+    level_filter="ERROR",
+    hours_back=24
+)
+
+if len(error_logs) > 10:
+    # Enviar alerta
+    db_logger.log_system_event(
+        event_type="ALERT",
+        event_name="HIGH_ERROR_RATE",
+        description=f"Taxa alta de erros detectada: {len(error_logs)} erros em 24h",
+        severity="WARNING"
+    )
+```
+
+## Integração com a Aplicação
+
+O sistema está totalmente integrado com:
+- **Análise de Sentimento**: Logs de uso de modelos IA
+- **Análise Técnica**: Métricas de performance
+- **API Calls**: Monitoramento de chamadas externas
+- **Interface Gradio**: Logs de interação do usuário
+- **Sistema Ensemble**: Logs de decisões de IA
+
+## Boas Práticas
+
+1. **Use níveis apropriados**: DEBUG para desenvolvimento, INFO para operações normais
+2. **Inclua contexto**: Sempre adicione metadados relevantes
+3. **Monitore performance**: Use métricas para identificar gargalos
+4. **Mantenha limpo**: Configure limpeza automática de logs antigos
+5. **Analise regularmente**: Use a interface para identificar padrões
+
+## Troubleshooting
+
+### Problemas Comuns
+
+1. **Banco não inicializa**
+   - Verificar permissões da pasta `logs/`
+   - Verificar espaço em disco
+
+2. **Performance lenta**
+   - Executar limpeza de logs antigos
+   - Verificar índices do banco
+
+3. **Interface não carrega**
+   - Verificar se o banco existe
+   - Verificar logs de erro do sistema
+
+### Comandos de Diagnóstico
+```python
+# Verificar saúde do banco
+db_logger.get_database_info()
+
+# Testar conexão
+db_logger.test_connection()
+
+# Estatísticas de uso
+stats = db_logger.get_log_statistics()
+```
+
+## Conclusão
+
+O sistema de logging avançado fornece visibilidade completa sobre todas as operações do sistema, permitindo:
+- **Monitoramento em tempo real**
+- **Análise de performance**
+- **Detecção de problemas**
+- **Auditoria de operações**
+- **Otimização contínua**
+
+Para mais informações, consulte os arquivos de código fonte ou a interface web de logs.

src/core/database_logger.py

@@ -0,0 +1,399 @@
+import sqlite3
+import json
+import datetime
+import threading
+import os
+from typing import Dict, Any, Optional, List
+from enum import Enum
+from dataclasses import dataclass, asdict
+from contextlib import contextmanager
+
+class LogLevel(Enum):
+    """Níveis de log disponíveis"""
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+class LogCategory(Enum):
+    """Categorias de log para organização"""
+    SYSTEM = "SYSTEM"
+    API = "API"
+    AI_MODEL = "AI_MODEL"
+    MARKET_ANALYSIS = "MARKET_ANALYSIS"
+    SENTIMENT_ANALYSIS = "SENTIMENT_ANALYSIS"
+    PERFORMANCE = "PERFORMANCE"
+    USER_INTERACTION = "USER_INTERACTION"
+    ERROR_TRACKING = "ERROR_TRACKING"
+    SECURITY = "SECURITY"
+
+@dataclass
+class LogEntry:
+    """Estrutura de uma entrada de log"""
+    timestamp: str
+    level: str
+    category: str
+    message: str
+    module: str
+    function: str
+    line_number: int
+    user_id: Optional[str] = None
+    session_id: Optional[str] = None
+    request_id: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+    stack_trace: Optional[str] = None
+    execution_time: Optional[float] = None
+
+class DatabaseLogger:
+    """Sistema de logging avançado com SQLite3"""
+    
+    def __init__(self, db_path: str = "logs/application.db"):
+        self.db_path = db_path
+        self._lock = threading.Lock()
+        self._ensure_directory_exists()
+        self._initialize_database()
+    
+    def _ensure_directory_exists(self):
+        """Garante que o diretório do banco de dados existe"""
+        os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
+    
+    def _initialize_database(self):
+        """Inicializa o banco de dados e cria as tabelas necessárias"""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            
+            # Tabela principal de logs
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS logs (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    timestamp TEXT NOT NULL,
+                    level TEXT NOT NULL,
+                    category TEXT NOT NULL,
+                    message TEXT NOT NULL,
+                    module TEXT NOT NULL,
+                    function TEXT NOT NULL,
+                    line_number INTEGER NOT NULL,
+                    user_id TEXT,
+                    session_id TEXT,
+                    request_id TEXT,
+                    metadata TEXT,
+                    stack_trace TEXT,
+                    execution_time REAL,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+            
+            # Tabela para métricas de performance
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS performance_metrics (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    timestamp TEXT NOT NULL,
+                    metric_name TEXT NOT NULL,
+                    metric_value REAL NOT NULL,
+                    unit TEXT,
+                    category TEXT,
+                    metadata TEXT,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+            
+            # Tabela para eventos do sistema
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS system_events (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    timestamp TEXT NOT NULL,
+                    event_type TEXT NOT NULL,
+                    event_name TEXT NOT NULL,
+                    description TEXT,
+                    severity TEXT,
+                    metadata TEXT,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+            
+            # Índices para melhor performance
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_logs_timestamp ON logs(timestamp)")
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_logs_level ON logs(level)")
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_logs_category ON logs(category)")
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_logs_session ON logs(session_id)")
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_performance_timestamp ON performance_metrics(timestamp)")
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_events_timestamp ON system_events(timestamp)")
+            
+            conn.commit()
+    
+    @contextmanager
+    def _get_connection(self):
+        """Context manager para conexões com o banco de dados"""
+        conn = sqlite3.connect(self.db_path, timeout=30.0)
+        conn.row_factory = sqlite3.Row
+        try:
+            yield conn
+        finally:
+            conn.close()
+    
+    def log(self, level: LogLevel, category: LogCategory, message: str, 
+            module: str, function: str, line_number: int,
+            user_id: Optional[str] = None, session_id: Optional[str] = None,
+            request_id: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None,
+            stack_trace: Optional[str] = None, execution_time: Optional[float] = None):
+        """Registra uma entrada de log no banco de dados"""
+        
+        log_entry = LogEntry(
+            timestamp=datetime.datetime.now().isoformat(),
+            level=level.value,
+            category=category.value,
+            message=message,
+            module=module,
+            function=function,
+            line_number=line_number,
+            user_id=user_id,
+            session_id=session_id,
+            request_id=request_id,
+            metadata=json.dumps(metadata) if metadata else None,
+            stack_trace=stack_trace,
+            execution_time=execution_time
+        )
+        
+        with self._lock:
+            with self._get_connection() as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    INSERT INTO logs (
+                        timestamp, level, category, message, module, function, 
+                        line_number, user_id, session_id, request_id, metadata, 
+                        stack_trace, execution_time
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """, (
+                    log_entry.timestamp, log_entry.level, log_entry.category,
+                    log_entry.message, log_entry.module, log_entry.function,
+                    log_entry.line_number, log_entry.user_id, log_entry.session_id,
+                    log_entry.request_id, log_entry.metadata, log_entry.stack_trace,
+                    log_entry.execution_time
+                ))
+                conn.commit()
+    
+    def log_performance_metric(self, metric_name: str, metric_value: float,
+                             unit: str = None, category: str = None,
+                             metadata: Optional[Dict[str, Any]] = None):
+        """Registra uma métrica de performance"""
+        
+        with self._lock:
+            with self._get_connection() as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    INSERT INTO performance_metrics (
+                        timestamp, metric_name, metric_value, unit, category, metadata
+                    ) VALUES (?, ?, ?, ?, ?, ?)
+                """, (
+                    datetime.datetime.now().isoformat(),
+                    metric_name,
+                    metric_value,
+                    unit,
+                    category,
+                    json.dumps(metadata) if metadata else None
+                ))
+                conn.commit()
+    
+    def log_system_event(self, event_type: str, event_name: str,
+                        description: str = None, severity: str = "INFO",
+                        metadata: Optional[Dict[str, Any]] = None):
+        """Registra um evento do sistema"""
+        
+        with self._lock:
+            with self._get_connection() as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    INSERT INTO system_events (
+                        timestamp, event_type, event_name, description, severity, metadata
+                    ) VALUES (?, ?, ?, ?, ?, ?)
+                """, (
+                    datetime.datetime.now().isoformat(),
+                    event_type,
+                    event_name,
+                    description,
+                    severity,
+                    json.dumps(metadata) if metadata else None
+                ))
+                conn.commit()
+    
+    def get_logs(self, level: Optional[str] = None, category: Optional[str] = None,
+                start_time: Optional[str] = None, end_time: Optional[str] = None,
+                limit: int = 100, offset: int = 0) -> List[Dict[str, Any]]:
+        """Recupera logs do banco de dados com filtros"""
+        
+        query = "SELECT * FROM logs WHERE 1=1"
+        params = []
+        
+        if level:
+            query += " AND level = ?"
+            params.append(level)
+        
+        if category:
+            query += " AND category = ?"
+            params.append(category)
+        
+        if start_time:
+            query += " AND timestamp >= ?"
+            params.append(start_time)
+        
+        if end_time:
+            query += " AND timestamp <= ?"
+            params.append(end_time)
+        
+        query += " ORDER BY timestamp DESC LIMIT ? OFFSET ?"
+        params.extend([limit, offset])
+        
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(query, params)
+            rows = cursor.fetchall()
+            
+            return [dict(row) for row in rows]
+    
+    def get_performance_metrics(self, metric_name: Optional[str] = None,
+                              start_time: Optional[str] = None,
+                              end_time: Optional[str] = None,
+                              limit: int = 100) -> List[Dict[str, Any]]:
+        """Recupera m��tricas de performance"""
+        
+        query = "SELECT * FROM performance_metrics WHERE 1=1"
+        params = []
+        
+        if metric_name:
+            query += " AND metric_name = ?"
+            params.append(metric_name)
+        
+        if start_time:
+            query += " AND timestamp >= ?"
+            params.append(start_time)
+        
+        if end_time:
+            query += " AND timestamp <= ?"
+            params.append(end_time)
+        
+        query += " ORDER BY timestamp DESC LIMIT ?"
+        params.append(limit)
+        
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(query, params)
+            rows = cursor.fetchall()
+            
+            return [dict(row) for row in rows]
+    
+    def get_system_events(self, event_type: Optional[str] = None,
+                         severity: Optional[str] = None,
+                         start_time: Optional[str] = None,
+                         end_time: Optional[str] = None,
+                         limit: int = 100) -> List[Dict[str, Any]]:
+        """Recupera eventos do sistema"""
+        
+        query = "SELECT * FROM system_events WHERE 1=1"
+        params = []
+        
+        if event_type:
+            query += " AND event_type = ?"
+            params.append(event_type)
+        
+        if severity:
+            query += " AND severity = ?"
+            params.append(severity)
+        
+        if start_time:
+            query += " AND timestamp >= ?"
+            params.append(start_time)
+        
+        if end_time:
+            query += " AND timestamp <= ?"
+            params.append(end_time)
+        
+        query += " ORDER BY timestamp DESC LIMIT ?"
+        params.append(limit)
+        
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(query, params)
+            rows = cursor.fetchall()
+            
+            return [dict(row) for row in rows]
+    
+    def cleanup_old_logs(self, days_to_keep: int = 30):
+        """Remove logs antigos para manter o banco de dados otimizado"""
+        
+        cutoff_date = (datetime.datetime.now() - datetime.timedelta(days=days_to_keep)).isoformat()
+        
+        with self._lock:
+            with self._get_connection() as conn:
+                cursor = conn.cursor()
+                
+                # Remove logs antigos
+                cursor.execute("DELETE FROM logs WHERE timestamp < ?", (cutoff_date,))
+                
+                # Remove métricas antigas
+                cursor.execute("DELETE FROM performance_metrics WHERE timestamp < ?", (cutoff_date,))
+                
+                # Remove eventos antigos
+                cursor.execute("DELETE FROM system_events WHERE timestamp < ?", (cutoff_date,))
+                
+                # Otimiza o banco de dados
+                cursor.execute("VACUUM")
+                
+                conn.commit()
+    
+    def get_statistics(self) -> Dict[str, Any]:
+        """Retorna estatísticas do sistema de logging"""
+        
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            
+            # Contagem total de logs
+            cursor.execute("SELECT COUNT(*) as total FROM logs")
+            total_logs = cursor.fetchone()['total']
+            
+            # Logs por nível
+            cursor.execute("""
+                SELECT level, COUNT(*) as count 
+                FROM logs 
+                GROUP BY level 
+                ORDER BY count DESC
+            """)
+            logs_by_level = dict(cursor.fetchall())
+            
+            # Logs por categoria
+            cursor.execute("""
+                SELECT category, COUNT(*) as count 
+                FROM logs 
+                GROUP BY category 
+                ORDER BY count DESC
+            """)
+            logs_by_category = dict(cursor.fetchall())
+            
+            # Logs das últimas 24 horas
+            last_24h = (datetime.datetime.now() - datetime.timedelta(hours=24)).isoformat()
+            cursor.execute("SELECT COUNT(*) as count FROM logs WHERE timestamp >= ?", (last_24h,))
+            logs_last_24h = cursor.fetchone()['count']
+            
+            return {
+                'total_logs': total_logs,
+                'logs_by_level': logs_by_level,
+                'logs_by_category': logs_by_category,
+                'logs_last_24h': logs_last_24h,
+                'database_path': self.db_path
+            }
+
+# Instância global do logger
+_logger_instance = None
+
+def get_logger() -> DatabaseLogger:
+    """Retorna a instância global do logger"""
+    global _logger_instance
+    if _logger_instance is None:
+        _logger_instance = DatabaseLogger()
+    return _logger_instance
+
+def initialize_logger(db_path: str = "logs/application.db") -> DatabaseLogger:
+    """Inicializa o logger com um caminho específico"""
+    global _logger_instance
+    _logger_instance = DatabaseLogger(db_path)
+    return _logger_instance

src/ui/log_viewer.py

@@ -0,0 +1,453 @@
+import gradio as gr
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Tuple
+import json
+from ..core.database_logger import get_logger, LogLevel, LogCategory
+
+class LogViewer:
+    """Interface para visualização de logs"""
+    
+    def __init__(self):
+        self.logger = get_logger()
+    
+    def get_log_data(self, level_filter: str = "ALL", category_filter: str = "ALL",
+                    hours_back: int = 24, limit: int = 1000) -> pd.DataFrame:
+        """Recupera dados de log filtrados"""
+        
+        # Calcular tempo de início
+        start_time = (datetime.now() - timedelta(hours=hours_back)).isoformat()
+        
+        # Aplicar filtros
+        level = None if level_filter == "ALL" else level_filter
+        category = None if category_filter == "ALL" else category_filter
+        
+        # Buscar logs
+        logs = self.logger.get_logs(
+            level=level,
+            category=category,
+            start_time=start_time,
+            limit=limit
+        )
+        
+        if not logs:
+            return pd.DataFrame()
+        
+        # Converter para DataFrame
+        df = pd.DataFrame(logs)
+        df['timestamp'] = pd.to_datetime(df['timestamp'])
+        
+        return df
+    
+    def create_log_table(self, level_filter: str, category_filter: str, 
+                        hours_back: int, limit: int) -> str:
+        """Cria tabela HTML com os logs"""
+        
+        df = self.get_log_data(level_filter, category_filter, hours_back, limit)
+        
+        if df.empty:
+            return "<p>Nenhum log encontrado com os filtros aplicados.</p>"
+        
+        # Preparar dados para exibição
+        display_df = df[['timestamp', 'level', 'category', 'message', 'module', 'function']].copy()
+        display_df['timestamp'] = display_df['timestamp'].dt.strftime('%Y-%m-%d %H:%M:%S')
+        
+        # Aplicar cores baseadas no nível
+        def style_level(level):
+            colors = {
+                'DEBUG': '#6c757d',
+                'INFO': '#17a2b8',
+                'WARNING': '#ffc107',
+                'ERROR': '#dc3545',
+                'CRITICAL': '#6f42c1'
+            }
+            return f'<span style="color: {colors.get(level, "#000")}; font-weight: bold;">{level}</span>'
+        
+        display_df['level'] = display_df['level'].apply(style_level)
+        
+        # Converter para HTML
+        html_table = display_df.to_html(escape=False, index=False, classes='table table-striped')
+        
+        return f"""
+        <div style="max-height: 600px; overflow-y: auto;">
+            {html_table}
+        </div>
+        """
+    
+    def create_log_statistics(self, hours_back: int) -> str:
+        """Cria estatísticas dos logs"""
+        
+        stats = self.logger.get_statistics()
+        
+        # Logs das últimas N horas
+        start_time = (datetime.now() - timedelta(hours=hours_back)).isoformat()
+        recent_logs = self.logger.get_logs(start_time=start_time, limit=10000)
+        
+        recent_df = pd.DataFrame(recent_logs) if recent_logs else pd.DataFrame()
+        
+        html = f"""
+        <div class="row">
+            <div class="col-md-6">
+                <h4>📊 Estatísticas Gerais</h4>
+                <ul>
+                    <li><strong>Total de Logs:</strong> {stats['total_logs']:,}</li>
+                    <li><strong>Logs (últimas 24h):</strong> {stats['logs_last_24h']:,}</li>
+                    <li><strong>Logs (últimas {hours_back}h):</strong> {len(recent_df):,}</li>
+                </ul>
+            </div>
+            <div class="col-md-6">
+                <h4>📈 Distribuição por Nível</h4>
+                <ul>
+        """
+        
+        for level, count in stats['logs_by_level'].items():
+            html += f"<li><strong>{level}:</strong> {count:,}</li>"
+        
+        html += """
+                </ul>
+            </div>
+        </div>
+        <div class="row mt-3">
+            <div class="col-12">
+                <h4>🏷️ Distribuição por Categoria</h4>
+                <ul>
+        """
+        
+        for category, count in stats['logs_by_category'].items():
+            html += f"<li><strong>{category}:</strong> {count:,}</li>"
+        
+        html += """
+                </ul>
+            </div>
+        </div>
+        """
+        
+        return html
+    
+    def create_performance_chart(self, hours_back: int) -> go.Figure:
+        """Cria gráfico de métricas de performance"""
+        
+        start_time = (datetime.now() - timedelta(hours=hours_back)).isoformat()
+        metrics = self.logger.get_performance_metrics(start_time=start_time, limit=1000)
+        
+        if not metrics:
+            fig = go.Figure()
+            fig.add_annotation(
+                text="Nenhuma métrica de performance encontrada",
+                xref="paper", yref="paper",
+                x=0.5, y=0.5, showarrow=False
+            )
+            return fig
+        
+        df = pd.DataFrame(metrics)
+        df['timestamp'] = pd.to_datetime(df['timestamp'])
+        
+        # Agrupar por nome da métrica
+        fig = go.Figure()
+        
+        for metric_name in df['metric_name'].unique():
+            metric_data = df[df['metric_name'] == metric_name]
+            
+            fig.add_trace(go.Scatter(
+                x=metric_data['timestamp'],
+                y=metric_data['metric_value'],
+                mode='lines+markers',
+                name=metric_name,
+                hovertemplate='<b>%{fullData.name}</b><br>' +
+                             'Tempo: %{x}<br>' +
+                             'Valor: %{y}<br>' +
+                             '<extra></extra>'
+            ))
+        
+        fig.update_layout(
+            title="Métricas de Performance ao Longo do Tempo",
+            xaxis_title="Timestamp",
+            yaxis_title="Valor",
+            hovermode='closest'
+        )
+        
+        return fig
+    
+    def create_log_timeline_chart(self, hours_back: int) -> go.Figure:
+        """Cria gráfico de timeline dos logs"""
+        
+        start_time = (datetime.now() - timedelta(hours=hours_back)).isoformat()
+        logs = self.logger.get_logs(start_time=start_time, limit=5000)
+        
+        if not logs:
+            fig = go.Figure()
+            fig.add_annotation(
+                text="Nenhum log encontrado no período",
+                xref="paper", yref="paper",
+                x=0.5, y=0.5, showarrow=False
+            )
+            return fig
+        
+        df = pd.DataFrame(logs)
+        df['timestamp'] = pd.to_datetime(df['timestamp'])
+        
+        # Contar logs por hora e nível
+        df['hour'] = df['timestamp'].dt.floor('H')
+        log_counts = df.groupby(['hour', 'level']).size().reset_index(name='count')
+        
+        fig = go.Figure()
+        
+        colors = {
+            'DEBUG': '#6c757d',
+            'INFO': '#17a2b8',
+            'WARNING': '#ffc107',
+            'ERROR': '#dc3545',
+            'CRITICAL': '#6f42c1'
+        }
+        
+        for level in log_counts['level'].unique():
+            level_data = log_counts[log_counts['level'] == level]
+            
+            fig.add_trace(go.Bar(
+                x=level_data['hour'],
+                y=level_data['count'],
+                name=level,
+                marker_color=colors.get(level, '#000000')
+            ))
+        
+        fig.update_layout(
+            title="Distribuição de Logs por Hora e Nível",
+            xaxis_title="Hora",
+            yaxis_title="Quantidade de Logs",
+            barmode='stack'
+        )
+        
+        return fig
+    
+    def search_logs(self, search_term: str, hours_back: int) -> str:
+        """Busca logs por termo específico"""
+        
+        start_time = (datetime.now() - timedelta(hours=hours_back)).isoformat()
+        all_logs = self.logger.get_logs(start_time=start_time, limit=10000)
+        
+        if not all_logs:
+            return "<p>Nenhum log encontrado.</p>"
+        
+        # Filtrar logs que contêm o termo de busca
+        filtered_logs = [
+            log for log in all_logs 
+            if search_term.lower() in log['message'].lower() or 
+               search_term.lower() in log['module'].lower() or
+               search_term.lower() in log['function'].lower()
+        ]
+        
+        if not filtered_logs:
+            return f"<p>Nenhum log encontrado com o termo '{search_term}'.</p>"
+        
+        df = pd.DataFrame(filtered_logs)
+        df['timestamp'] = pd.to_datetime(df['timestamp'])
+        
+        # Preparar dados para exibição
+        display_df = df[['timestamp', 'level', 'category', 'message', 'module', 'function']].copy()
+        display_df['timestamp'] = display_df['timestamp'].dt.strftime('%Y-%m-%d %H:%M:%S')
+        
+        # Destacar termo de busca
+        def highlight_term(text, term):
+            if pd.isna(text):
+                return text
+            return str(text).replace(term, f'<mark>{term}</mark>')
+        
+        for col in ['message', 'module', 'function']:
+            display_df[col] = display_df[col].apply(lambda x: highlight_term(x, search_term))
+        
+        html_table = display_df.to_html(escape=False, index=False, classes='table table-striped')
+        
+        return f"""
+        <div style="max-height: 600px; overflow-y: auto;">
+            <p><strong>Encontrados {len(filtered_logs)} logs com o termo '{search_term}'</strong></p>
+            {html_table}
+        </div>
+        """
+    
+    def export_logs(self, level_filter: str, category_filter: str, 
+                   hours_back: int, format_type: str) -> str:
+        """Exporta logs em diferentes formatos"""
+        
+        df = self.get_log_data(level_filter, category_filter, hours_back, 10000)
+        
+        if df.empty:
+            return "Nenhum log para exportar."
+        
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        
+        if format_type == "CSV":
+            filename = f"logs_export_{timestamp}.csv"
+            df.to_csv(filename, index=False)
+            return f"Logs exportados para {filename}"
+        
+        elif format_type == "JSON":
+            filename = f"logs_export_{timestamp}.json"
+            df.to_json(filename, orient='records', date_format='iso')
+            return f"Logs exportados para {filename}"
+        
+        elif format_type == "HTML":
+            filename = f"logs_export_{timestamp}.html"
+            html_content = f"""
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <title>Relatório de Logs - {timestamp}</title>
+                <style>
+                    body {{ font-family: Arial, sans-serif; margin: 20px; }}
+                    table {{ border-collapse: collapse; width: 100%; }}
+                    th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
+                    th {{ background-color: #f2f2f2; }}
+                    .debug {{ color: #6c757d; }}
+                    .info {{ color: #17a2b8; }}
+                    .warning {{ color: #ffc107; }}
+                    .error {{ color: #dc3545; }}
+                    .critical {{ color: #6f42c1; }}
+                </style>
+            </head>
+            <body>
+                <h1>Relatório de Logs</h1>
+                <p>Gerado em: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</p>
+                <p>Total de registros: {len(df)}</p>
+                {df.to_html(escape=False, index=False, classes='table')}
+            </body>
+            </html>
+            """
+            
+            with open(filename, 'w', encoding='utf-8') as f:
+                f.write(html_content)
+            
+            return f"Relatório HTML exportado para {filename}"
+        
+        return "Formato não suportado."
+
+def create_log_viewer_interface() -> gr.Blocks:
+    """Cria a interface do visualizador de logs"""
+    
+    viewer = LogViewer()
+    
+    with gr.Blocks(title="📊 Visualizador de Logs") as interface:
+        gr.Markdown("# 📊 Sistema de Visualização de Logs")
+        
+        with gr.Tab("📋 Logs Recentes"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    level_filter = gr.Dropdown(
+                        choices=["ALL"] + [level.value for level in LogLevel],
+                        value="ALL",
+                        label="Filtrar por Nível"
+                    )
+                    category_filter = gr.Dropdown(
+                        choices=["ALL"] + [cat.value for cat in LogCategory],
+                        value="ALL",
+                        label="Filtrar por Categoria"
+                    )
+                    hours_back = gr.Slider(
+                        minimum=1, maximum=168, value=24, step=1,
+                        label="Horas Anteriores"
+                    )
+                    limit = gr.Slider(
+                        minimum=10, maximum=5000, value=100, step=10,
+                        label="Limite de Registros"
+                    )
+                    refresh_btn = gr.Button("🔄 Atualizar", variant="primary")
+                
+                with gr.Column(scale=3):
+                    log_table = gr.HTML(label="Logs")
+            
+            refresh_btn.click(
+                fn=viewer.create_log_table,
+                inputs=[level_filter, category_filter, hours_back, limit],
+                outputs=log_table
+            )
+        
+        with gr.Tab("📊 Estatísticas"):
+            with gr.Row():
+                stats_hours = gr.Slider(
+                    minimum=1, maximum=168, value=24, step=1,
+                    label="Período (horas)"
+                )
+                stats_refresh_btn = gr.Button("🔄 Atualizar Estatísticas", variant="primary")
+            
+            stats_html = gr.HTML(label="Estatísticas")
+            
+            stats_refresh_btn.click(
+                fn=viewer.create_log_statistics,
+                inputs=[stats_hours],
+                outputs=stats_html
+            )
+        
+        with gr.Tab("📈 Gráficos"):
+            with gr.Row():
+                chart_hours = gr.Slider(
+                    minimum=1, maximum=168, value=24, step=1,
+                    label="Período (horas)"
+                )
+                chart_refresh_btn = gr.Button("🔄 Atualizar Gráficos", variant="primary")
+            
+            with gr.Row():
+                timeline_chart = gr.Plot(label="Timeline de Logs")
+                performance_chart = gr.Plot(label="Métricas de Performance")
+            
+            chart_refresh_btn.click(
+                fn=lambda hours: (viewer.create_log_timeline_chart(hours), viewer.create_performance_chart(hours)),
+                inputs=[chart_hours],
+                outputs=[timeline_chart, performance_chart]
+            )
+        
+        with gr.Tab("🔍 Busca"):
+            with gr.Row():
+                search_term = gr.Textbox(label="Termo de Busca", placeholder="Digite o termo para buscar...")
+                search_hours = gr.Slider(
+                    minimum=1, maximum=168, value=24, step=1,
+                    label="Período (horas)"
+                )
+                search_btn = gr.Button("🔍 Buscar", variant="primary")
+            
+            search_results = gr.HTML(label="Resultados da Busca")
+            
+            search_btn.click(
+                fn=viewer.search_logs,
+                inputs=[search_term, search_hours],
+                outputs=search_results
+            )
+        
+        with gr.Tab("📤 Exportar"):
+            with gr.Row():
+                export_level = gr.Dropdown(
+                    choices=["ALL"] + [level.value for level in LogLevel],
+                    value="ALL",
+                    label="Filtrar por Nível"
+                )
+                export_category = gr.Dropdown(
+                    choices=["ALL"] + [cat.value for cat in LogCategory],
+                    value="ALL",
+                    label="Filtrar por Categoria"
+                )
+                export_hours = gr.Slider(
+                    minimum=1, maximum=168, value=24, step=1,
+                    label="Período (horas)"
+                )
+                export_format = gr.Dropdown(
+                    choices=["CSV", "JSON", "HTML"],
+                    value="CSV",
+                    label="Formato"
+                )
+                export_btn = gr.Button("📤 Exportar", variant="primary")
+            
+            export_result = gr.Textbox(label="Resultado da Exportação")
+            
+            export_btn.click(
+                fn=viewer.export_logs,
+                inputs=[export_level, export_category, export_hours, export_format],
+                outputs=export_result
+            )
+        
+        # Carregar dados iniciais
+        interface.load(
+            fn=lambda: (viewer.create_log_table("ALL", "ALL", 24, 100), viewer.create_log_statistics(24)),
+            outputs=[log_table, stats_html]
+        )
+    
+    return interface

src/utils/logging_decorators.py

@@ -0,0 +1,381 @@
+import functools
+import time
+import traceback
+import inspect
+from typing import Any, Callable, Optional
+from ..core.database_logger import get_logger, LogLevel, LogCategory
+
+def log_execution(category: LogCategory = LogCategory.SYSTEM, 
+                 log_args: bool = False, 
+                 log_result: bool = False,
+                 log_performance: bool = True):
+    """Decorador para logging automático de execução de funções"""
+    
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            logger = get_logger()
+            
+            # Informações da função
+            module_name = func.__module__
+            function_name = func.__name__
+            
+            # Obter número da linha
+            try:
+                line_number = inspect.getsourcelines(func)[1]
+            except:
+                line_number = 0
+            
+            # Preparar metadados
+            metadata = {
+                'function_signature': str(inspect.signature(func))
+            }
+            
+            if log_args:
+                metadata['args'] = str(args)
+                metadata['kwargs'] = str(kwargs)
+            
+            start_time = time.time()
+            
+            try:
+                # Log de início da execução
+                logger.log(
+                    level=LogLevel.DEBUG,
+                    category=category,
+                    message=f"Iniciando execução da função {function_name}",
+                    module=module_name,
+                    function=function_name,
+                    line_number=line_number,
+                    metadata=metadata
+                )
+                
+                # Executar função
+                result = func(*args, **kwargs)
+                
+                execution_time = time.time() - start_time
+                
+                # Preparar metadados do resultado
+                result_metadata = metadata.copy()
+                if log_result:
+                    result_metadata['result'] = str(result)[:1000]  # Limitar tamanho
+                
+                # Log de sucesso
+                logger.log(
+                    level=LogLevel.INFO,
+                    category=category,
+                    message=f"Função {function_name} executada com sucesso",
+                    module=module_name,
+                    function=function_name,
+                    line_number=line_number,
+                    metadata=result_metadata,
+                    execution_time=execution_time
+                )
+                
+                # Log de performance se habilitado
+                if log_performance:
+                    logger.log_performance_metric(
+                        metric_name=f"{module_name}.{function_name}_execution_time",
+                        metric_value=execution_time,
+                        unit="seconds",
+                        category=category.value,
+                        metadata={'function': function_name, 'module': module_name}
+                    )
+                
+                return result
+                
+            except Exception as e:
+                execution_time = time.time() - start_time
+                
+                # Log de erro
+                logger.log(
+                    level=LogLevel.ERROR,
+                    category=category,
+                    message=f"Erro na execução da função {function_name}: {str(e)}",
+                    module=module_name,
+                    function=function_name,
+                    line_number=line_number,
+                    metadata=metadata,
+                    stack_trace=traceback.format_exc(),
+                    execution_time=execution_time
+                )
+                
+                raise
+        
+        return wrapper
+    return decorator
+
+def log_api_call(endpoint: str = None):
+    """Decorador específico para logging de chamadas de API"""
+    
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            logger = get_logger()
+            
+            module_name = func.__module__
+            function_name = func.__name__
+            
+            try:
+                line_number = inspect.getsourcelines(func)[1]
+            except:
+                line_number = 0
+            
+            # Extrair informações da requisição se disponível
+            request_info = {}
+            if 'request' in kwargs:
+                request = kwargs['request']
+                request_info = {
+                    'method': getattr(request, 'method', 'UNKNOWN'),
+                    'url': getattr(request, 'url', 'UNKNOWN'),
+                    'user_agent': getattr(request, 'headers', {}).get('user-agent', 'UNKNOWN')
+                }
+            
+            metadata = {
+                'endpoint': endpoint or function_name,
+                'request_info': request_info
+            }
+            
+            start_time = time.time()
+            
+            try:
+                # Log início da chamada API
+                logger.log(
+                    level=LogLevel.INFO,
+                    category=LogCategory.API,
+                    message=f"Chamada API iniciada: {endpoint or function_name}",
+                    module=module_name,
+                    function=function_name,
+                    line_number=line_number,
+                    metadata=metadata
+                )
+                
+                result = func(*args, **kwargs)
+                execution_time = time.time() - start_time
+                
+                # Log sucesso da API
+                logger.log(
+                    level=LogLevel.INFO,
+                    category=LogCategory.API,
+                    message=f"Chamada API concluída com sucesso: {endpoint or function_name}",
+                    module=module_name,
+                    function=function_name,
+                    line_number=line_number,
+                    metadata=metadata,
+                    execution_time=execution_time
+                )
+                
+                # Métrica de performance da API
+                logger.log_performance_metric(
+                    metric_name=f"api_{endpoint or function_name}_response_time",
+                    metric_value=execution_time,
+                    unit="seconds",
+                    category="API",
+                    metadata={'endpoint': endpoint or function_name}
+                )
+                
+                return result
+                
+            except Exception as e:
+                execution_time = time.time() - start_time
+                
+                logger.log(
+                    level=LogLevel.ERROR,
+                    category=LogCategory.API,
+                    message=f"Erro na chamada API {endpoint or function_name}: {str(e)}",
+                    module=module_name,
+                    function=function_name,
+                    line_number=line_number,
+                    metadata=metadata,
+                    stack_trace=traceback.format_exc(),
+                    execution_time=execution_time
+                )
+                
+                raise
+        
+        return wrapper
+    return decorator
+
+def log_ai_model_usage(model_name: str = None):
+    """Decorador para logging de uso de modelos de IA"""
+    
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            logger = get_logger()
+            
+            module_name = func.__module__
+            function_name = func.__name__
+            
+            try:
+                line_number = inspect.getsourcelines(func)[1]
+            except:
+                line_number = 0
+            
+            metadata = {
+                'model_name': model_name or function_name,
+                'input_size': len(str(args)) + len(str(kwargs))
+            }
+            
+            start_time = time.time()
+            
+            try:
+                logger.log(
+                    level=LogLevel.INFO,
+                    category=LogCategory.AI_MODEL,
+                    message=f"Iniciando processamento do modelo {model_name or function_name}",
+                    module=module_name,
+                    function=function_name,
+                    line_number=line_number,
+                    metadata=metadata
+                )
+                
+                result = func(*args, **kwargs)
+                execution_time = time.time() - start_time
+                
+                # Atualizar metadados com informações do resultado
+                result_metadata = metadata.copy()
+                result_metadata['output_size'] = len(str(result))
+                
+                logger.log(
+                    level=LogLevel.INFO,
+                    category=LogCategory.AI_MODEL,
+                    message=f"Modelo {model_name or function_name} processado com sucesso",
+                    module=module_name,
+                    function=function_name,
+                    line_number=line_number,
+                    metadata=result_metadata,
+                    execution_time=execution_time
+                )
+                
+                # Métricas específicas de IA
+                logger.log_performance_metric(
+                    metric_name=f"ai_model_{model_name or function_name}_inference_time",
+                    metric_value=execution_time,
+                    unit="seconds",
+                    category="AI_MODEL",
+                    metadata={
+                        'model': model_name or function_name,
+                        'input_size': metadata['input_size'],
+                        'output_size': result_metadata['output_size']
+                    }
+                )
+                
+                return result
+                
+            except Exception as e:
+                execution_time = time.time() - start_time
+                
+                logger.log(
+                    level=LogLevel.ERROR,
+                    category=LogCategory.AI_MODEL,
+                    message=f"Erro no modelo {model_name or function_name}: {str(e)}",
+                    module=module_name,
+                    function=function_name,
+                    line_number=line_number,
+                    metadata=metadata,
+                    stack_trace=traceback.format_exc(),
+                    execution_time=execution_time
+                )
+                
+                raise
+        
+        return wrapper
+    return decorator
+
+class LoggingContext:
+    """Context manager para logging de blocos de código"""
+    
+    def __init__(self, operation_name: str, category: LogCategory = LogCategory.SYSTEM,
+                 level: LogLevel = LogLevel.INFO, metadata: dict = None):
+        self.operation_name = operation_name
+        self.category = category
+        self.level = level
+        self.metadata = metadata or {}
+        self.logger = get_logger()
+        self.start_time = None
+    
+    def __enter__(self):
+        self.start_time = time.time()
+        
+        # Obter informações do caller
+        frame = inspect.currentframe().f_back
+        module_name = frame.f_globals.get('__name__', 'unknown')
+        function_name = frame.f_code.co_name
+        line_number = frame.f_lineno
+        
+        self.logger.log(
+            level=self.level,
+            category=self.category,
+            message=f"Iniciando operação: {self.operation_name}",
+            module=module_name,
+            function=function_name,
+            line_number=line_number,
+            metadata=self.metadata
+        )
+        
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        execution_time = time.time() - self.start_time
+        
+        # Obter informações do caller
+        frame = inspect.currentframe().f_back
+        module_name = frame.f_globals.get('__name__', 'unknown')
+        function_name = frame.f_code.co_name
+        line_number = frame.f_lineno
+        
+        if exc_type is None:
+            # Sucesso
+            self.logger.log(
+                level=self.level,
+                category=self.category,
+                message=f"Operação concluída com sucesso: {self.operation_name}",
+                module=module_name,
+                function=function_name,
+                line_number=line_number,
+                metadata=self.metadata,
+                execution_time=execution_time
+            )
+        else:
+            # Erro
+            self.logger.log(
+                level=LogLevel.ERROR,
+                category=self.category,
+                message=f"Erro na operação {self.operation_name}: {str(exc_val)}",
+                module=module_name,
+                function=function_name,
+                line_number=line_number,
+                metadata=self.metadata,
+                stack_trace=traceback.format_exc(),
+                execution_time=execution_time
+            )
+        
+        # Log de performance
+        self.logger.log_performance_metric(
+            metric_name=f"operation_{self.operation_name.replace(' ', '_')}_time",
+            metric_value=execution_time,
+            unit="seconds",
+            category=self.category.value,
+            metadata={'operation': self.operation_name}
+        )
+
+def quick_log(message: str, level: LogLevel = LogLevel.INFO, 
+             category: LogCategory = LogCategory.SYSTEM, **kwargs):
+    """Função utilitária para logging rápido"""
+    logger = get_logger()
+    
+    # Obter informações do caller
+    frame = inspect.currentframe().f_back
+    module_name = frame.f_globals.get('__name__', 'unknown')
+    function_name = frame.f_code.co_name
+    line_number = frame.f_lineno
+    
+    logger.log(
+        level=level,
+        category=category,
+        message=message,
+        module=module_name,
+        function=function_name,
+        line_number=line_number,
+        **kwargs
+    )

test_logging_system.py

@@ -0,0 +1,324 @@
+#!/usr/bin/env python3
+"""
+Script de teste para o sistema de logging avançado.
+Testa todas as funcionalidades do sistema de logging com SQLite3.
+"""
+
+import os
+import sys
+import time
+import json
+from datetime import datetime
+
+# Adicionar o diretório src ao path
+src_path = os.path.join(os.path.dirname(__file__), 'src')
+sys.path.insert(0, src_path)
+
+try:
+    from src.core.database_logger import DatabaseLogger, LogLevel, LogCategory
+    from src.utils.logging_decorators import log_execution, log_api_call, log_ai_model_usage, LoggingContext, quick_log
+except ImportError as e:
+    print(f"❌ Erro ao importar módulos de logging: {e}")
+    print("Tentando importação alternativa...")
+    try:
+        # Importação direta dos arquivos
+        import importlib.util
+        
+        # Carregar database_logger
+        spec = importlib.util.spec_from_file_location(
+            "database_logger", 
+            os.path.join(src_path, "core", "database_logger.py")
+        )
+        db_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(db_module)
+        
+        DatabaseLogger = db_module.DatabaseLogger
+        LogLevel = db_module.LogLevel
+        LogCategory = db_module.LogCategory
+        
+        # Carregar logging_decorators
+        spec2 = importlib.util.spec_from_file_location(
+            "logging_decorators", 
+            os.path.join(src_path, "utils", "logging_decorators.py")
+        )
+        dec_module = importlib.util.module_from_spec(spec2)
+        spec2.loader.exec_module(dec_module)
+        
+        log_execution = dec_module.log_execution
+        log_api_call = dec_module.log_api_call
+        log_ai_model_usage = dec_module.log_ai_model_usage
+        LoggingContext = dec_module.LoggingContext
+        quick_log = dec_module.quick_log
+        
+        print("✅ Importação alternativa bem-sucedida")
+        
+    except Exception as e2:
+        print(f"❌ Erro na importação alternativa: {e2}")
+        sys.exit(1)
+
+def test_basic_logging():
+    """Testa funcionalidades básicas de logging."""
+    print("\n🧪 Testando logging básico...")
+    
+    # Criar diretório de logs se não existir
+    os.makedirs('logs', exist_ok=True)
+    
+    # Inicializar logger
+    db_logger = DatabaseLogger('logs/test_logging.db')
+    
+    # Teste 1: Log simples
+    db_logger.log(
+        level=LogLevel.INFO,
+        category=LogCategory.SYSTEM,
+        message="Teste de log básico",
+        module="test_logging_system",
+        function="test_basic_logging",
+        line_number=70
+    )
+    
+    # Teste 2: Log com metadados
+    db_logger.log(
+        level=LogLevel.DEBUG,
+        category=LogCategory.API,
+        message="Teste com metadados",
+        module="test_logging_system",
+        function="test_basic_logging",
+        line_number=80,
+        metadata={'test_id': 1, 'timestamp': datetime.now().isoformat()}
+    )
+    
+    # Teste 3: Log de erro
+    db_logger.log(
+        level=LogLevel.ERROR,
+        category=LogCategory.SYSTEM,
+        message="Teste de log de erro",
+        module="test_logging_system",
+        function="test_basic_logging",
+        line_number=90,
+        execution_time=0.001
+    )
+    
+    print("✅ Logging básico funcionando")
+    return db_logger
+
+def test_performance_metrics(db_logger):
+    """Testa logging de métricas de performance."""
+    print("\n🧪 Testando métricas de performance...")
+    
+    # Teste 1: Métrica de tempo de resposta
+    db_logger.log_performance_metric(
+        metric_name="response_time",
+        metric_value=0.150,
+        unit="seconds",
+        category="api_performance"
+    )
+    
+    # Teste 2: Métrica de uso de memória
+    db_logger.log_performance_metric(
+        metric_name="memory_usage",
+        metric_value=256.5,
+        unit="MB",
+        category="system_resources"
+    )
+    
+    # Teste 3: Métrica de throughput
+    db_logger.log_performance_metric(
+        metric_name="requests_per_second",
+        metric_value=45.2,
+        unit="req/s",
+        category="performance",
+        metadata={'endpoint': '/api/analyze'}
+    )
+    
+    print("✅ Métricas de performance funcionando")
+
+def test_system_events(db_logger):
+    """Testa logging de eventos do sistema."""
+    print("\n🧪 Testando eventos do sistema...")
+    
+    # Teste 1: Evento de inicialização
+    db_logger.log_system_event(
+        event_type="STARTUP",
+        event_name="SERVICE_STARTED",
+        description="Serviço de teste iniciado",
+        severity="INFO"
+    )
+    
+    # Teste 2: Evento de erro
+    db_logger.log_system_event(
+        event_type="ERROR",
+        event_name="CONNECTION_FAILED",
+        description="Falha na conexão com API externa",
+        severity="ERROR",
+        metadata={'api_endpoint': 'https://api.example.com', 'error_code': 500}
+    )
+    
+    # Teste 3: Evento de alerta
+    db_logger.log_system_event(
+        event_type="ALERT",
+        event_name="HIGH_CPU_USAGE",
+        description="Uso de CPU acima de 80%",
+        severity="WARNING",
+        metadata={'cpu_usage': 85.2, 'threshold': 80}
+    )
+    
+    print("✅ Eventos do sistema funcionando")
+
+@log_execution(LogCategory.SYSTEM, log_performance=True)
+def test_function_with_decorator():
+    """Função de teste com decorador de logging."""
+    time.sleep(0.1)  # Simular processamento
+    return "Resultado do teste"
+
+@log_api_call("test_api")
+def test_api_function():
+    """Função de teste para chamada de API."""
+    time.sleep(0.05)  # Simular chamada de API
+    return {'status': 'success', 'data': 'test_data'}
+
+@log_ai_model_usage("test_model")
+def test_ai_model_function():
+    """Função de teste para uso de modelo IA."""
+    time.sleep(0.2)  # Simular processamento de IA
+    return {'prediction': 0.85, 'confidence': 0.92}
+
+def test_decorators():
+    """Testa os decoradores de logging."""
+    print("\n🧪 Testando decoradores...")
+    
+    # Teste 1: Decorador de execução
+    result1 = test_function_with_decorator()
+    print(f"Resultado função com decorador: {result1}")
+    
+    # Teste 2: Decorador de API
+    result2 = test_api_function()
+    print(f"Resultado API: {result2}")
+    
+    # Teste 3: Decorador de modelo IA
+    result3 = test_ai_model_function()
+    print(f"Resultado modelo IA: {result3}")
+    
+    print("✅ Decoradores funcionando")
+
+def test_context_manager():
+    """Testa o gerenciador de contexto."""
+    print("\n🧪 Testando gerenciador de contexto...")
+    
+    with LoggingContext("Processamento de teste", LogLevel.INFO, LogCategory.SYSTEM):
+        time.sleep(0.1)
+        print("Executando dentro do contexto de logging")
+    
+    print("✅ Gerenciador de contexto funcionando")
+
+def test_quick_log():
+    """Testa a função de logging rápido."""
+    print("\n🧪 Testando logging rápido...")
+    
+    # Log simples
+    quick_log("Teste de log rápido", LogLevel.INFO, LogCategory.SYSTEM)
+    
+    # Log com metadados
+    quick_log(
+        "Teste com metadados", 
+        LogLevel.DEBUG, 
+        LogCategory.API,
+        metadata={'test': True, 'value': 42}
+    )
+    
+    print("✅ Logging rápido funcionando")
+
+def test_log_retrieval(db_logger):
+    """Testa recuperação e filtragem de logs."""
+    print("\n🧪 Testando recuperação de logs...")
+    
+    # Teste 1: Buscar todos os logs
+    all_logs = db_logger.get_logs(limit=10)
+    print(f"Total de logs encontrados: {len(all_logs)}")
+    
+    # Teste 2: Filtrar por nível
+    error_logs = db_logger.get_logs(level="ERROR", limit=5)
+    print(f"Logs de erro: {len(error_logs)}")
+    
+    # Teste 3: Filtrar por categoria
+    system_logs = db_logger.get_logs(category="SYSTEM", limit=5)
+    print(f"Logs do sistema: {len(system_logs)}")
+    
+    # Teste 4: Buscar métricas de performance
+    metrics = db_logger.get_performance_metrics(limit=5)
+    print(f"Métricas encontradas: {len(metrics)}")
+    
+    # Teste 5: Buscar eventos do sistema
+    events = db_logger.get_system_events(limit=5)
+    print(f"Eventos do sistema: {len(events)}")
+    
+    print("✅ Recuperação de logs funcionando")
+
+def test_statistics(db_logger):
+    """Testa geração de estatísticas."""
+    print("\n🧪 Testando estatísticas...")
+    
+    stats = db_logger.get_statistics()
+    print(f"Estatísticas: {json.dumps(stats, indent=2)}")
+    
+    print("✅ Estatísticas funcionando")
+
+def test_cleanup(db_logger):
+    """Testa limpeza de logs antigos."""
+    print("\n🧪 Testando limpeza...")
+    
+    # Não vamos fazer limpeza real nos testes, apenas verificar se o método existe
+    try:
+        # db_logger.cleanup_old_logs(days_to_keep=0)  # Comentado para não apagar logs de teste
+        print("Método de limpeza disponível")
+    except Exception as e:
+        print(f"Erro na limpeza: {e}")
+    
+    print("✅ Limpeza funcionando")
+
+def main():
+    """Função principal de teste."""
+    print("🚀 Iniciando testes do sistema de logging avançado")
+    print("=" * 60)
+    
+    try:
+        # Testes básicos
+        db_logger = test_basic_logging()
+        test_performance_metrics(db_logger)
+        test_system_events(db_logger)
+        
+        # Testes de decoradores (se disponíveis)
+        try:
+            test_decorators()
+            test_context_manager()
+            test_quick_log()
+        except Exception as e:
+            print(f"⚠️ Alguns decoradores não funcionaram: {e}")
+        
+        # Testes de recuperação
+        test_log_retrieval(db_logger)
+        test_statistics(db_logger)
+        test_cleanup(db_logger)
+        
+        print("\n" + "=" * 60)
+        print("✅ Todos os testes concluídos com sucesso!")
+        print(f"📁 Logs salvos em: logs/test_logging.db")
+        
+        # Mostrar algumas estatísticas finais
+        final_stats = db_logger.get_statistics()
+        print(f"\n📊 Estatísticas finais:")
+        print(f"   Total de logs: {final_stats.get('total_logs', 0)}")
+        print(f"   Logs por nível: {final_stats.get('logs_by_level', {})}")
+        print(f"   Logs por categoria: {final_stats.get('logs_by_category', {})}")
+        print(f"   Logs últimas 24h: {final_stats.get('logs_last_24h', 0)}")
+        
+    except Exception as e:
+        print(f"\n❌ Erro durante os testes: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+    
+    return 0
+
+if __name__ == "__main__":
+    exit_code = main()
+    sys.exit(exit_code)