talentro-commons 0.20.4__tar.gz → 0.20.6__tar.gz

{talentro_commons-0.20.4 → talentro_commons-0.20.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: talentro-commons
-Version: 0.20.4
+Version: 0.20.6
 Summary: This package contains all globally used code, services, models and data structures for Talentro
 License: Proprietary
 Author: Emiel van Essen

{talentro_commons-0.20.4 → talentro_commons-0.20.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "talentro-commons"
-version = "0.20.4"
+version = "0.20.6"
 description = "This package contains all globally used code, services, models and data structures for Talentro"
 authors = ["Emiel van Essen <emiel@marksmen.nl>"]
 license = "Proprietary"

{talentro_commons-0.20.4 → talentro_commons-0.20.6}/src/talentro/services/rabbitmq.py

@@ -100,12 +100,12 @@ class RabbitMQ:
                           f"(TTL: {ttl_ms}ms)")
 
     async def consume(
-        self,
-        exchange_name: str,
-        queue: str,
-        callback: Callable,
-        dlx_name: Optional[str] = None,
-        max_retries: int = 3
+            self,
+            exchange_name: str,
+            queue: str,
+            callback: Callable,
+            dlx_name: Optional[str] = None,
+            max_retries: int = 3
     ):
         while True:
             try:
@@ -125,62 +125,40 @@ class RabbitMQ:
 
                 async for message in queue_object:
                     try:
-                        async with message.process():
+                        # Use ignore_processed=True to prevent auto-ack on successful processing
+                        async with message.process(ignore_processed=True, requeue=False):
                             event: Event = Event.decode(message.body)
-                            print(f"  RabbitMQ ({queue}) - [x] Received event: {event.meta.event_type} (trace: {event.meta.trace_id})")
+                            print(
+                                f"  RabbitMQ ({queue}) - [x] Received event: {event.meta.event_type} (trace: {event.meta.trace_id})")
                             await callback(queue, event)
+                            # If we reach here, callback succeeded - manually ack
+                            await message.ack()
                     except Exception as e:
                         # Handle callback exception - send to retry queue
                         print(f"  RabbitMQ ({queue}) - ⚠️ Error processing message: {e}")
                         traceback.print_exc()
-                        await self._handle_failed_message(message, queue, exchange_name, dlx_name, max_retries)
+
+                        # Get retry count from headers
+                        x_death = message.headers.get('x-death', [])
+                        death_count = len(x_death) if x_death else 0
+
+                        print(f"  RabbitMQ ({queue}) - Retry attempt {death_count + 1}/{max_retries + 1}")
+
+                        if death_count >= max_retries:
+                            print(f"  RabbitMQ ({queue}) - ❌ Max retries ({max_retries}) exceeded. Sending to DLQ.")
+                            await message.nack(requeue=False)
+                        else:
+                            print(f"  RabbitMQ ({queue}) - Sending to retry queue...")
+                            await message.nack(requeue=False)
 
             except (aio_pika.exceptions.AMQPConnectionError, aio_pika.exceptions.ChannelClosed):
                 print(f"  RabbitMQ - Connection lost while consuming {queue}. Retrying in 5 seconds...")
                 await asyncio.sleep(5)
             except Exception as e:
                 print(f"  RabbitMQ - Unexpected error in consumer {queue}: {e}")
+                traceback.print_exc()
                 await asyncio.sleep(5)
 
-    @staticmethod
-    async def _handle_failed_message(
-            message: aio_pika.IncomingMessage,
-            queue_name: str,
-            exchange_name: str,
-            dlx_name: Optional[str] = None,
-            max_retries: int = 3
-    ):
-        """
-        Handle failed messages by sending them to the retry queue or DLQ.
-        """
-        try:
-            # Get death count from headers
-            x_death = message.headers.get('x-death', [])
-            death_count = 0
-
-            if x_death:
-                # x-death is a list of death info dicts
-                death_count = len(x_death)
-
-            print(f"  RabbitMQ ({queue_name}) - Retry attempt {death_count + 1}/{max_retries + 1}")
-
-            if death_count >= max_retries:
-                # Max retries exceeded - send to DLQ
-                print(f"  RabbitMQ ({queue_name}) - ❌ Max retries ({max_retries}) exceeded. Sending to DLQ.")
-                await message.nack(requeue=False)
-            else:
-                # Still have retries left - send to retry queue
-                if dlx_name:
-                    await message.nack(requeue=False)
-                    print(f"  RabbitMQ ({queue_name}) - Sending to retry queue...")
-                else:
-                    await message.nack(requeue=True)
-                    print(f"  RabbitMQ ({queue_name}) - Message requeued")
-
-        except Exception as e:
-            print(f"  RabbitMQ ({queue_name}) - Error handling failed message: {e}")
-            await message.nack(requeue=False)
-
     async def send_message(self, message: Message):
         # Haal de exchange op
         if message.exchange == "default":
@@ -210,7 +188,7 @@ class QueueContext(metaclass=SingletonMeta):
     def __init__(self):
         self._rabbit_mq = RabbitMQ()
         self._message_callbacks = []
-        self._topology_config: TopologyConfig | None = None
+        self._topology_configs: dict[str, TopologyConfig] = {}  # Store all topologies
 
     async def connect(self):
         try:
@@ -227,7 +205,8 @@ class QueueContext(metaclass=SingletonMeta):
             await self._setup_topology_with_config(topology)
 
     async def _setup_topology_with_config(self, topology_config: TopologyConfig):
-        self._topology_config = topology_config
+        # Sla topology op met exchange_name als key
+        self._topology_configs[topology_config.exchange_name] = topology_config
 
         await self._rabbit_mq.setup_topology(
             topology_config.exchange_name,
@@ -237,15 +216,21 @@ class QueueContext(metaclass=SingletonMeta):
             retry_config=topology_config.retry_config
         )
 
-    async def start_consuming(self, queue: str):
-        max_retries = self._topology_config.get_max_retries(queue) if self._topology_config else 3
+
+    async def start_consuming(self, queue: str, exchange_name: str):
+        topology_config = self._topology_configs.get(exchange_name)
+
+        if not topology_config:
+            raise ValueError(f"Topology not found for exchange: {exchange_name}")
+
+        max_retries = topology_config.get_max_retries(queue)
 
         asyncio.create_task(
             self._rabbit_mq.consume(
-                self._topology_config.exchange_name,
+                exchange_name,
                 queue,
                 self._on_new_message,
-                dlx_name=self._topology_config.dlx_name,
+                dlx_name=topology_config.dlx_name,
                 max_retries=max_retries
             )
         )