buz 2.15.5__tar.gz → 2.15.6__tar.gz

{buz-2.15.5 → buz-2.15.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buz
-Version: 2.15.5
+Version: 2.15.6
 Summary: Buz is a set of light, simple and extensible implementations of event, command and query buses.
 License: MIT
 Author: Luis Pintado Lozano

{buz-2.15.5 → buz-2.15.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "buz"
-version = "2.15.5"
+version = "2.15.6"
 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>"]

{buz-2.15.5 → buz-2.15.6}/src/buz/event/infrastructure/buz_kafka/base_buz_aiokafka_async_consumer.py

@@ -33,6 +33,13 @@ T = TypeVar("T", bound=Event)
 
 class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
     __FALLBACK_PARTITION_ASSIGNORS = (RoundRobinPartitionAssignor,)
+    __DEFAULT_MAX_POLL_INTERVAL = 30 * 60 * 1000
+    __DEFAULT_SESSION_TIMEOUT_MS = 1000 * 120
+    __DEFAULT_HEARTBEAT_INTERVAL = int(__DEFAULT_SESSION_TIMEOUT_MS / 5)
+    __SECONDS_BETWEEN_EXECUTIONS_IF_THERE_ARE_NO_TASKS_IN_THE_QUEUE = 1
+    __SECONDS_BETWEEN_POLLS_IF_THERE_ARE_TASKS_IN_THE_QUEUE = 1
+    __SECONDS_BETWEEN_POLLS_IF_THERE_ARE_NO_NEW_TASKS = 1
+    __MAX_NUMBER_OF_CONCURRENT_POLLING_TASKS = 20
 
     def __init__(
         self,
@@ -48,10 +55,14 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
         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,
-        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,
+        seconds_between_executions_if_there_are_no_tasks_in_the_queue: Optional[int] = None,
+        seconds_between_polls_if_there_are_tasks_in_the_queue: Optional[int] = None,
+        seconds_between_polls_if_there_are_no_new_tasks: Optional[int] = None,
+        max_number_of_concurrent_polling_tasks: Optional[int] = None,
+        session_timeout_ms: Optional[int] = None,
+        max_poll_interval_ms: Optional[int] = None,
+        heartbeat_interval_ms: Optional[int] = None,
+        wait_for_connection_to_cluster_ms: Optional[int] = None,
     ):
         self.__connection_config = connection_config
         self.__consume_strategy = consume_strategy
@@ -60,34 +71,47 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
         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] = {}
         self.__queue_per_consumer_mapper: dict[
             AIOKafkaConsumer, MultiqueueRepository[TopicPartition, KafkaPollRecord]
         ] = {}
-        self.__max_records_retrieved_per_poll = max_records_retrieved_per_poll
-        self.__max_queue_size = max_queue_size
-        self.__should_stop = AsyncIOEvent()
+        self.__max_records_retrieved_per_poll: int = max_records_retrieved_per_poll
+        self.__session_timeout_ms: int = session_timeout_ms or self.__DEFAULT_SESSION_TIMEOUT_MS
+        self.__max_poll_interval_ms: int = max_poll_interval_ms or self.__DEFAULT_MAX_POLL_INTERVAL
+        self.__heartbeat_interval_ms: int = heartbeat_interval_ms or self.__DEFAULT_HEARTBEAT_INTERVAL
+        self.__max_queue_size: int = max_queue_size
+        self.__should_stop: AsyncIOEvent = AsyncIOEvent()
         self.__start_kafka_consumers_elapsed_time: Optional[timedelta] = None
         self.__initial_coroutines_created_elapsed_time: Optional[timedelta] = None
         self.__events_processed: int = 0
         self.__events_processed_elapsed_time: timedelta = timedelta()
-        self.__kafka_admin_client = kafka_admin_client
-        self.__auto_create_topic_configuration = auto_create_topic_configuration
-        self.__seconds_between_executions_if_there_are_no_tasks_in_the_queue = (
+        self.__kafka_admin_client: Optional[KafkaAdminClient] = kafka_admin_client
+        self.__auto_create_topic_configuration: Optional[AutoCreateTopicConfiguration] = auto_create_topic_configuration
+        self.__seconds_between_executions_if_there_are_no_tasks_in_the_queue: int = (
             seconds_between_executions_if_there_are_no_tasks_in_the_queue
+            or self.__SECONDS_BETWEEN_EXECUTIONS_IF_THERE_ARE_NO_TASKS_IN_THE_QUEUE
         )
-        self.__seconds_between_polls_if_there_are_tasks_in_the_queue = (
+        self.__seconds_between_polls_if_there_are_tasks_in_the_queue: int = (
             seconds_between_polls_if_there_are_tasks_in_the_queue
+            or self.__SECONDS_BETWEEN_POLLS_IF_THERE_ARE_TASKS_IN_THE_QUEUE
         )
-        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.__seconds_between_polls_if_there_are_no_new_tasks: int = (
+            seconds_between_polls_if_there_are_no_new_tasks or self.__SECONDS_BETWEEN_POLLS_IF_THERE_ARE_NO_NEW_TASKS
+        )
+        self.__max_number_of_concurrent_polling_tasks: int = (
+            max_number_of_concurrent_polling_tasks or self.__MAX_NUMBER_OF_CONCURRENT_POLLING_TASKS
+        )
+        self.__wait_for_connection_to_cluster_ms: Optional[int] = wait_for_connection_to_cluster_ms
+        self.__polling_tasks_semaphore = Semaphore(self.__max_number_of_concurrent_polling_tasks)
         self.__task_execution_mutex = Lock()
+        self.__is_worked_initialized = False
 
-    async def configure_health_check_server(self, health_check_port: int) -> web.TCPSite:
+    async def configure_http_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())
+        app.router.add_get("/ready", lambda request: self.__is_ready())
+
         runner = web.AppRunner(app)
         await runner.setup()
         site = web.TCPSite(runner, "localhost", health_check_port)
@@ -95,12 +119,14 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
         return site
 
     async def run(self) -> None:
+        self.__print_worker_configuration()
         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)
+            health_check_server = await self.configure_http_check_server(self.__health_check_port)
+
+        await self.__generate_kafka_consumers()
 
         self.__initial_coroutines_created_elapsed_time = datetime.now() - start_time
 
@@ -108,14 +134,39 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
             self._logger.error("There are no valid subscribers to execute, finalizing consumer")
             return
 
+        self.__is_worked_initialized = True
+
         start_consumption_time = datetime.now()
         worker_errors = await self.__run_worker()
         self.__events_processed_elapsed_time = datetime.now() - start_consumption_time
 
+        await self.__handle_graceful_stop(worker_errors)
+
         if health_check_server is not None:
             await health_check_server.stop()
 
-        await self.__handle_graceful_stop(worker_errors)
+    def __print_worker_configuration(self) -> None:
+        self._logger.info(
+            f"Consumer configuration:\n"
+            f"  - Consume strategy: {self.__consume_strategy}\n"
+            f"  - Max queue size: {self.__max_queue_size}\n"
+            f"  - Max records retrieved per poll: {self.__max_records_retrieved_per_poll}\n"
+            f"  - Kafka partition assignors: {self.__kafka_partition_assignors}\n"
+            f"  - Consumer initial offset position: {self.__consumer_initial_offset_position}\n"
+            f"  - Session timeout ms: {self.__session_timeout_ms}\n"
+            f"  - Max poll interval ms: {self.__max_poll_interval_ms}\n"
+            f"  - Heartbeat interval ms: {self.__heartbeat_interval_ms}\n"
+            f"  - Seconds between executions if there are no tasks in the queue: "
+            f"{self.__seconds_between_executions_if_there_are_no_tasks_in_the_queue}\n"
+            f"  - Seconds between polls if there are tasks in the queue: "
+            f"{self.__seconds_between_polls_if_there_are_tasks_in_the_queue}\n"
+            f"  - Seconds between polls if there are no new tasks: "
+            f"{self.__seconds_between_polls_if_there_are_no_new_tasks}\n"
+            f"  - Max number of concurrent polling tasks: {self.__max_number_of_concurrent_polling_tasks}\n"
+            f"  - Wait for connection to cluster ms: {self.__wait_for_connection_to_cluster_ms}\n"
+            f"  - Health check port: {self.__health_check_port}\n"
+            f"  - Number of subscribers: {len(self.__subscribers)}"
+        )
 
     async def __handle_graceful_stop(self, worker_errors: tuple[Optional[Exception], Optional[Exception]]) -> None:
         self._logger.info("Stopping kafka consumers...")
@@ -160,36 +211,44 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
         self.__start_kafka_consumers_elapsed_time = datetime.now() - start_time
 
     async def __generate_kafka_consumer_for_subscriber(self, subscriber: MetaSubscriber) -> None:
-        try:
-            executor = await self._create_kafka_consumer_executor(subscriber)
-            topics = self.__consume_strategy.get_topics(subscriber)
-            kafka_consumer = AIOKafkaConsumer(
-                consumer_group=self.__consume_strategy.get_subscription_group(subscriber),
-                topics=topics,
-                connection_config=self.__connection_config,
-                initial_offset_position=self.__consumer_initial_offset_position,
-                partition_assignors=self.__kafka_partition_assignors + self.__FALLBACK_PARTITION_ASSIGNORS,
-                logger=self._logger,
-                kafka_admin_client=self.__kafka_admin_client,
-                auto_create_topic_configuration=self.__auto_create_topic_configuration,
-                on_partition_revoked=self.__on_partition_revoked,
-            )
-
-            self.__executor_per_consumer_mapper[kafka_consumer] = executor
-
-            self.__queue_per_consumer_mapper[kafka_consumer] = InMemoryMultiqueueRepository()
+        executor = await self._create_kafka_consumer_executor(subscriber)
+        topics = self.__consume_strategy.get_topics(subscriber)
+        kafka_consumer = AIOKafkaConsumer(
+            consumer_group=self.__consume_strategy.get_subscription_group(subscriber),
+            topics=topics,
+            connection_config=self.__connection_config,
+            initial_offset_position=self.__consumer_initial_offset_position,
+            partition_assignors=self.__kafka_partition_assignors + self.__FALLBACK_PARTITION_ASSIGNORS,
+            logger=self._logger,
+            kafka_admin_client=self.__kafka_admin_client,
+            auto_create_topic_configuration=self.__auto_create_topic_configuration,
+            on_partition_revoked=self.__on_partition_revoked,
+            session_timeout_ms=self.__session_timeout_ms,
+            max_poll_interval_ms=self.__max_poll_interval_ms,
+            heartbeat_interval_ms=self.__heartbeat_interval_ms,
+            wait_for_connection_to_cluster_ms=self.__wait_for_connection_to_cluster_ms,
+        )
 
-        except Exception:
-            self._logger.exception(
-                f"Unexpected error during Kafka subscriber '{subscriber.fqn()}' creation. Skipping it: {traceback.format_exc()}"
-            )
+        self.__executor_per_consumer_mapper[kafka_consumer] = executor
+
+        self.__queue_per_consumer_mapper[kafka_consumer] = InMemoryMultiqueueRepository()
+
+        self._logger.info(
+            f"initializing consumer group: '{kafka_consumer.get_consumer_group()}' subscribed to the topics: '{kafka_consumer.get_topics()}'"
+        )
+
+        await kafka_consumer.init()
+
+        self._logger.info(
+            f"Initialized consumer group: '{kafka_consumer.get_consumer_group()}' subscribed to the topics: '{kafka_consumer.get_topics()}'"
+        )
 
     @abstractmethod
     async def _create_kafka_consumer_executor(self, subscriber: MetaSubscriber) -> KafkaEventSubscriberExecutor:
         pass
 
     async def __polling_task(self) -> None:
-        self._logger.info("Initializing subscribers")
+        self._logger.info("Creating polling tasks")
         try:
             polling_task_per_consumer = [
                 create_task(self.__polling_consuming_tasks(consumer))
@@ -204,18 +263,6 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
 
     async def __polling_consuming_tasks(self, consumer: AIOKafkaConsumer) -> None:
         queue = self.__queue_per_consumer_mapper[consumer]
-
-        try:
-            self._logger.info(
-                f"initializing consumer group: '{consumer.get_consumer_group()}' subscribed to the topics: '{consumer.get_topics()}'"
-            )
-            await consumer.init()
-            self._logger.info(f"initialized '{consumer.get_consumer_group()}'")
-        except Exception:
-            self._logger.exception(
-                f"Unexpected error during Kafka subscriber '{consumer.get_consumer_group()}' initialization. Skipping it: {traceback.format_exc()}"
-            )
-
         while not self.__should_stop.is_set():
             total_size = sum([queue.get_total_size() for queue in self.__queue_per_consumer_mapper.values()])
             if total_size >= self.__max_queue_size:
@@ -240,7 +287,7 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
                 await sleep(self.__seconds_between_polls_if_there_are_no_new_tasks)
 
     async def __consume_events_task(self) -> None:
-        self._logger.info("Initializing consuming task")
+        self._logger.info("Creating consuming task")
         blocked_tasks_iterator = self.__generate_blocked_consuming_tasks_iterator()
 
         async for consuming_task in blocked_tasks_iterator:
@@ -300,9 +347,22 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
 
         return web.Response(text=json.dumps(health_information), content_type="application/json")
 
+    async def __is_ready(self) -> web.Response:
+        is_ready = self.__is_worked_initialized
+        status_code = 200 if is_ready else 503
+
+        self._logger.info(f"Health check is_ready: {is_ready}, status_code: {status_code}")
+
+        return web.Response(
+            text=json.dumps({"is_ready": is_ready}), content_type="application/json", status=status_code
+        )
+
     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}")
-        self._logger.info(f"Initial coroutines created elapsed time: {self.__initial_coroutines_created_elapsed_time}")
-        self._logger.info(f"Events processed: {self.__events_processed}")
-        self._logger.info(f"Events processed elapsed time: {self.__events_processed_elapsed_time}")
+        self._logger.info(
+            f"System startup summary:\n"
+            f"  - Number of subscribers: {len(self.__subscribers)}\n"
+            f"  - Start Kafka consumers elapsed time: {self.__start_kafka_consumers_elapsed_time}\n"
+            f"  - Initial coroutines created elapsed time: {self.__initial_coroutines_created_elapsed_time}\n"
+            f"  - Events processed: {self.__events_processed}\n"
+            f"  - Events processed elapsed time: {self.__events_processed_elapsed_time}"
+        )

{buz-2.15.5 → buz-2.15.6}/src/buz/event/infrastructure/buz_kafka/buz_aiokafka_async_consumer.py

@@ -47,11 +47,15 @@ class BuzAIOKafkaAsyncConsumer(BaseBuzAIOKafkaAsyncConsumer):
         consume_retrier: Optional[ConsumeRetrier] = None,
         reject_callback: Optional[RejectCallback] = None,
         auto_create_topic_configuration: Optional[AutoCreateTopicConfiguration] = None,
-        seconds_between_executions_if_there_are_no_tasks_in_the_queue: int = 1,
-        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,
+        seconds_between_executions_if_there_are_no_tasks_in_the_queue: Optional[int] = None,
+        seconds_between_polls_if_there_are_tasks_in_the_queue: Optional[int] = None,
+        seconds_between_polls_if_there_are_no_new_tasks: Optional[int] = None,
+        max_number_of_concurrent_polling_tasks: Optional[int] = None,
+        session_timeout_ms: Optional[int] = None,
+        max_poll_interval_ms: Optional[int] = None,
+        heartbeat_interval_ms: Optional[int] = None,
         health_check_port: Optional[int] = None,
+        wait_for_connection_to_cluster_ms: Optional[int] = None,
     ):
         super().__init__(
             connection_config=connection_config,
@@ -68,7 +72,11 @@ 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,
+            session_timeout_ms=session_timeout_ms,
+            max_poll_interval_ms=max_poll_interval_ms,
+            heartbeat_interval_ms=heartbeat_interval_ms,
             health_check_port=health_check_port,
+            wait_for_connection_to_cluster_ms=wait_for_connection_to_cluster_ms,
         )
         self.__on_fail_strategy = on_fail_strategy
         self.__consume_middlewares = consume_middlewares

{buz-2.15.5 → buz-2.15.6}/src/buz/event/infrastructure/buz_kafka/buz_aiokafka_multi_threaded_consumer.py

@@ -48,11 +48,15 @@ class BuzAIOKafkaMultiThreadedConsumer(BaseBuzAIOKafkaAsyncConsumer):
         consume_retrier: Optional[ConsumeRetrier] = None,
         reject_callback: Optional[RejectCallback] = None,
         auto_create_topic_configuration: Optional[AutoCreateTopicConfiguration] = None,
-        seconds_between_executions_if_there_are_no_tasks_in_the_queue: int = 1,
-        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,
+        seconds_between_executions_if_there_are_no_tasks_in_the_queue: Optional[int] = None,
+        seconds_between_polls_if_there_are_tasks_in_the_queue: Optional[int] = None,
+        seconds_between_polls_if_there_are_no_new_tasks: Optional[int] = None,
+        max_number_of_concurrent_polling_tasks: Optional[int] = None,
+        session_timeout_ms: Optional[int] = None,
+        max_poll_interval_ms: Optional[int] = None,
+        heartbeat_interval_ms: Optional[int] = None,
+        health_check_port: Optional[int] = None,
+        wait_for_connection_to_cluster_ms: Optional[int] = None,
     ):
         super().__init__(
             connection_config=connection_config,
@@ -70,6 +74,10 @@ class BuzAIOKafkaMultiThreadedConsumer(BaseBuzAIOKafkaAsyncConsumer):
             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,
+            session_timeout_ms=session_timeout_ms,
+            max_poll_interval_ms=max_poll_interval_ms,
+            heartbeat_interval_ms=heartbeat_interval_ms,
+            wait_for_connection_to_cluster_ms=wait_for_connection_to_cluster_ms,
         )
         self.__on_fail_strategy = on_fail_strategy
         self.__consume_middlewares = consume_middlewares

{buz-2.15.5 → buz-2.15.6}/src/buz/kafka/infrastructure/aiokafka/aiokafka_consumer.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 from logging import Logger
 from typing import Awaitable, Callable, Optional, Sequence, cast
 
@@ -25,8 +26,6 @@ from buz.kafka.infrastructure.aiokafka.translators.consumer_initial_offset_posit
 
 class AIOKafkaConsumer:
     __DEFAULT_POLL_TIMEOUT_MS = 0
-    __DEFAULT_SESSION_TIMEOUT_MS = 1000 * 120
-    __DEFAULT_MAX_POLL_INTERVAL = 30 * 60 * 1000
 
     def __init__(
         self,
@@ -38,9 +37,12 @@ class AIOKafkaConsumer:
         initial_offset_position: ConsumerInitialOffsetPosition,
         partition_assignors: tuple,
         logger: Logger,
-        session_timeout_ms: int = __DEFAULT_SESSION_TIMEOUT_MS,
+        session_timeout_ms: int,
+        max_poll_interval_ms: int,
+        heartbeat_interval_ms: int,
         on_partition_revoked: Callable[[AIOKafkaConsumer, set[TopicPartition]], Awaitable[None]],
         auto_create_topic_configuration: Optional[AutoCreateTopicConfiguration] = None,
+        wait_for_connection_to_cluster_ms: Optional[int] = None,
     ) -> None:
         self.__consumer_group = consumer_group
         self.__topics = topics
@@ -52,6 +54,9 @@ class AIOKafkaConsumer:
         self.__session_timeout_ms = session_timeout_ms
         self.__auto_create_topic_configuration = auto_create_topic_configuration
         self.__on_partitions_revoked_callback = on_partition_revoked
+        self.__max_poll_interval_ms = max_poll_interval_ms
+        self.__heartbeat_interval_ms = heartbeat_interval_ms
+        self.__wait_for_connection_to_cluster_ms = wait_for_connection_to_cluster_ms
         self.__check_kafka_admin_client_is_needed()
         self.__consumer = self.__generate_consumer()
 
@@ -98,10 +103,10 @@ class AIOKafkaConsumer:
                 self.__initial_offset_position
             ),
             session_timeout_ms=self.__session_timeout_ms,
-            heartbeat_interval_ms=int(self.__session_timeout_ms / 5),
+            heartbeat_interval_ms=self.__heartbeat_interval_ms,
             partition_assignment_strategy=list(self.__partition_assignors),
-            max_poll_interval_ms=self.__DEFAULT_MAX_POLL_INTERVAL,
-            rebalance_timeout_ms=self.__DEFAULT_MAX_POLL_INTERVAL,
+            max_poll_interval_ms=self.__max_poll_interval_ms,
+            rebalance_timeout_ms=self.__max_poll_interval_ms,
         )
 
         return consumer
@@ -148,7 +153,11 @@ class AIOKafkaConsumer:
         )
 
         self.__logger.info(f"initializing connection of consumer with group_id={self.__consumer_group}")
-        await self.__consumer.start()
+
+        if self.__wait_for_connection_to_cluster_ms is not None:
+            await asyncio.wait_for(self.__consumer.start(), self.__wait_for_connection_to_cluster_ms / 1000)
+        else:
+            await self.__consumer.start()
 
     async def __on_partitions_assigned(
         self,