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

1from __future__ import annotations 

2 

3import json 

4from typing import Any 

5 

6from aio_pika.abc import AbstractIncomingMessage 

7from pydantic import ValidationError 

8 

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 

14 

15logger = get_logger("consumer") 

16 

17 

18class RobotEventConsumer: 

19 """Consumes robot results and heartbeats with bounded redelivery. 

20 

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 """ 

25 

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 

37 

38 async def start(self) -> None: 

39 await self._broker.consume(self.on_message) 

40 logger.info("consumer started") 

41 

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() 

59 

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 

73 

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 

91 

92 await message.ack() 

93 logger.warning("robot event requeued", attempt=attempt, retry_in_ms=delay_ms, error=str(error))