Modulo-6 / app /integrations /rabbit_consumer.py
Mate11
feat: agregar logs estructurados para eventos entrantes de M10/M1/M2/M9
5a6229e
Raw History Blame Contribute Delete
5.9 kB
"""
Consumer de `internacion.requests`: recibe por el bus del Core (M10) los mismos eventos
que hoy llegan como webhooks REST directos de M1/M9/M2 (`app/routers/webhooks.py`).
La cola y los 5 event types (`internacion.solicitud.creada`,
`internacion.alta-medica.registrada`, `internacion.alerta-emergencia.detectada`,
`internacion.alerta-resuelta.notificada`, `internacion.turno.cancelado`) ya están dados de
alta y bindeados en el Core — ver `M6_DISEÑO.md` §7. Este módulo solo consume: cada
mensaje se despacha a la misma función de servicio que usa el router REST equivalente, sin
lógica de negocio nueva. Cirugía urgente queda fuera (excluida de esta migración, ver
`M6_DISEÑO.md` §7): sigue siendo solo REST.
Los endpoints REST entrantes siguen activos sin cambios durante la transición — cada
equipo (M1/M9/M2) migra su emisor a su propio ritmo.
"""
import asyncio
import json
import logging
import aio_pika
from supabase import Client
from app.config import settings
from app.dependencies import get_db
from app.schemas.reserva import CancelacionQuirofanoRequest
from app.schemas.solicitud import (
AlertaEmergenciaRequest,
AlertaResueltaRequest,
AltaMedicaWebhook,
SolicitudHceWebhook,
)
from app.services import solicitud_service
logger = logging.getLogger(__name__)
def _handle_solicitud(db: Client, payload: dict) -> None:
data = SolicitudHceWebhook.model_validate(payload)
solicitud_service.recibir_solicitud(db, data)
def _handle_alta_medica(db: Client, payload: dict) -> None:
data = AltaMedicaWebhook.model_validate(payload)
solicitud_service.procesar_alta_medica(db, data)
def _handle_alerta_emergencia(db: Client, payload: dict) -> None:
data = AlertaEmergenciaRequest.model_validate(payload)
solicitud_service.procesar_alerta_emergencia(db, data.paciente_id)
def _handle_alerta_resuelta(db: Client, payload: dict) -> None:
data = AlertaResueltaRequest.model_validate(payload)
solicitud_service.procesar_alerta_resuelta(db, data.paciente_id)
def _handle_turno_cancelado(db: Client, payload: dict) -> None:
# turno_id viaja en el payload del evento (en el webhook REST equivalente viene en el
# path: POST /turnos/{turno_id}/cancelacion). CancelacionQuirofanoRequest ignora los
# campos extra, así que se puede validar el resto del payload tal cual.
turno_id = payload["turno_id"]
data = CancelacionQuirofanoRequest.model_validate(payload)
solicitud_service.cancelar_reserva_por_turno(db, turno_id, data.motivo)
_HANDLERS = {
"internacion.solicitud.creada": _handle_solicitud,
"internacion.alta-medica.registrada": _handle_alta_medica,
"internacion.alerta-emergencia.detectada": _handle_alerta_emergencia,
"internacion.alerta-resuelta.notificada": _handle_alerta_resuelta,
"internacion.turno.cancelado": _handle_turno_cancelado,
}
def dispatch(event_type_name: str, payload: dict) -> None:
"""
Despacha un mensaje ya parseado a la función de servicio correspondiente.
Lanza `KeyError` si `event_type_name` no está mapeado, o lo que levante el servicio de
negocio (`ValueError`, `HTTPException`, etc.) — `_on_message` decide ack/reject según
el resultado.
"""
handler = _HANDLERS.get(event_type_name)
if handler is None:
raise KeyError(f"event_type_name no reconocido: {event_type_name!r}")
db = get_db()
handler(db, payload)
async def _on_message(message: aio_pika.abc.AbstractIncomingMessage) -> None:
try:
envelope = json.loads(message.body)
event_type_name = envelope["event_type_name"]
payload = json.loads(envelope["payload"])
except (json.JSONDecodeError, KeyError, TypeError) as e:
logger.error(
"[M10→M6] Mensaje malformado en cola %s — se descarta sin procesar. Error: %s | body_preview=%r",
settings.internacion_requests_queue, e, message.body[:200],
)
await message.reject(requeue=False)
return
log_id = envelope.get("log_id")
logger.info(
"[M10→M6] Evento recibido: event_type=%r log_id=%s cola=%s",
event_type_name, log_id, settings.internacion_requests_queue,
)
try:
dispatch(event_type_name, payload)
except KeyError:
logger.error(
"[M10→M6] Evento desconocido: event_type=%r log_id=%s — se descarta (sin handler registrado)",
event_type_name, log_id,
)
await message.reject(requeue=False)
return
except Exception:
logger.exception(
"[M10→M6] Error procesando event_type=%r log_id=%s — se descarta (reject sin requeue)",
event_type_name, log_id,
)
await message.reject(requeue=False)
return
await message.ack()
logger.info(
"[M10→M6] Evento procesado OK: event_type=%r log_id=%s",
event_type_name, log_id,
)
async def run_consumer() -> None:
"""
Conecta a RabbitMQ y consume `internacion.requests` indefinidamente. Pensado para
correr como task de asyncio en el lifespan de FastAPI (`app/main.py`), gateado por
`settings.rabbitmq_consumer_enabled`.
"""
connection = await aio_pika.connect_robust(
host=settings.rabbitmq_host,
port=settings.rabbitmq_port,
login=settings.core_service_email,
password=settings.core_service_password,
virtualhost=settings.rabbitmq_vhost,
)
async with connection:
channel = await connection.channel()
await channel.set_qos(prefetch_count=10)
# passive=True: la cola ya existe (creada vía POST /rabbit/queues del Core, con
# su propia DLQ) — no la redeclaramos con propiedades propias.
queue = await channel.declare_queue(settings.internacion_requests_queue, passive=True)
await queue.consume(_on_message)
await asyncio.Future()