buz 2.14.2__tar.gz → 2.14.3__tar.gz

{buz-2.14.2 → buz-2.14.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buz
-Version: 2.14.2
+Version: 2.14.3
 Summary: Buz is a set of light, simple and extensible implementations of event, command and query buses.
 License: MIT
 Author: Luis Pintado Lozano
@@ -22,6 +22,7 @@ Classifier: Typing :: Typed
 Provides-Extra: aiokafka
 Provides-Extra: kombu
 Provides-Extra: pypendency
+Requires-Dist: aiohttp (>=3.11.13,<4.0.0)
 Requires-Dist: aiokafka[lz4] (==0.12.0) ; extra == "aiokafka"
 Requires-Dist: asgiref (>=3.8.1,<4.0.0) ; extra == "aiokafka"
 Requires-Dist: asyncio (>=3.4.3,<4.0.0) ; extra == "aiokafka"

{buz-2.14.2 → buz-2.14.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "buz"
-version = "2.14.2"
+version = "2.14.3"
 description = "Buz is a set of light, simple and extensible implementations of event, command and query buses."
 readme = "README.md"
 authors = ["Luis Pintado Lozano <luis.pintado.lozano@gmail.com>", "Gerardo Parra <gprauxiliar@gmail.com>"]
@@ -31,6 +31,7 @@ asyncio = { version ="^3.4.3", optional = true }
 aiokafka = {version = "==0.12.0", extras = ["lz4"], optional = true}
 asgiref = {version = "^3.8.1", optional = true}
 cachetools = "^5.5.0"
+aiohttp = "^3.11.13"
 
 [tool.poetry.dev-dependencies]
 black = "^23.3"

{buz-2.14.2 → buz-2.14.3}/src/buz/event/infrastructure/buz_kafka/base_buz_aiokafka_async_consumer.py

@@ -1,3 +1,4 @@
+import json
 import traceback
 from abc import abstractmethod
 from asyncio import Lock, Task, create_task, gather, Semaphore, Event as AsyncIOEvent, sleep
@@ -5,6 +6,7 @@ from datetime import timedelta, datetime
 from itertools import cycle
 from logging import Logger
 from typing import AsyncIterator, Optional, Sequence, Type, TypeVar
+from aiohttp import web
 
 from aiokafka import TopicPartition
 from aiokafka.coordinator.assignors.abstract import AbstractPartitionAssignor
@@ -43,6 +45,7 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
         kafka_partition_assignors: tuple[Type[AbstractPartitionAssignor], ...] = (),
         subscribers: Sequence[MetaSubscriber],
         logger: Logger,
+        health_check_port: Optional[int],
         consumer_initial_offset_position: ConsumerInitialOffsetPosition,
         auto_create_topic_configuration: Optional[AutoCreateTopicConfiguration] = None,
         seconds_between_executions_if_there_are_no_tasks_in_the_queue: int = 1,
@@ -55,6 +58,7 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
         self.__kafka_partition_assignors = kafka_partition_assignors
         self.__subscribers = subscribers
         self._logger = logger
+        self.__health_check_port = health_check_port
         self.__consumer_initial_offset_position = consumer_initial_offset_position
         self.__max_records_retrieved_per_poll = 1
         self.__executor_per_consumer_mapper: dict[AIOKafkaConsumer, KafkaEventSubscriberExecutor] = {}
@@ -78,12 +82,26 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
         )
         self.__seconds_between_polls_if_there_are_no_new_tasks = seconds_between_polls_if_there_are_no_new_tasks
         self.__polling_tasks_semaphore = Semaphore(max_number_of_concurrent_polling_tasks)
-
         self.__task_execution_mutex = Lock()
 
+    async def configure_health_check_server(self, health_check_port: int) -> web.TCPSite:
+        self._logger.info(f"Starting health check server on port {health_check_port}")
+        app = web.Application()
+        app.router.add_get("/health", lambda request: self.__health_check())
+        runner = web.AppRunner(app)
+        await runner.setup()
+        site = web.TCPSite(runner, "localhost", health_check_port)
+        await site.start()
+        return site
+
     async def run(self) -> None:
         start_time = datetime.now()
         await self.__generate_kafka_consumers()
+        health_check_server: Optional[web.TCPSite] = None
+
+        if self.__health_check_port is not None:
+            health_check_server = await self.configure_health_check_server(self.__health_check_port)
+
         self.__initial_coroutines_created_elapsed_time = datetime.now() - start_time
 
         if len(self.__executor_per_consumer_mapper) == 0:
@@ -94,6 +112,9 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
         worker_errors = await self.__run_worker()
         self.__events_processed_elapsed_time = datetime.now() - start_consumption_time
 
+        if health_check_server is not None:
+            await health_check_server.stop()
+
         await self.__handle_graceful_stop(worker_errors)
 
     async def __handle_graceful_stop(self, worker_errors: tuple[Optional[Exception], Optional[Exception]]) -> None:
@@ -270,6 +291,15 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
         for kafka_consumer in self.__queue_per_consumer_mapper.keys():
             await kafka_consumer.stop()
 
+    async def __health_check(self) -> web.Response:
+        health_information = {
+            "subscribers": [subscriber.fqn() for subscriber in self.__subscribers],
+            "number_of_subscribers": len(self.__subscribers),
+            "event_processed": self.__events_processed,
+        }
+
+        return web.Response(text=json.dumps(health_information), content_type="application/json")
+
     def __print_statistics(self) -> None:
         self._logger.info("Number of subscribers: %d", len(self.__subscribers))
         self._logger.info(f"Start kafka consumers elapsed time: {self.__start_kafka_consumers_elapsed_time}")

{buz-2.14.2 → buz-2.14.3}/src/buz/event/infrastructure/buz_kafka/buz_aiokafka_async_consumer.py

@@ -51,6 +51,7 @@ class BuzAIOKafkaAsyncConsumer(BaseBuzAIOKafkaAsyncConsumer):
         seconds_between_polls_if_there_are_tasks_in_the_queue: int = 1,
         seconds_between_polls_if_there_are_no_new_tasks: int = 1,
         max_number_of_concurrent_polling_tasks: int = 20,
+        health_check_port: Optional[int] = None,
     ):
         super().__init__(
             connection_config=connection_config,
@@ -67,6 +68,7 @@ class BuzAIOKafkaAsyncConsumer(BaseBuzAIOKafkaAsyncConsumer):
             seconds_between_polls_if_there_are_tasks_in_the_queue=seconds_between_polls_if_there_are_tasks_in_the_queue,
             seconds_between_polls_if_there_are_no_new_tasks=seconds_between_polls_if_there_are_no_new_tasks,
             max_number_of_concurrent_polling_tasks=max_number_of_concurrent_polling_tasks,
+            health_check_port=health_check_port,
         )
         self.__on_fail_strategy = on_fail_strategy
         self.__consume_middlewares = consume_middlewares

{buz-2.14.2 → buz-2.14.3}/src/buz/event/infrastructure/buz_kafka/buz_aiokafka_multi_threaded_consumer.py

@@ -52,6 +52,7 @@ class BuzAIOKafkaMultiThreadedConsumer(BaseBuzAIOKafkaAsyncConsumer):
         seconds_between_polls_if_there_are_tasks_in_the_queue: int = 1,
         seconds_between_polls_if_there_are_no_new_tasks: int = 1,
         max_number_of_concurrent_polling_tasks: int = 20,
+        health_check_port: Optional[int] = 3123,
     ):
         super().__init__(
             connection_config=connection_config,
@@ -68,6 +69,7 @@ class BuzAIOKafkaMultiThreadedConsumer(BaseBuzAIOKafkaAsyncConsumer):
             seconds_between_polls_if_there_are_tasks_in_the_queue=seconds_between_polls_if_there_are_tasks_in_the_queue,
             seconds_between_polls_if_there_are_no_new_tasks=seconds_between_polls_if_there_are_no_new_tasks,
             max_number_of_concurrent_polling_tasks=max_number_of_concurrent_polling_tasks,
+            health_check_port=health_check_port,
         )
         self.__on_fail_strategy = on_fail_strategy
         self.__consume_middlewares = consume_middlewares