From 006687f250b2449f0b6783f000ec6298d0b4cc0b Mon Sep 17 00:00:00 2001 From: Ricardo Date: Thu, 8 Oct 2026 14:18:46 -0300 Subject: [PATCH] Corrige pool esgotado e erros do Holmes sem mensagem MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Rota de notas não segura conexão do banco enquanto espera o Holmes - Contador de chamadas usa conexão própria e curta quando não recebe uma - Timeout do Holmes sobe de 5s (padrão do httpx) para 30s - Erros passam a registrar o tipo (timeouts vinham com mensagem vazia) e traceback - Log também gravado em api.log, inclusive os erros 500 do uvicorn Co-Authored-By: Claude Opus 5.5 (1M context) --- app/utils/api_tracker.py | 55 +++++++++----- app/utils/holmes.py | 101 ++++++++++++++------------ app/v1/modules/escrituracao/router.py | 21 ++++-- main.py | 14 +++- 4 files changed, 115 insertions(+), 76 deletions(-) diff --git a/app/utils/api_tracker.py b/app/utils/api_tracker.py index 29c8459..24ff704 100644 --- a/app/utils/api_tracker.py +++ b/app/utils/api_tracker.py @@ -2,9 +2,13 @@ import logging from sqlalchemy.pool import PoolProxiedConnection +from app.core.database import engine + +logger = logging.getLogger('api_podium') + def registrar_contador( - conn: PoolProxiedConnection, + conn: PoolProxiedConnection | None, api: str, endpoint: str, metodo: str, @@ -13,25 +17,36 @@ def registrar_contador( duracao_ms: float, erro: str | None = None, ) -> None: - """Grava uma linha na tabela contadores_api. Falha aqui não derruba a chamada principal.""" - cursor = conn.cursor() + """Grava uma linha na tabela contadores_api. Falha aqui não derruba a chamada principal. + + Sem conn, pega uma conexão do pool só pro INSERT e devolve logo em seguida. + """ + conexao_propria = conn is None try: - cursor.execute(""" - INSERT INTO contadores_api - (api, endpoint, metodo_http, status_code, sucesso, duracao_ms, mensagem_erro) - VALUES (?, ?, ?, ?, ?, ?, ?) - """, ( - api, - endpoint, - metodo, - status_code, - 'S' if sucesso else 'N', - round(duracao_ms, 2), - erro[:500] if erro else None, - )) - conn.commit() + if conexao_propria: + conn = engine.raw_connection() + cursor = conn.cursor() + try: + cursor.execute(""" + INSERT INTO contadores_api + (api, endpoint, metodo_http, status_code, sucesso, duracao_ms, mensagem_erro) + VALUES (?, ?, ?, ?, ?, ?, ?) + """, ( + api, + endpoint, + metodo, + status_code, + 'S' if sucesso else 'N', + round(duracao_ms, 2), + erro[:500] if erro else None, + )) + conn.commit() + finally: + cursor.close() except Exception as e: - conn.rollback() - logging.error(f'Falha ao gravar contador: {e}') + if conn is not None: + conn.rollback() + logger.error(f'Falha ao gravar contador: {type(e).__name__}: {e}') finally: - cursor.close() + if conexao_propria and conn is not None: + conn.close() diff --git a/app/utils/holmes.py b/app/utils/holmes.py index fd4c128..c2e5e7a 100644 --- a/app/utils/holmes.py +++ b/app/utils/holmes.py @@ -10,6 +10,11 @@ from sqlalchemy.pool import PoolProxiedConnection from app.core.configs import settings from app.utils.api_tracker import registrar_contador +logger = logging.getLogger("api_podium") + +# O padrão do httpx é 5s, pouco pro Holmes em horário de pico +HOLMES_TIMEOUT = httpx.Timeout(30.0, connect=10.0) + _TOKEN_FILE = os.path.join(tempfile.gettempdir(), "holmes_token_cache.json") async def get_header() -> tuple[dict, str]: @@ -22,7 +27,7 @@ async def _holmes_request( api_nome: str = "holmes" for tentativa in range(2): header, api_nome = await get_header() - async with httpx.AsyncClient() as client: + async with httpx.AsyncClient(timeout=HOLMES_TIMEOUT) as client: response = await getattr(client, method)(url, headers=header, **kwargs) return response, api_nome raise RuntimeError("Holmes: falha de autenticação após retry") @@ -46,12 +51,12 @@ async def get_holmes_process(id_processo: str, conn: PoolProxiedConnection): return response.json() except httpx.HTTPStatusError as e: status = e.response.status_code - erro = str(e) - logging.error(f"Erro na API Holmes (ID {id_processo}): {e}") + erro = f"{type(e).__name__}: {e}" + logger.error(f"Erro na API Holmes (ID {id_processo}): {e}") return None except Exception as e: - erro = str(e) - logging.error(f"Erro inesperado ao consultar Holmes: {e}") + erro = f"{type(e).__name__}: {e}" + logger.exception(f"Erro inesperado ao consultar Holmes: {type(e).__name__}: {e}") return None finally: duracao = (time.perf_counter() - inicio) * 1000 @@ -86,12 +91,12 @@ async def get_holmes_process_details(id_processo: str, conn: PoolProxiedConnecti return response.json() except httpx.HTTPStatusError as e: status = e.response.status_code - erro = str(e) - logging.error(f"Erro na API Holmes details (ID {id_processo}): {e}") + erro = f"{type(e).__name__}: {e}" + logger.error(f"Erro na API Holmes details (ID {id_processo}): {e}") return None except Exception as e: - erro = str(e) - logging.error(f"Erro inesperado ao consultar Holmes details: {e}") + erro = f"{type(e).__name__}: {e}" + logger.exception(f"Erro inesperado ao consultar Holmes details: {type(e).__name__}: {e}") return None finally: duracao = (time.perf_counter() - inicio) * 1000 @@ -107,7 +112,7 @@ async def get_holmes_process_details(id_processo: str, conn: PoolProxiedConnecti ) -async def get_holmes_history(id_processo: str, conn: PoolProxiedConnection): +async def get_holmes_history(id_processo: str, conn: PoolProxiedConnection | None = None): """ Busca o historico no holmes (importante para pegar o id da ultima task, para avançar futuramente) Args: @@ -134,12 +139,12 @@ async def get_holmes_history(id_processo: str, conn: PoolProxiedConnection): return response.json() except httpx.HTTPStatusError as e: status = e.response.status_code - erro = str(e) - logging.error(f"Erro na API Holmes (ID {id_processo}): {e}") + erro = f"{type(e).__name__}: {e}" + logger.error(f"Erro na API Holmes (ID {id_processo}): {e}") return None except Exception as e: - erro = str(e) - logging.error(f"Erro inesperado ao consultar Holmes: {e}") + erro = f"{type(e).__name__}: {e}" + logger.exception(f"Erro inesperado ao consultar Holmes: {type(e).__name__}: {e}") return None finally: duracao = (time.perf_counter() - inicio) * 1000 @@ -171,12 +176,12 @@ async def get_holmes_rateio(id_processo: str, conn: PoolProxiedConnection): return response.json() except httpx.HTTPStatusError as e: status = e.response.status_code - erro = str(e) - logging.error(f"Erro na API Holmes (ID {id_processo}): {e}") + erro = f"{type(e).__name__}: {e}" + logger.error(f"Erro na API Holmes (ID {id_processo}): {e}") return None except Exception as e: - erro = str(e) - logging.error(f"Erro inesperado ao consultar Holmes: {e}") + erro = f"{type(e).__name__}: {e}" + logger.exception(f"Erro inesperado ao consultar Holmes: {type(e).__name__}: {e}") return None finally: duracao = (time.perf_counter() - inicio) * 1000 @@ -207,12 +212,12 @@ async def get_holmes_dados_tabela(id_processo: str, id_tabela: str, conn: PoolPr return response.json() except httpx.HTTPStatusError as e: status = e.response.status_code - erro = str(e) - logging.error(f"Erro na API Holmes (ID {id_processo}): {e}") + erro = f"{type(e).__name__}: {e}" + logger.error(f"Erro na API Holmes (ID {id_processo}): {e}") return None except Exception as e: - erro = str(e) - logging.error(f"Erro inesperado ao consultar Holmes: {e}") + erro = f"{type(e).__name__}: {e}" + logger.exception(f"Erro inesperado ao consultar Holmes: {type(e).__name__}: {e}") return None finally: duracao = (time.perf_counter() - inicio) * 1000 @@ -340,12 +345,12 @@ async def buscar_processo( return {"status": True, "dados": {**dados, "docs": docs, "total": len(docs)}} except httpx.HTTPStatusError as e: status = e.response.status_code - erro = str(e) - logging.error(f"Erro na API Holmes (ID {chave}): {e}") + erro = f"{type(e).__name__}: {e}" + logger.error(f"Erro na API Holmes (ID {chave}): {e}") return {"status": False, "error": e} except Exception as e: - erro = str(e) - logging.error(f"Erro inesperado ao consultar Holmes: {e}") + erro = f"{type(e).__name__}: {e}" + logger.exception(f"Erro inesperado ao consultar Holmes: {type(e).__name__}: {e}") return {"status": False, "error": e} finally: duracao = (time.perf_counter() - inicio) * 1000 @@ -421,12 +426,12 @@ async def buscar_processo_por_chaves( return {"status": True, "dados": {**dados, "docs": docs, "total": len(docs)}} except httpx.HTTPStatusError as e: status = e.response.status_code - erro = str(e) - logging.error(f"Erro na API Holmes (combinacoes {combinacoes}): {e}") + erro = f"{type(e).__name__}: {e}" + logger.error(f"Erro na API Holmes (combinacoes {combinacoes}): {e}") return {"status": False, "error": e} except Exception as e: - erro = str(e) - logging.error(f"Erro inesperado ao consultar Holmes: {e}") + erro = f"{type(e).__name__}: {e}" + logger.exception(f"Erro inesperado ao consultar Holmes: {type(e).__name__}: {e}") return {"status": False, "error": e} finally: duracao = (time.perf_counter() - inicio) * 1000 @@ -451,7 +456,7 @@ async def action(payload: dict, id_task: str, id_processo: str, conn: PoolProxie api_nome = "holmes" try: - async with httpx.AsyncClient() as client: + async with httpx.AsyncClient(timeout=HOLMES_TIMEOUT) as client: response = await client.post( url, headers={"api_token": settings.holmes.token}, json=payload ) @@ -461,12 +466,12 @@ async def action(payload: dict, id_task: str, id_processo: str, conn: PoolProxie return True, response.json() except httpx.HTTPStatusError as e: status = e.response.status_code - erro = str(e) - logging.error(f"Erro na API Holmes (ID {id_processo}): {e}") + erro = f"{type(e).__name__}: {e}" + logger.error(f"Erro na API Holmes (ID {id_processo}): {e}") return False, e except Exception as e: - erro = str(e) - logging.error(f"Erro inesperado ao consultar Holmes: {e}") + erro = f"{type(e).__name__}: {e}" + logger.exception(f"Erro inesperado ao consultar Holmes: {type(e).__name__}: {e}") return False, e finally: duracao = (time.perf_counter() - inicio) * 1000 @@ -502,12 +507,12 @@ async def cria_processo( return True, response.json() except httpx.HTTPStatusError as e: status = e.response.status_code - erro = str(e) - logging.error(f"Erro na API Holmes - Criar Processo ({payload}): {e}") + erro = f"{type(e).__name__}: {e}" + logger.error(f"Erro na API Holmes - Criar Processo ({payload}): {e}") return False, str(e) except Exception as e: - erro = str(e) - logging.error(f"Erro inesperado ao criar processo no Holmes: {e}") + erro = f"{type(e).__name__}: {e}" + logger.exception(f"Erro inesperado ao criar processo no Holmes: {type(e).__name__}: {e}") return False, str(e) finally: duracao = (time.perf_counter() - inicio) * 1000 @@ -544,7 +549,7 @@ async def enviar_documento( try: files = {"file": (nome_arquivo, arquivo, "application/pdf")} - async with httpx.AsyncClient() as client: + async with httpx.AsyncClient(timeout=HOLMES_TIMEOUT) as client: response = await client.post( url, headers={"api_token": settings.holmes.token}, files=files ) @@ -554,12 +559,12 @@ async def enviar_documento( return True, {"task_id": task_id} except httpx.HTTPStatusError as e: status = e.response.status_code - erro = str(e) - logging.error(f"Erro ao enviar documento Holmes (ID {id_processo}): {e}") + erro = f"{type(e).__name__}: {e}" + logger.error(f"Erro ao enviar documento Holmes (ID {id_processo}): {e}") return False, str(e) except Exception as e: - erro = str(e) - logging.error(f"Erro inesperado ao enviar documento Holmes: {e}") + erro = f"{type(e).__name__}: {e}" + logger.exception(f"Erro inesperado ao enviar documento Holmes: {type(e).__name__}: {e}") return False, str(e) finally: duracao = (time.perf_counter() - inicio) * 1000 @@ -612,12 +617,12 @@ async def cancela_processo( } except httpx.HTTPStatusError as e: status = e.response.status_code - erro = str(e) - logging.error(f"Erro ao cancelar processo Holmes (ID {id_processo}): {e}") + erro = f"{type(e).__name__}: {e}" + logger.error(f"Erro ao cancelar processo Holmes (ID {id_processo}): {e}") return False, str(e) except Exception as e: - erro = str(e) - logging.error(f"Erro inesperado ao cancelar processo Holmes: {e}") + erro = f"{type(e).__name__}: {e}" + logger.exception(f"Erro inesperado ao cancelar processo Holmes: {type(e).__name__}: {e}") return False, str(e) finally: duracao = (time.perf_counter() - inicio) * 1000 diff --git a/app/v1/modules/escrituracao/router.py b/app/v1/modules/escrituracao/router.py index 402f4eb..a65303d 100644 --- a/app/v1/modules/escrituracao/router.py +++ b/app/v1/modules/escrituracao/router.py @@ -1,7 +1,7 @@ from fastapi import APIRouter, HTTPException, status from fastapi.concurrency import run_in_threadpool -from app.core.database import Conexao +from app.core.database import engine from app.utils.holmes import get_holmes_history from app.v1.modules.escrituracao.models.modelo_notas import NotasHolmesInput from app.v1.modules.escrituracao.service import NotasDespesas @@ -10,23 +10,30 @@ escrituracao_router = APIRouter( prefix='/escrituracao' ) + +def gravar_nota(dados_nota_holmes: NotasHolmesInput, historico: dict | None) -> str: + # Pega a conexão só na hora de gravar: segurar ela enquanto espera o Holmes esgotava o pool + conexao = engine.raw_connection() + try: + return NotasDespesas(conexao).inserir_nota_despesas(dados_nota_holmes, historico) + finally: + conexao.close() + + # Rota que recebe a nota do Holmes e grava na PD_HOLMES_APOLLO @escrituracao_router.post( path='/notas_despesas' ) async def inserir_nota_despesas( dados_nota_holmes: NotasHolmesInput, - conexao: Conexao, ): - repo = NotasDespesas(conexao) - - # History traz a hora de cada "Aprovar"; se o Holmes falhar, volta None e grava só Feito / Não Feito - historico = await get_holmes_history(dados_nota_holmes.id, conexao) + # History traz a hora de cada "Aprovar"; se o Holmes falhar, volta None e grava sem a hora do history + historico = await get_holmes_history(dados_nota_holmes.id) try: # O banco é síncrono: roda fora do event loop pra não travar as outras requisições - acao = await run_in_threadpool(repo.inserir_nota_despesas, dados_nota_holmes, historico) + acao = await run_in_threadpool(gravar_nota, dados_nota_holmes, historico) except ValueError as erro: raise HTTPException( status_code= status.HTTP_422_UNPROCESSABLE_ENTITY, diff --git a/main.py b/main.py index c86193d..34e1f2f 100644 --- a/main.py +++ b/main.py @@ -1,5 +1,7 @@ import json import logging +from logging.handlers import RotatingFileHandler +from pathlib import Path import uvicorn from fastapi import FastAPI @@ -12,10 +14,20 @@ logger = logging.getLogger('api_podium') logger.setLevel(logging.INFO) logger.propagate = False # não repassa pro root, senão a mensagem pode sair duplicada +formato = logging.Formatter('%(asctime)s | %(levelname)s | %(name)s | %(message)s') + handler = logging.StreamHandler() -handler.setFormatter(logging.Formatter('%(asctime)s | %(levelname)s | %(name)s | %(message)s')) +handler.setFormatter(formato) logger.addHandler(handler) +# Também grava em api.log (ao lado do main.py), girando a cada 5 MB e guardando os 5 últimos +arquivo_log = RotatingFileHandler( + Path(__file__).resolve().parent / 'api.log', maxBytes=5_000_000, backupCount=5, encoding='utf-8' +) +arquivo_log.setFormatter(formato) +logger.addHandler(arquivo_log) +logging.getLogger('uvicorn.error').addHandler(arquivo_log) # erros 500 com traceback (ex.: pool esgotado) + app = FastAPI( title = 'API - Podium', version= '0.0.1'