Update utils/debug_utils.py

utils/debug_utils.py

@@ -1,33 +1,51 @@
 # FILE: utils/debug_utils.py
-# DESCRIPTION: A utility for detailed function logging and debugging.
+# DESCRIPTION: Utility for detailed function logging with persistent file output.
 
 import os
 import functools
 import torch
-
-# Define o nível de log. Mude para "INFO" para desativar os logs detalhados.
-# Você pode controlar isso com uma variável de ambiente.
 import logging
 import warnings
+from huggingface_hub import logging as hf_logging
+
+# --- CONFIGURAÇÃO INICIAL ---
 warnings.filterwarnings("ignore", category=UserWarning)
 warnings.filterwarnings("ignore", category=FutureWarning)
 warnings.filterwarnings("ignore", message=".*")
-from huggingface_hub import logging as ll
-ll.set_verbosity_error()
-ll.set_verbosity_warning()
-ll.set_verbosity_info()
-ll.set_verbosity_debug()
+hf_logging.set_verbosity_error()
+
+LOG_LEVEL = os.environ.get("ADUC_LOG_LEVEL", "DEBUG").upper()
+# --- NOVO CAMINHO PADRONIZADO PARA O LOG DA SESSÃO ATUAL ---
+LOG_DIR = "/data/logs"
+LOG_FILE_PATH = os.path.join(LOG_DIR, "session.log")
+
+# --- CONFIGURAÇÃO DO LOGGER ---
 
-LOG_LEVEL = "DEBUG" #os.environ.get("ADUC_LOG_LEVEL", "DEBUG").upper()
-logging.basicConfig(level=LOG_LEVEL, format='%(message)s')
+# 1. Cria o diretório de log se ele não existir
+os.makedirs(LOG_DIR, exist_ok=True)
+
+# 2. Obtém o logger principal
 logger = logging.getLogger("AducDebug")
+logger.setLevel(LOG_LEVEL)
+
+# 3. Evita adicionar handlers duplicados (importante em ambientes interativos)
+if not logger.handlers:
+    # Handler para o arquivo de log persistente. 'w' para começar um novo log a cada sessão.
+    # O start.sh já terá movido o log antigo.
+    file_handler = logging.FileHandler(LOG_FILE_PATH, mode='w')
+    file_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+    file_handler.setFormatter(file_formatter)
+    logger.addHandler(file_handler)
 
-logging.basicConfig(level=logging.DEBUG)
-logger.setLevel(logging.DEBUG)
+    # Handler para o console (terminal)
+    stream_handler = logging.StreamHandler()
+    stream_formatter = logging.Formatter('%(message)s') # Formato limpo para o terminal
+    stream_handler.setFormatter(stream_formatter)
+    logger.addHandler(stream_handler)
 
+# --- FUNÇÕES DO DECORADOR ---
 
 def _format_value(value):
-    """Formata os valores dos argumentos para uma exibição concisa e informativa."""
     if isinstance(value, torch.Tensor):
         return f"Tensor(shape={list(value.shape)}, device='{value.device}', dtype={value.dtype})"
     if isinstance(value, str) and len(value) > 70:
@@ -39,45 +57,29 @@ def _format_value(value):
     return repr(value)
 
 def log_function_io(func):
-    """
-    Um decorador que registra as entradas, saídas e exceções de uma função.
-    Ele é ativado apenas se o nível de log estiver definido como DEBUG.
-    """
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
-        # Só executa a lógica de log se o nível for DEBUG
         if logger.isEnabledFor(logging.DEBUG):
-            # Obtém o nome do módulo e da função
             func_name = f"{func.__module__}.{func.__name__}"
-            
-            # Formata os argumentos de entrada
             args_repr = [_format_value(a) for a in args]
             kwargs_repr = {k: _format_value(v) for k, v in kwargs.items()}
             signature = ", ".join(args_repr + [f"{k}={v}" for k, v in kwargs_repr.items()])
 
-            # Log de Entrada
             logger.debug(f"\n\n== INÍCIO: {func_name} ==========")
             logger.debug(f"\n  -> ENTRADA: \n({signature})")
 
             try:
-                # Executa a função original
                 result = func(*args, **kwargs)
-                
-                # Formata e registra o resultado
                 result_repr = _format_value(result)
                 logger.debug(f"\n\n  <- SAÍDA: \n{result_repr}")
-                
             except Exception as e:
-                # Registra qualquer exceção que ocorra
                 logger.error(f"\n  <-- ERRO em \n{func_name}: {e}", exc_info=True)
-                raise  # Re-lança a exceção para não alterar o comportamento do programa
+                raise
             finally:
-                # Log de Fim
                 logger.debug(f"============================================\n\n")
             
             return result
         else:
-            # Se o log não estiver em modo DEBUG, executa a função sem nenhum overhead.
             return func(*args, **kwargs)
             
     return wrapper