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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: talentro-commons
-Version: 0.20.5
+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.5 → talentro_commons-0.20.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "talentro-commons"
-version = "0.20.5"
+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.5 → 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":