Corrige pool esgotado e erros do Holmes sem mensagem

- 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) <noreply@anthropic.com>
This commit is contained in:
Ricardo 2026-10-08 14:18:46 -03:00
parent 36f042cbae
commit 006687f250
4 changed files with 115 additions and 76 deletions

View file

@ -2,9 +2,13 @@ import logging
from sqlalchemy.pool import PoolProxiedConnection from sqlalchemy.pool import PoolProxiedConnection
from app.core.database import engine
logger = logging.getLogger('api_podium')
def registrar_contador( def registrar_contador(
conn: PoolProxiedConnection, conn: PoolProxiedConnection | None,
api: str, api: str,
endpoint: str, endpoint: str,
metodo: str, metodo: str,
@ -13,25 +17,36 @@ def registrar_contador(
duracao_ms: float, duracao_ms: float,
erro: str | None = None, erro: str | None = None,
) -> None: ) -> None:
"""Grava uma linha na tabela contadores_api. Falha aqui não derruba a chamada principal.""" """Grava uma linha na tabela contadores_api. Falha aqui não derruba a chamada principal.
cursor = conn.cursor()
Sem conn, pega uma conexão do pool só pro INSERT e devolve logo em seguida.
"""
conexao_propria = conn is None
try: try:
cursor.execute(""" if conexao_propria:
INSERT INTO contadores_api conn = engine.raw_connection()
(api, endpoint, metodo_http, status_code, sucesso, duracao_ms, mensagem_erro) cursor = conn.cursor()
VALUES (?, ?, ?, ?, ?, ?, ?) try:
""", ( cursor.execute("""
api, INSERT INTO contadores_api
endpoint, (api, endpoint, metodo_http, status_code, sucesso, duracao_ms, mensagem_erro)
metodo, VALUES (?, ?, ?, ?, ?, ?, ?)
status_code, """, (
'S' if sucesso else 'N', api,
round(duracao_ms, 2), endpoint,
erro[:500] if erro else None, metodo,
)) status_code,
conn.commit() 'S' if sucesso else 'N',
round(duracao_ms, 2),
erro[:500] if erro else None,
))
conn.commit()
finally:
cursor.close()
except Exception as e: except Exception as e:
conn.rollback() if conn is not None:
logging.error(f'Falha ao gravar contador: {e}') conn.rollback()
logger.error(f'Falha ao gravar contador: {type(e).__name__}: {e}')
finally: finally:
cursor.close() if conexao_propria and conn is not None:
conn.close()

View file

@ -10,6 +10,11 @@ from sqlalchemy.pool import PoolProxiedConnection
from app.core.configs import settings from app.core.configs import settings
from app.utils.api_tracker import registrar_contador 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") _TOKEN_FILE = os.path.join(tempfile.gettempdir(), "holmes_token_cache.json")
async def get_header() -> tuple[dict, str]: async def get_header() -> tuple[dict, str]:
@ -22,7 +27,7 @@ async def _holmes_request(
api_nome: str = "holmes" api_nome: str = "holmes"
for tentativa in range(2): for tentativa in range(2):
header, api_nome = await get_header() 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) response = await getattr(client, method)(url, headers=header, **kwargs)
return response, api_nome return response, api_nome
raise RuntimeError("Holmes: falha de autenticação após retry") 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() return response.json()
except httpx.HTTPStatusError as e: except httpx.HTTPStatusError as e:
status = e.response.status_code status = e.response.status_code
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro na API Holmes (ID {id_processo}): {e}") logger.error(f"Erro na API Holmes (ID {id_processo}): {e}")
return None return None
except Exception as e: except Exception as e:
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro inesperado ao consultar Holmes: {e}") logger.exception(f"Erro inesperado ao consultar Holmes: {type(e).__name__}: {e}")
return None return None
finally: finally:
duracao = (time.perf_counter() - inicio) * 1000 duracao = (time.perf_counter() - inicio) * 1000
@ -86,12 +91,12 @@ async def get_holmes_process_details(id_processo: str, conn: PoolProxiedConnecti
return response.json() return response.json()
except httpx.HTTPStatusError as e: except httpx.HTTPStatusError as e:
status = e.response.status_code status = e.response.status_code
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro na API Holmes details (ID {id_processo}): {e}") logger.error(f"Erro na API Holmes details (ID {id_processo}): {e}")
return None return None
except Exception as e: except Exception as e:
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro inesperado ao consultar Holmes details: {e}") logger.exception(f"Erro inesperado ao consultar Holmes details: {type(e).__name__}: {e}")
return None return None
finally: finally:
duracao = (time.perf_counter() - inicio) * 1000 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) Busca o historico no holmes (importante para pegar o id da ultima task, para avançar futuramente)
Args: Args:
@ -134,12 +139,12 @@ async def get_holmes_history(id_processo: str, conn: PoolProxiedConnection):
return response.json() return response.json()
except httpx.HTTPStatusError as e: except httpx.HTTPStatusError as e:
status = e.response.status_code status = e.response.status_code
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro na API Holmes (ID {id_processo}): {e}") logger.error(f"Erro na API Holmes (ID {id_processo}): {e}")
return None return None
except Exception as e: except Exception as e:
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro inesperado ao consultar Holmes: {e}") logger.exception(f"Erro inesperado ao consultar Holmes: {type(e).__name__}: {e}")
return None return None
finally: finally:
duracao = (time.perf_counter() - inicio) * 1000 duracao = (time.perf_counter() - inicio) * 1000
@ -171,12 +176,12 @@ async def get_holmes_rateio(id_processo: str, conn: PoolProxiedConnection):
return response.json() return response.json()
except httpx.HTTPStatusError as e: except httpx.HTTPStatusError as e:
status = e.response.status_code status = e.response.status_code
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro na API Holmes (ID {id_processo}): {e}") logger.error(f"Erro na API Holmes (ID {id_processo}): {e}")
return None return None
except Exception as e: except Exception as e:
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro inesperado ao consultar Holmes: {e}") logger.exception(f"Erro inesperado ao consultar Holmes: {type(e).__name__}: {e}")
return None return None
finally: finally:
duracao = (time.perf_counter() - inicio) * 1000 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() return response.json()
except httpx.HTTPStatusError as e: except httpx.HTTPStatusError as e:
status = e.response.status_code status = e.response.status_code
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro na API Holmes (ID {id_processo}): {e}") logger.error(f"Erro na API Holmes (ID {id_processo}): {e}")
return None return None
except Exception as e: except Exception as e:
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro inesperado ao consultar Holmes: {e}") logger.exception(f"Erro inesperado ao consultar Holmes: {type(e).__name__}: {e}")
return None return None
finally: finally:
duracao = (time.perf_counter() - inicio) * 1000 duracao = (time.perf_counter() - inicio) * 1000
@ -340,12 +345,12 @@ async def buscar_processo(
return {"status": True, "dados": {**dados, "docs": docs, "total": len(docs)}} return {"status": True, "dados": {**dados, "docs": docs, "total": len(docs)}}
except httpx.HTTPStatusError as e: except httpx.HTTPStatusError as e:
status = e.response.status_code status = e.response.status_code
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro na API Holmes (ID {chave}): {e}") logger.error(f"Erro na API Holmes (ID {chave}): {e}")
return {"status": False, "error": e} return {"status": False, "error": e}
except Exception as e: except Exception as e:
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro inesperado ao consultar Holmes: {e}") logger.exception(f"Erro inesperado ao consultar Holmes: {type(e).__name__}: {e}")
return {"status": False, "error": e} return {"status": False, "error": e}
finally: finally:
duracao = (time.perf_counter() - inicio) * 1000 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)}} return {"status": True, "dados": {**dados, "docs": docs, "total": len(docs)}}
except httpx.HTTPStatusError as e: except httpx.HTTPStatusError as e:
status = e.response.status_code status = e.response.status_code
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro na API Holmes (combinacoes {combinacoes}): {e}") logger.error(f"Erro na API Holmes (combinacoes {combinacoes}): {e}")
return {"status": False, "error": e} return {"status": False, "error": e}
except Exception as e: except Exception as e:
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro inesperado ao consultar Holmes: {e}") logger.exception(f"Erro inesperado ao consultar Holmes: {type(e).__name__}: {e}")
return {"status": False, "error": e} return {"status": False, "error": e}
finally: finally:
duracao = (time.perf_counter() - inicio) * 1000 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" api_nome = "holmes"
try: try:
async with httpx.AsyncClient() as client: async with httpx.AsyncClient(timeout=HOLMES_TIMEOUT) as client:
response = await client.post( response = await client.post(
url, headers={"api_token": settings.holmes.token}, json=payload 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() return True, response.json()
except httpx.HTTPStatusError as e: except httpx.HTTPStatusError as e:
status = e.response.status_code status = e.response.status_code
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro na API Holmes (ID {id_processo}): {e}") logger.error(f"Erro na API Holmes (ID {id_processo}): {e}")
return False, e return False, e
except Exception as e: except Exception as e:
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro inesperado ao consultar Holmes: {e}") logger.exception(f"Erro inesperado ao consultar Holmes: {type(e).__name__}: {e}")
return False, e return False, e
finally: finally:
duracao = (time.perf_counter() - inicio) * 1000 duracao = (time.perf_counter() - inicio) * 1000
@ -502,12 +507,12 @@ async def cria_processo(
return True, response.json() return True, response.json()
except httpx.HTTPStatusError as e: except httpx.HTTPStatusError as e:
status = e.response.status_code status = e.response.status_code
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro na API Holmes - Criar Processo ({payload}): {e}") logger.error(f"Erro na API Holmes - Criar Processo ({payload}): {e}")
return False, str(e) return False, str(e)
except Exception as e: except Exception as e:
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro inesperado ao criar processo no Holmes: {e}") logger.exception(f"Erro inesperado ao criar processo no Holmes: {type(e).__name__}: {e}")
return False, str(e) return False, str(e)
finally: finally:
duracao = (time.perf_counter() - inicio) * 1000 duracao = (time.perf_counter() - inicio) * 1000
@ -544,7 +549,7 @@ async def enviar_documento(
try: try:
files = {"file": (nome_arquivo, arquivo, "application/pdf")} 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( response = await client.post(
url, headers={"api_token": settings.holmes.token}, files=files url, headers={"api_token": settings.holmes.token}, files=files
) )
@ -554,12 +559,12 @@ async def enviar_documento(
return True, {"task_id": task_id} return True, {"task_id": task_id}
except httpx.HTTPStatusError as e: except httpx.HTTPStatusError as e:
status = e.response.status_code status = e.response.status_code
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro ao enviar documento Holmes (ID {id_processo}): {e}") logger.error(f"Erro ao enviar documento Holmes (ID {id_processo}): {e}")
return False, str(e) return False, str(e)
except Exception as e: except Exception as e:
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro inesperado ao enviar documento Holmes: {e}") logger.exception(f"Erro inesperado ao enviar documento Holmes: {type(e).__name__}: {e}")
return False, str(e) return False, str(e)
finally: finally:
duracao = (time.perf_counter() - inicio) * 1000 duracao = (time.perf_counter() - inicio) * 1000
@ -612,12 +617,12 @@ async def cancela_processo(
} }
except httpx.HTTPStatusError as e: except httpx.HTTPStatusError as e:
status = e.response.status_code status = e.response.status_code
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro ao cancelar processo Holmes (ID {id_processo}): {e}") logger.error(f"Erro ao cancelar processo Holmes (ID {id_processo}): {e}")
return False, str(e) return False, str(e)
except Exception as e: except Exception as e:
erro = str(e) erro = f"{type(e).__name__}: {e}"
logging.error(f"Erro inesperado ao cancelar processo Holmes: {e}") logger.exception(f"Erro inesperado ao cancelar processo Holmes: {type(e).__name__}: {e}")
return False, str(e) return False, str(e)
finally: finally:
duracao = (time.perf_counter() - inicio) * 1000 duracao = (time.perf_counter() - inicio) * 1000

View file

@ -1,7 +1,7 @@
from fastapi import APIRouter, HTTPException, status from fastapi import APIRouter, HTTPException, status
from fastapi.concurrency import run_in_threadpool 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.utils.holmes import get_holmes_history
from app.v1.modules.escrituracao.models.modelo_notas import NotasHolmesInput from app.v1.modules.escrituracao.models.modelo_notas import NotasHolmesInput
from app.v1.modules.escrituracao.service import NotasDespesas from app.v1.modules.escrituracao.service import NotasDespesas
@ -10,23 +10,30 @@ escrituracao_router = APIRouter(
prefix='/escrituracao' 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 # Rota que recebe a nota do Holmes e grava na PD_HOLMES_APOLLO
@escrituracao_router.post( @escrituracao_router.post(
path='/notas_despesas' path='/notas_despesas'
) )
async def inserir_nota_despesas( async def inserir_nota_despesas(
dados_nota_holmes: NotasHolmesInput, dados_nota_holmes: NotasHolmesInput,
conexao: Conexao,
): ):
repo = NotasDespesas(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)
# 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)
try: try:
# O banco é síncrono: roda fora do event loop pra não travar as outras requisições # 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: except ValueError as erro:
raise HTTPException( raise HTTPException(
status_code= status.HTTP_422_UNPROCESSABLE_ENTITY, status_code= status.HTTP_422_UNPROCESSABLE_ENTITY,

14
main.py
View file

@ -1,5 +1,7 @@
import json import json
import logging import logging
from logging.handlers import RotatingFileHandler
from pathlib import Path
import uvicorn import uvicorn
from fastapi import FastAPI from fastapi import FastAPI
@ -12,10 +14,20 @@ logger = logging.getLogger('api_podium')
logger.setLevel(logging.INFO) logger.setLevel(logging.INFO)
logger.propagate = False # não repassa pro root, senão a mensagem pode sair duplicada 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 = logging.StreamHandler()
handler.setFormatter(logging.Formatter('%(asctime)s | %(levelname)s | %(name)s | %(message)s')) handler.setFormatter(formato)
logger.addHandler(handler) 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( app = FastAPI(
title = 'API - Podium', title = 'API - Podium',
version= '0.0.1' version= '0.0.1'