Coverage for src/robot_dispatch/messaging/consumer.py: 88%
51 statements
« prev ^ index » next coverage.py v7.17.2, created at 2026-11-07 17:18 +0000
« prev ^ index » next coverage.py v7.17.2, created at 2026-11-07 17:18 +0000
1from __future__ import annotations
3import json
4from typing import Any
6from aio_pika.abc import AbstractIncomingMessage
7from pydantic import ValidationError
9from robot_dispatch.config import Settings
10from robot_dispatch.logging_setup import get_logger
11from robot_dispatch.messaging.broker import Broker
12from robot_dispatch.messaging.messages import RETRY_QUEUE, HeartbeatMessage, TaskResultMessage
13from robot_dispatch.services.results import HeartbeatService, ResultService
15logger = get_logger("consumer")
18class RobotEventConsumer:
19 """Consumes robot results and heartbeats with bounded redelivery.
21 A handler error is retried up to `result_retry_max` times with a per-message
22 TTL in `dispatch.results.retry`, then dead-lettered to `dispatch.results.dlq`.
23 Malformed payloads are dead-lettered immediately: replaying them cannot help.
24 """
26 def __init__(
27 self,
28 broker: Broker,
29 results: ResultService,
30 heartbeats: HeartbeatService,
31 settings: Settings,
32 ) -> None:
33 self._broker = broker
34 self._results = results
35 self._heartbeats = heartbeats
36 self._settings = settings
38 async def start(self) -> None:
39 await self._broker.consume(self.on_message)
40 logger.info("consumer started")
42 async def on_message(self, message: AbstractIncomingMessage) -> None:
43 headers: dict[str, Any] = dict(message.headers or {})
44 try:
45 payload = json.loads(message.body)
46 kind = payload.get("kind")
47 if kind == "heartbeat":
48 await self._heartbeats.handle(HeartbeatMessage.model_validate(payload))
49 else:
50 await self._results.handle(TaskResultMessage.model_validate(payload))
51 except (json.JSONDecodeError, ValidationError, KeyError) as exc:
52 logger.error("malformed robot event, dead-lettering", error=str(exc))
53 await message.reject(requeue=False)
54 return
55 except Exception as exc: # noqa: BLE001 - infrastructure failure, retry
56 await self._schedule_retry(message, headers, exc)
57 return
58 await message.ack()
60 async def _schedule_retry(
61 self, message: AbstractIncomingMessage, headers: dict[str, Any], error: Exception
62 ) -> None:
63 attempt = int(headers.get("x-retry-count", 0)) + 1
64 if attempt > self._settings.result_retry_max:
65 logger.error(
66 "robot event dropped after retries",
67 attempts=attempt,
68 error=str(error),
69 message_id=message.message_id,
70 )
71 await message.reject(requeue=False)
72 return
74 delay_ms = self._settings.result_retry_delay_ms * attempt
75 try:
76 await self._broker.publish_raw(
77 queue=RETRY_QUEUE,
78 body=message.body,
79 headers={
80 **headers,
81 "x-retry-count": attempt,
82 "x-last-error": str(error)[:500],
83 },
84 expiration_ms=delay_ms,
85 message_id=message.message_id,
86 )
87 except Exception as publish_error: # noqa: BLE001 - broker may be down
88 logger.error("cannot schedule retry, requeueing", error=str(publish_error))
89 await message.reject(requeue=True)
90 return
92 await message.ack()
93 logger.warning("robot event requeued", attempt=attempt, retry_in_ms=delay_ms, error=str(error))