buz 2.13.1rc9__py3-none-any.whl → 2.14.1__py3-none-any.whl

buz/kafka/infrastructure/aiokafka/aiokafka_producer.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from ssl import SSLContext
+from typing import Generic, Optional, TypeVar
+
+from aiokafka import AIOKafkaProducer as NativeAIOKafkaProducer
+from aiokafka.helpers import create_ssl_context
+
+from buz.kafka.domain.models.kafka_connection_config import KafkaConnectionConfig
+from buz.kafka.domain.models.kafka_supported_compression_type import KafkaSupportedCompressionType
+from buz.kafka.domain.models.kafka_supported_security_protocols import KafkaSupportedSecurityProtocols
+from buz.kafka.domain.services.async_kafka_producer import AsyncKafkaProducer
+from buz.kafka.infrastructure.serializers.byte_serializer import ByteSerializer
+from buz.kafka.infrastructure.serializers.kafka_header_serializer import KafkaHeaderSerializer
+
+T = TypeVar("T")
+
+
+class AIOKafkaProducer(AsyncKafkaProducer, Generic[T]):
+    __DEFAULT_REQUEST_TIMEOUT_MS = 5000
+    __kafka_producer: Optional[NativeAIOKafkaProducer] = None
+
+    def __init__(
+        self,
+        *,
+        connection_config: KafkaConnectionConfig,
+        byte_serializer: ByteSerializer[T],
+        compression_type: Optional[KafkaSupportedCompressionType] = None,
+        retry_backoff_ms: int = 100,
+    ) -> None:
+        self.__connection_config = connection_config
+        self.__byte_serializer = byte_serializer
+        self.__header_serializer = KafkaHeaderSerializer()
+        self.__compression_type = compression_type
+        self.__retry_backoff_ms = retry_backoff_ms
+
+    async def _get_aiokafka_producer(self) -> NativeAIOKafkaProducer:
+        if self.__kafka_producer:
+            return self.__kafka_producer
+
+        ssl_context: Optional[SSLContext] = None
+
+        sasl_mechanism = (
+            self.__connection_config.credentials.sasl_mechanism.value
+            if self.__connection_config.credentials.sasl_mechanism
+            else "PLAIN"
+        )
+
+        if self.__connection_config.credentials.security_protocol == KafkaSupportedSecurityProtocols.SASL_SSL:
+            ssl_context = create_ssl_context()
+
+        self.__kafka_producer = NativeAIOKafkaProducer(
+            client_id=self.__connection_config.client_id,
+            bootstrap_servers=",".join(self.__connection_config.bootstrap_servers),
+            sasl_mechanism=sasl_mechanism,
+            ssl_context=ssl_context,
+            sasl_plain_username=self.__connection_config.credentials.user,
+            sasl_plain_password=self.__connection_config.credentials.password,
+            retry_backoff_ms=self.__retry_backoff_ms,
+            request_timeout_ms=self.__DEFAULT_REQUEST_TIMEOUT_MS,
+            compression_type=self.__compression_type.value if self.__compression_type else None,
+        )
+
+        await self.__kafka_producer.start()
+
+        return self.__kafka_producer
+
+    async def connect(self) -> None:
+        await self._get_aiokafka_producer()
+
+    async def disconnect(self) -> None:
+        if self.__kafka_producer is None:
+            return None
+        await self.__kafka_producer.stop()
+        self.__kafka_producer = None
+
+    async def produce(
+        self,
+        *,
+        topic: str,
+        message: T,
+        partition_key: Optional[str] = None,
+        headers: Optional[dict[str, str]] = None,
+    ) -> None:
+        serialized_headers = self.__header_serializer.serialize(headers) if headers is not None else None
+        kafka_producer = await self._get_aiokafka_producer()
+
+        await kafka_producer.send_and_wait(
+            topic=topic,
+            value=self.__byte_serializer.serialize(message),
+            headers=serialized_headers,
+            key=partition_key.encode("utf-8") if partition_key else None,
+        )
+
+    async def close(self) -> None:
+        if self.__kafka_producer is not None:
+            await self.__kafka_producer.stop()
+            self.__kafka_producer = None

buz/kafka/infrastructure/interfaces/async_connection_manager.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+
+
+class AsyncConnectionManager(ABC):
+    @abstractmethod
+    async def connect(self) -> None:
+        pass
+
+    @abstractmethod
+    async def disconnect(self) -> None:
+        pass

buz/kafka/infrastructure/interfaces/connection_manager.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+
+
+class ConnectionManager(ABC):
+    @abstractmethod
+    def connect(self) -> None:
+        pass
+
+    @abstractmethod
+    def disconnect(self) -> None:
+        pass

buz/kafka/infrastructure/kafka_python/kafka_python_admin_client.py

@@ -8,10 +8,12 @@ from typing import Any, Callable, Optional, Sequence, cast
 from cachetools import TTLCache
 from kafka import KafkaClient, KafkaConsumer
 from kafka.admin import KafkaAdminClient as KafkaPythonLibraryAdminClient, NewTopic
+from kafka.admin.new_partitions import NewPartitions
 from kafka.errors import TopicAlreadyExistsError
 from kafka.structs import TopicPartition, OffsetAndTimestamp
 
 from buz.kafka.domain.exceptions.not_all_partition_assigned_exception import NotAllPartitionAssignedException
+from buz.kafka.domain.exceptions.not_valid_partition_number_exception import NotValidPartitionNumberException
 from buz.kafka.domain.exceptions.topic_already_created_exception import KafkaTopicsAlreadyCreatedException
 from buz.kafka.domain.exceptions.topic_not_found_exception import TopicNotFoundException
 from buz.kafka.domain.models.consumer_initial_offset_position import ConsumerInitialOffsetPosition
@@ -30,18 +32,19 @@ TOPIC_CACHE_KEY = "topics"
 class KafkaPythonAdminClient(KafkaAdminClient):
     __PYTHON_KAFKA_DUPLICATED_TOPIC_ERROR_CODE = 36
 
+    _kafka_admin: Optional[KafkaPythonLibraryAdminClient] = None
+    _kafka_client: Optional[KafkaClient] = None
+
     def __init__(
         self,
         *,
         logger: Logger,
-        config: KafkaConnectionConfig,
+        connection_config: KafkaConnectionConfig,
         cache_ttl_seconds: int = 0,
     ):
         self._logger = logger
-        self._config = config
-        self._config_in_library_format = self.__get_kafka_config_in_library_format(config)
-        self._kafka_admin = KafkaPythonLibraryAdminClient(**self._config_in_library_format)
-        self._kafka_client = KafkaClient(**self._config_in_library_format)
+        self.__connection_config = connection_config
+        self._config_in_library_format = self.__get_kafka_config_in_library_format(self.__connection_config)
         self.__ttl_cache: TTLCache[str, Any] = TTLCache(maxsize=1, ttl=cache_ttl_seconds)
 
     def __get_kafka_config_in_library_format(self, config: KafkaConnectionConfig) -> dict:
@@ -54,6 +57,28 @@ class KafkaPythonAdminClient(KafkaAdminClient):
             "sasl_plain_password": config.credentials.password,
         }
 
+    def connect(self):
+        self._get_kafka_admin()
+        self._get_kafka_client()
+
+    def disconnect(self):
+        if self._kafka_admin is not None:
+            self._kafka_admin.close()
+            self._kafka_admin = None
+        if self._kafka_client is not None:
+            self._kafka_client.close()
+            self._kafka_client = None
+
+    def _get_kafka_admin(self) -> KafkaPythonLibraryAdminClient:
+        if not self._kafka_admin:
+            self._kafka_admin = KafkaPythonLibraryAdminClient(**self._config_in_library_format)
+        return self._kafka_admin
+
+    def _get_kafka_client(self) -> KafkaClient:
+        if not self._kafka_client:
+            self._kafka_client = KafkaClient(**self._config_in_library_format)
+        return self._kafka_client
+
     def create_topics(
         self,
         *,
@@ -70,7 +95,7 @@ class KafkaPythonAdminClient(KafkaAdminClient):
         ]
 
         try:
-            self._kafka_admin.create_topics(new_topics=new_topics)
+            self._get_kafka_admin().create_topics(new_topics=new_topics)
         except TopicAlreadyExistsError as error:
             topic_names = self.__get_list_of_kafka_topics_from_topic_already_exists_error(error)
             raise KafkaTopicsAlreadyCreatedException(topic_names=topic_names)
@@ -94,7 +119,7 @@ class KafkaPythonAdminClient(KafkaAdminClient):
         self,
     ) -> set[str]:
         return self.__resolve_cached_property(
-            TOPIC_CACHE_KEY, lambda: set(self._kafka_admin.list_topics()) - INTERNAL_KAFKA_TOPICS
+            TOPIC_CACHE_KEY, lambda: set(self._get_kafka_admin().list_topics()) - INTERNAL_KAFKA_TOPICS
         )
 
     def __resolve_cached_property(self, property_key: str, callback: Callable) -> Any:
@@ -110,7 +135,7 @@ class KafkaPythonAdminClient(KafkaAdminClient):
         *,
         topics: set[str],
     ) -> None:
-        self._kafka_admin.delete_topics(
+        self._get_kafka_admin().delete_topics(
             topics=topics,
         )
         self.__remove_cache_property(TOPIC_CACHE_KEY)
@@ -123,18 +148,18 @@ class KafkaPythonAdminClient(KafkaAdminClient):
         *,
         subscription_groups: set[str],
     ) -> None:
-        self._kafka_admin.delete_consumer_groups(
+        self._get_kafka_admin().delete_consumer_groups(
             group_ids=subscription_groups,
         )
 
-    def get_subscription_groups(
+    def get_cluster_consumer_groups(
         self,
     ) -> set[str]:
-        return set(self._kafka_admin.list_consumer_groups())
+        return set([consumer_group_tuple[0] for consumer_group_tuple in self._get_kafka_admin().list_consumer_groups()])
 
     def _wait_for_cluster_update(self) -> None:
-        future = self._kafka_client.cluster.request_update()
-        self._kafka_client.poll(future=future)
+        future = self._get_kafka_client().cluster.request_update()
+        self._get_kafka_client().poll(future=future)
 
     def move_offsets_to_datetime(
         self,
@@ -143,6 +168,46 @@ class KafkaPythonAdminClient(KafkaAdminClient):
         topic: str,
         target_datetime: datetime,
     ) -> None:
+        (consumer, topic_partitions) = self.__get_consumer_with_all_partitions_assigned(
+            consumer_group=consumer_group,
+            topic=topic,
+        )
+
+        offsets_for_date = self.__get_first_offset_after_date(
+            consumer=consumer,
+            topic_partitions=topic_partitions,
+            target_datetime=target_datetime,
+        )
+
+        try:
+            end_offsets = consumer.end_offsets(topic_partitions)
+
+            if end_offsets is None or len(end_offsets.keys()) != len(topic_partitions):
+                raise Exception(f'There was an error extracting the end offsets of the topic "{topic}"')
+
+            for topic_partition in topic_partitions:
+                offset_and_timestamp = offsets_for_date.get(topic_partition)
+                if offset_and_timestamp:
+                    self._logger.info(f'moving "{topic_partition}" to the offset "{offset_and_timestamp.offset}"')
+                    consumer.seek(topic_partition, offset_and_timestamp.offset)
+                else:
+                    self._logger.info(
+                        f'moving "{topic_partition}" to the end of the topic because there are no messages later than "{target_datetime}"'
+                    )
+                    consumer.seek(topic_partition, end_offsets[topic_partition])
+
+            consumer.commit()
+        except Exception as exception:
+            consumer.close()
+            raise exception
+
+        consumer.close()
+
+    def __get_consumer_with_all_partitions_assigned(
+        self,
+        consumer_group: str,
+        topic: str,
+    ) -> tuple[KafkaConsumer, Sequence[TopicPartition]]:
         consumer = KafkaConsumer(
             group_id=consumer_group,
             enable_auto_commit=False,
@@ -152,44 +217,29 @@ class KafkaPythonAdminClient(KafkaAdminClient):
             **self._config_in_library_format,
         )
 
-        partitions = consumer.partitions_for_topic(topic)
-
-        if partitions is None:
-            raise TopicNotFoundException(topic)
-
-        topic_partitions = [TopicPartition(topic, p) for p in partitions]
-        consumer.subscribe(topics=[topic])
-
-        self.__force_partition_assignment(consumer)
+        try:
+            partitions = self.get_number_of_partitions(topic)
 
-        # We need all the partitions in order to update the offsets
-        if len(consumer.assignment()) != len(topic_partitions):
-            raise NotAllPartitionAssignedException(topic)
+            topic_partitions = [TopicPartition(topic=topic, partition=partition) for partition in range(partitions)]
 
-        offsets_for_date = self.__get_first_offset_after_date(
-            consumer=consumer,
-            topic_partitions=topic_partitions,
-            target_datetime=target_datetime,
-        )
+            consumer.subscribe(topic)
 
-        end_offsets = consumer.end_offsets(topic_partitions)
+            self.__force_partition_assignment(consumer)
 
-        if end_offsets is None or len(end_offsets.keys()) != len(topic_partitions):
-            raise Exception(f'There was an error extracting the end offsets of the topic "{topic}"')
+            # We need all the partitions in order to update the offsets
+            if len(consumer.assignment()) != len(topic_partitions):
+                raise NotAllPartitionAssignedException(topic)
 
-        for topic_partition in topic_partitions:
-            offset_and_timestamp = offsets_for_date.get(topic_partition)
-            if offset_and_timestamp:
-                self._logger.info(f'moving "{topic_partition}" to the offset "{offset_and_timestamp.offset}"')
-                consumer.seek(topic_partition, offset_and_timestamp.offset)
-            else:
-                self._logger.info(
-                    f'moving "{topic_partition}" to the end of the topic because there are no messages later than "{target_datetime}"'
-                )
-                consumer.seek(topic_partition, end_offsets[topic_partition])
+            # This could produce a race condition, but it is a limitation of kafka admin (we are not able to check if all the partition are assigned using the manual assignment)
+            # https://github.com/dpkp/kafka-python/blob/master/kafka/consumer/group.py#L430
+            consumer.unsubscribe()
+            consumer.assign(topic_partitions)
+            self.__force_partition_assignment(consumer)
 
-        consumer.commit()
-        consumer.close()
+            return (consumer, topic_partitions)
+        except Exception as exception:
+            consumer.close()
+            raise exception
 
     def __get_first_offset_after_date(
         self,
@@ -212,3 +262,138 @@ class KafkaPythonAdminClient(KafkaAdminClient):
     # We are not to commit the new offset, but we need to execute a polling in order to start the partition assignment
     def __force_partition_assignment(self, consumer: KafkaConsumer) -> None:
         consumer.poll(max_records=1, timeout_ms=0)
+
+    def increase_topic_partitions_and_set_offset_of_related_consumer_groups_to_the_beginning_of_the_new_ones(
+        self,
+        *,
+        topic: str,
+        new_number_of_partitions: int,
+    ) -> None:
+        self._logger.info(
+            f'Increasing topic "{topic}" partitions: Verifying the new number of partitions "{new_number_of_partitions}"'
+        )
+
+        previous_partitions_number = self.get_number_of_partitions(topic)
+        topic_partitions = [
+            TopicPartition(topic=topic, partition=partition) for partition in range(previous_partitions_number)
+        ]
+
+        if previous_partitions_number >= new_number_of_partitions:
+            raise NotValidPartitionNumberException(
+                partition_number=new_number_of_partitions,
+                min_partition_number=len(topic_partitions),
+            )
+
+        self._logger.info(f'Increasing topic "{topic}" partitions: Extracting related consumer groups')
+        related_consumer_groups = self.__get_consumer_groups_related_to_a_topic(topic_partitions)
+
+        self._logger.info(
+            f'Increasing topic "{topic}" partitions: The following consumer groups will be updated:"{related_consumer_groups}"'
+        )
+
+        consumers_to_update: list[KafkaConsumer] = []
+        new_partitions_consumer: Optional[KafkaConsumer] = None
+
+        try:
+            for consumer_group in related_consumer_groups:
+                self._logger.info(
+                    f'Increasing topic "{topic}" partitions: Requesting the assignment of the partitions of the group "{consumer_group}"'
+                )
+                (consumer_with_all_partitions, _) = self.__get_consumer_with_all_partitions_assigned(
+                    consumer_group=consumer_group,
+                    topic=topic,
+                )
+                consumers_to_update.append(consumer_with_all_partitions)
+
+            self._logger.info(
+                f'Increasing topic "{topic}" partitions: Incrementing the partition to "{new_number_of_partitions}"'
+            )
+
+            self._get_kafka_admin().create_partitions(
+                {
+                    topic: NewPartitions(total_count=new_number_of_partitions),
+                }
+            )
+
+            new_partitions = [
+                TopicPartition(
+                    topic=topic,
+                    partition=partition_index,
+                )
+                for partition_index in range(previous_partitions_number, new_number_of_partitions)
+            ]
+
+            for consumer_group in related_consumer_groups:
+                self._logger.info(
+                    f'Increasing topic "{topic}" partitions: Moving the offset of the consumer group "{consumer_group}" to the beginning of the new partitions'
+                )
+                # We need to create a new consumer because kafka-python has a limitation that does not allow to assign specific partitions to a consumer subscribed to an entire topic
+                new_partitions_consumer = KafkaConsumer(
+                    group_id=consumer_group,
+                    enable_auto_commit=False,
+                    auto_offset_reset=KafkaPythonConsumerInitialOffsetPositionTranslator.to_kafka_supported_format(
+                        ConsumerInitialOffsetPosition.BEGINNING
+                    ),
+                    **self._config_in_library_format,
+                )
+                new_partitions_consumer.assign(new_partitions)
+                for new_partition in new_partitions:
+                    new_partitions_consumer.seek(new_partition, 0)
+                new_partitions_consumer.commit()
+                new_partitions_consumer.close()
+
+            self._logger.info(f'Increasing topic "{topic}" partitions: Process complete')
+
+        except Exception as exception:
+            for consumer_with_all_partitions in consumers_to_update:
+                consumer_with_all_partitions.close()
+
+            if new_partitions_consumer is not None:
+                new_partitions_consumer.close()
+
+            self._logger.error(f'Increasing topic "{topic}" partitions: unexpected error {exception}')
+            raise exception
+
+        return
+
+    def get_number_of_partitions(self, topic: str) -> int:
+        consumer = KafkaConsumer(
+            enable_auto_commit=False,
+            auto_offset_reset=KafkaPythonConsumerInitialOffsetPositionTranslator.to_kafka_supported_format(
+                ConsumerInitialOffsetPosition.BEGINNING
+            ),
+            **self._config_in_library_format,
+        )
+
+        try:
+            partitions = consumer.partitions_for_topic(topic)
+            if partitions is None:
+                raise TopicNotFoundException(topic_name=topic)
+
+            return len(partitions)
+        except Exception as exception:
+            consumer.close()
+            raise exception
+
+    # The purpose of this function is to get all the consumer groups that are consuming from the topic
+    # It is a heavy tasks because we need to get the offset of all the partitions of the topic
+    def __get_consumer_groups_related_to_a_topic(self, topic_partitions: Sequence[TopicPartition]) -> set[str]:
+        cluster_consumer_groups = self.get_cluster_consumer_groups()
+
+        related_consumer_groups: set[str] = set()
+
+        for consumer_group in cluster_consumer_groups:
+            partitions_offsets = list(
+                self._get_kafka_admin()
+                .list_consumer_group_offsets(consumer_group, partitions=topic_partitions)
+                .values()
+            )
+
+            partitions_with_valid_offsets = [partition for partition in partitions_offsets if partition.offset != -1]
+
+            if len(partitions_with_valid_offsets) == 0:
+                continue
+
+            related_consumer_groups.add(consumer_group)
+
+        return related_consumer_groups

buz/kafka/infrastructure/kafka_python/kafka_python_admin_test_client.py

@@ -27,10 +27,10 @@ class KafkaPythonAdminTestClient(KafkaPythonAdminClient, KafkaAdminTestClient):
         self,
         *,
         logger: Logger,
-        config: KafkaConnectionConfig,
+        connection_config: KafkaConnectionConfig,
     ):
         super().__init__(
-            config=config,
+            connection_config=connection_config,
             logger=logger,
         )
 
@@ -88,5 +88,5 @@ class KafkaPythonAdminTestClient(KafkaPythonAdminClient, KafkaAdminTestClient):
         self,
     ) -> None:
         self.delete_topics(topics=self.get_topics())
-        self.delete_subscription_groups(subscription_groups=self.get_subscription_groups())
+        self.delete_subscription_groups(subscription_groups=self.get_cluster_consumer_groups())
         self._wait_for_cluster_update()

buz/kafka/infrastructure/kafka_python/kafka_python_producer.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
-from typing import Generic, Optional, TypeVar
+from typing import Generic, Optional, TypeVar, cast
 
 from kafka import KafkaProducer as KafkaPythonLibraryProducer
+from kafka.producer.future import FutureRecordMetadata
 
 from buz.kafka.domain.models.kafka_connection_config import KafkaConnectionConfig
+from buz.kafka.domain.models.kafka_supported_compression_type import KafkaSupportedCompressionType
 from buz.kafka.domain.services.kafka_producer import KafkaProducer
 from buz.kafka.infrastructure.serializers.byte_serializer import ByteSerializer
 from buz.kafka.infrastructure.serializers.kafka_header_serializer import KafkaHeaderSerializer
@@ -13,33 +15,55 @@ T = TypeVar("T")
 
 
 class KafkaPythonProducer(KafkaProducer, Generic[T]):
+    __kafka_producer: Optional[KafkaPythonLibraryProducer] = None
+    __SEND_TIMEOUT_SECONDS = 5
+
     def __init__(
         self,
         *,
-        config: KafkaConnectionConfig,
+        connection_config: KafkaConnectionConfig,
         byte_serializer: ByteSerializer[T],
         retries: int = 0,
         retry_backoff_ms: int = 100,
+        compression_type: Optional[KafkaSupportedCompressionType] = None,
     ) -> None:
-        self.__config = config
+        self.__connection_config = connection_config
         self.__byte_serializer = byte_serializer
         self.__header_serializer = KafkaHeaderSerializer()
+        self.__retries = retries
+        self.__retry_backoff_ms = retry_backoff_ms
+        self.__compression_type = compression_type
 
-        sasl_mechanism: Optional[str] = None
+    def _get_kafka_producer(self) -> KafkaPythonLibraryProducer:
+        if self.__kafka_producer is None:
+            sasl_mechanism = (
+                self.__connection_config.credentials.sasl_mechanism.value
+                if self.__connection_config.credentials.sasl_mechanism
+                else None
+            )
+            compression_type = self.__compression_type.value if self.__compression_type else None
 
-        if self.__config.credentials.sasl_mechanism is not None:
-            sasl_mechanism = self.__config.credentials.sasl_mechanism.value
+            self.__kafka_producer = KafkaPythonLibraryProducer(
+                client_id=self.__connection_config.client_id,
+                bootstrap_servers=self.__connection_config.bootstrap_servers,
+                security_protocol=self.__connection_config.credentials.security_protocol.value,
+                sasl_mechanism=sasl_mechanism,
+                sasl_plain_username=self.__connection_config.credentials.user,
+                sasl_plain_password=self.__connection_config.credentials.password,
+                retries=self.__retries,
+                retry_backoff_ms=self.__retry_backoff_ms,
+                compression_type=compression_type,
+            )
 
-        self.__kafka_producer = KafkaPythonLibraryProducer(
-            client_id=self.__config.client_id,
-            bootstrap_servers=self.__config.bootstrap_servers,
-            security_protocol=self.__config.credentials.security_protocol.value,
-            sasl_mechanism=sasl_mechanism,
-            sasl_plain_username=self.__config.credentials.user,
-            sasl_plain_password=self.__config.credentials.password,
-            retries=retries,
-            retry_backoff_ms=retry_backoff_ms,
-        )
+        return self.__kafka_producer
+
+    def connect(self):
+        self._get_kafka_producer()
+
+    def disconnect(self) -> None:
+        if self.__kafka_producer is not None:
+            self.__kafka_producer.close()
+            self.__kafka_producer = None
 
     def produce(
         self,
@@ -50,12 +74,17 @@ class KafkaPythonProducer(KafkaProducer, Generic[T]):
         headers: Optional[dict[str, str]] = None,
     ) -> None:
         serialized_headers = self.__header_serializer.serialize(headers) if headers is not None else None
+        kafka_producer = self._get_kafka_producer()
 
-        self.__kafka_producer.send(
-            topic=topic,
-            value=self.__byte_serializer.serialize(message),
-            headers=serialized_headers,
-            key=partition_key,
+        message_future = cast(
+            FutureRecordMetadata,
+            kafka_producer.send(
+                topic=topic,
+                value=self.__byte_serializer.serialize(message),
+                headers=serialized_headers,
+                key=partition_key,
+            ),
         )
+
         # We are forcing a flush because the task related with the send is asynchronous, and we want that the event to be sent after call produce
-        self.__kafka_producer.flush()
+        message_future.get(self.__SEND_TIMEOUT_SECONDS)

{buz-2.13.1rc9.dist-info → buz-2.14.1.dist-info}/METADATA

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