buz 2.25.0__tar.gz → 2.26.1__tar.gz

{buz-2.25.0 → buz-2.26.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buz
-Version: 2.25.0
+Version: 2.26.1
 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.25.0 → buz-2.26.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "buz"
-version = "2.25.0"
+version = "2.26.1"
 description = "Buz is a set of light, simple and extensible implementations of event, command and query buses."
 readme = "README.md"
 authors = [

buz-2.26.1/src/buz/event/async_event_bus_with_publish_result.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+from typing import Collection
+
+from buz.event import Event
+from buz.event.event_bus_publish_result import EventBusPublishResult
+from buz.kafka.infrastructure.interfaces.async_connection_manager import AsyncConnectionManager
+
+
+class AsyncEventBusWithPublishResult(AsyncConnectionManager, ABC):
+    """
+    Event bus with publish result tracking capabilities.
+
+    Unlike AsyncEventBus which returns None, this event bus returns
+    EventBusPublishResult to report which events succeeded and which failed.
+
+    This enables:
+    - Partial success tracking
+    - Fail-fast behavior with precise tracking
+    - Application-level retry control
+    - Better observability
+    """
+
+    @abstractmethod
+    async def publish(self, event: Event) -> None:
+        pass
+
+    @abstractmethod
+    async def bulk_publish(self, events: Collection[Event]) -> EventBusPublishResult:
+        """
+        Publish multiple events and return detailed results.
+
+        Returns:
+            EventBusPublishResult containing published_events and failed_events
+        """
+        pass

{buz-2.25.0 → buz-2.26.1}/src/buz/event/event.py

@@ -1,6 +1,8 @@
 from dataclasses import dataclass
 
-from buz import Message
+from buz.message import Message, MessageId
+
+EventId = MessageId
 
 
 @dataclass(frozen=True)

buz-2.26.1/src/buz/event/event_bus_publish_result.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from typing import Collection
+
+from buz.event import Event
+
+
+@dataclass
+class EventBusPublishResult:
+    published_events: Collection[Event]
+    failed_events: Collection[Event]

buz-2.26.1/src/buz/event/infrastructure/buz_kafka/async_buz_kafka_event_bus.py

@@ -0,0 +1,48 @@
+from logging import Logger
+from typing import Collection, Optional
+
+from buz.event import Event
+from buz.event.async_event_bus import AsyncEventBus
+from buz.event.infrastructure.buz_kafka.base_async_buz_kafka_event_bus import BaseAsyncBuzKafkaEventBus
+from buz.event.infrastructure.buz_kafka.publish_strategy.publish_strategy import KafkaPublishStrategy
+from buz.event.middleware.async_publish_middleware import AsyncPublishMiddleware
+from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
+from buz.kafka.domain.services.async_kafka_producer import AsyncKafkaProducer
+from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
+from buz.kafka.infrastructure.serializers.partitiion_key_generator import PartitionKeySerializer
+
+
+class AsyncBuzKafkaEventBus(BaseAsyncBuzKafkaEventBus, AsyncEventBus):
+    """
+    Async Kafka event bus with simple behavior (consistent with sync version).
+
+    - Returns None from bulk_publish
+    - Raises exception on failure
+    - No retry logic
+    """
+
+    def __init__(
+        self,
+        *,
+        publish_strategy: KafkaPublishStrategy,
+        producer: AsyncKafkaProducer,
+        logger: Logger,
+        kafka_admin_client: Optional[KafkaAdminClient] = None,
+        publish_middlewares: Optional[list[AsyncPublishMiddleware]] = None,
+        auto_create_topic_configuration: Optional[AutoCreateTopicConfiguration] = None,
+        partition_key_generator: Optional[PartitionKeySerializer] = None,
+    ):
+        super().__init__(
+            publish_strategy=publish_strategy,
+            producer=producer,
+            logger=logger,
+            kafka_admin_client=kafka_admin_client,
+            publish_middlewares=publish_middlewares,
+            auto_create_topic_configuration=auto_create_topic_configuration,
+            partition_key_generator=partition_key_generator,
+        )
+
+    async def bulk_publish(self, events: Collection[Event]) -> None:
+        """Publish all events sequentially. Raises exception on first failure."""
+        for event in events:
+            await self.publish(event)

buz-2.26.1/src/buz/event/infrastructure/buz_kafka/async_buz_kafka_event_bus_with_publish_result.py

@@ -0,0 +1,80 @@
+from logging import Logger
+from typing import Collection, Optional
+
+from buz.event import Event
+from buz.event.async_event_bus_with_publish_result import AsyncEventBusWithPublishResult
+from buz.event.event_bus_publish_result import EventBusPublishResult
+from buz.event.infrastructure.buz_kafka.base_async_buz_kafka_event_bus import BaseAsyncBuzKafkaEventBus
+from buz.event.infrastructure.buz_kafka.publish_strategy.publish_strategy import KafkaPublishStrategy
+from buz.event.middleware.async_publish_middleware import AsyncPublishMiddleware
+from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
+from buz.kafka.domain.services.async_kafka_producer import AsyncKafkaProducer
+from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
+from buz.kafka.infrastructure.serializers.partitiion_key_generator import PartitionKeySerializer
+
+
+class AsyncBuzKafkaEventBusWithPublishResult(BaseAsyncBuzKafkaEventBus, AsyncEventBusWithPublishResult):
+    """
+    Kafka event bus with publish result tracking and fail-fast behavior.
+
+    Features:
+    - Returns EventBusPublishResult with published/failed events
+    - Fail-fast behavior (stops on first failure)
+    - Partial success tracking for external state management
+    """
+
+    def __init__(
+        self,
+        *,
+        publish_strategy: KafkaPublishStrategy,
+        producer: AsyncKafkaProducer,
+        logger: Logger,
+        kafka_admin_client: Optional[KafkaAdminClient] = None,
+        publish_middlewares: Optional[list[AsyncPublishMiddleware]] = None,
+        auto_create_topic_configuration: Optional[AutoCreateTopicConfiguration] = None,
+        partition_key_generator: Optional[PartitionKeySerializer] = None,
+    ):
+        super().__init__(
+            publish_strategy=publish_strategy,
+            producer=producer,
+            logger=logger,
+            kafka_admin_client=kafka_admin_client,
+            publish_middlewares=publish_middlewares,
+            auto_create_topic_configuration=auto_create_topic_configuration,
+            partition_key_generator=partition_key_generator,
+        )
+
+    async def bulk_publish(self, events: Collection[Event]) -> EventBusPublishResult:
+        """
+        Publish events one by one with fail-fast behavior.
+
+        Publishes events sequentially. If any event fails, stops immediately and returns the result with:
+        - published_events: All events successfully published before the failure
+        - failed_events: The first event that failed (only one event)
+
+        This allows the caller to track which events were sent and which were not,
+        enabling proper state management in external systems.
+
+        Note: Kafka automatically handles partition assignment based on partition_key.
+        Events with the same partition_key will go to the same partition and maintain order.
+
+        Returns:
+            EventBusPublishResult with published_events and failed_events
+        """
+        published_events: list[Event] = []
+        failed_events: list[Event] = []
+
+        # FAIL-FAST: Stop on first failure
+        for event in events:
+            try:
+                await self.publish(event)
+                published_events.append(event)
+            except Exception as exc:
+                self._logger.error(f"Failed to publish event {event.id}. Error: {exc}")
+                failed_events.append(event)
+                break
+
+        return EventBusPublishResult(
+            published_events=published_events,
+            failed_events=failed_events,
+        )

buz-2.26.1/src/buz/event/infrastructure/buz_kafka/base_async_buz_kafka_event_bus.py

@@ -0,0 +1,118 @@
+from logging import Logger
+from typing import Optional
+
+from buz.event import Event
+from buz.event.exceptions.event_not_published_exception import EventNotPublishedException
+from buz.event.infrastructure.buz_kafka.exceptions.kafka_event_bus_config_not_valid_exception import (
+    KafkaEventBusConfigNotValidException,
+)
+from buz.event.infrastructure.buz_kafka.publish_strategy.publish_strategy import KafkaPublishStrategy
+from buz.event.middleware.async_publish_middleware import AsyncPublishMiddleware
+from buz.event.middleware.async_publish_middleware_chain_resolver import AsyncPublishMiddlewareChainResolver
+from buz.kafka.domain.exceptions.topic_already_created_exception import KafkaTopicsAlreadyCreatedException
+from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
+from buz.kafka.domain.models.create_kafka_topic import CreateKafkaTopic
+from buz.kafka.domain.services.async_kafka_producer import AsyncKafkaProducer
+from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
+from buz.kafka.infrastructure.serializers.implementations.cdc_partition_key_serializer import CDCPartitionKeySerializer
+from buz.kafka.infrastructure.serializers.partitiion_key_generator import PartitionKeySerializer
+
+
+class BaseAsyncBuzKafkaEventBus:
+    """
+    Base class for async Kafka event buses with common functionality.
+
+    Provides:
+    - Event publishing with middleware support
+    - Topic auto-creation
+    - Partition key generation
+    - Connection management
+    """
+
+    def __init__(
+        self,
+        *,
+        publish_strategy: KafkaPublishStrategy,
+        producer: AsyncKafkaProducer,
+        logger: Logger,
+        kafka_admin_client: Optional[KafkaAdminClient] = None,
+        publish_middlewares: Optional[list[AsyncPublishMiddleware]] = None,
+        auto_create_topic_configuration: Optional[AutoCreateTopicConfiguration] = None,
+        partition_key_generator: Optional[PartitionKeySerializer] = None,
+    ):
+        self._publish_middleware_chain_resolver = AsyncPublishMiddlewareChainResolver(publish_middlewares or [])
+        self._publish_strategy = publish_strategy
+        self._producer = producer
+        self._topics_checked: dict[str, bool] = {}
+        self._kafka_admin_client = kafka_admin_client
+        self._auto_create_topic_configuration = auto_create_topic_configuration
+        self._logger = logger
+        self._partition_key_generator: PartitionKeySerializer = partition_key_generator or CDCPartitionKeySerializer()
+        self._check_kafka_admin_client_is_needed()
+
+    def _check_kafka_admin_client_is_needed(self) -> None:
+        if self._kafka_admin_client is None and self._auto_create_topic_configuration is not None:
+            raise KafkaEventBusConfigNotValidException(
+                "A KafkaAdminClient is needed to create topics when 'auto_create_topic_configuration' is set."
+            )
+
+    async def publish(self, event: Event) -> None:
+        """Publish a single event through the middleware chain."""
+        await self._publish_middleware_chain_resolver.resolve(event, self._perform_publish)
+
+    async def _perform_publish(self, event: Event) -> None:
+        try:
+            topic = self._publish_strategy.get_topic(event)
+
+            if self._auto_create_topic_configuration is not None and self._is_topic_created(topic) is False:
+                try:
+                    self._logger.info(f"Creating missing topic: {topic}..")
+                    self._get_kafka_admin_client().create_topics(
+                        topics=[
+                            CreateKafkaTopic(
+                                name=topic,
+                                partitions=self._auto_create_topic_configuration.partitions,
+                                replication_factor=self._auto_create_topic_configuration.replication_factor,
+                                configs=self._auto_create_topic_configuration.configs,
+                            )
+                        ]
+                    )
+                    self._logger.info(f"Created missing topic: {topic}")
+                    self._topics_checked[topic] = True
+                except KafkaTopicsAlreadyCreatedException:
+                    pass
+
+            headers = self._get_event_headers(event)
+            await self._producer.produce(
+                message=event,
+                headers=headers,
+                topic=topic,
+                partition_key=self._partition_key_generator.generate_key(event),
+            )
+        except Exception as exc:
+            raise EventNotPublishedException(event) from exc
+
+    def _get_kafka_admin_client(self) -> KafkaAdminClient:
+        if self._kafka_admin_client is None:
+            raise KafkaEventBusConfigNotValidException("KafkaAdminClient is not set.")
+        return self._kafka_admin_client
+
+    def _is_topic_created(self, topic: str) -> bool:
+        is_topic_created = self._topics_checked.get(topic, None)
+
+        if is_topic_created is not None:
+            return is_topic_created
+
+        is_topic_created = self._get_kafka_admin_client().is_topic_created(topic)
+        self._topics_checked[topic] = is_topic_created
+
+        return is_topic_created
+
+    def _get_event_headers(self, event: Event) -> dict:
+        return {"id": event.id}
+
+    async def connect(self) -> None:
+        await self._producer.connect()
+
+    async def disconnect(self) -> None:
+        await self._producer.disconnect()

{buz-2.25.0 → buz-2.26.1}/src/buz/event/middleware/__init__.py

@@ -1,10 +1,12 @@
 from buz.event.middleware.base_async_consume_middleware import BaseAsyncConsumeMiddleware
+from buz.event.middleware.base_async_publish_middleware import BaseAsyncPublishMiddleware
 from buz.event.middleware.publish_middleware import PublishMiddleware, PublishCallable
 from buz.event.middleware.base_publish_middleware import BasePublishMiddleware
 from buz.event.middleware.publish_middleware_chain_resolver import PublishMiddlewareChainResolver
 from buz.event.middleware.consume_middleware import ConsumeMiddleware, ConsumeCallable
 from buz.event.middleware.base_consume_middleware import BaseConsumeMiddleware
 from buz.event.middleware.consume_middleware_chain_resolver import ConsumeMiddlewareChainResolver
+from buz.event.middleware.async_publish_middleware import AsyncPublishMiddleware, AsyncPublishCallable
 
 __all__ = [
     "PublishMiddleware",
@@ -16,4 +18,7 @@ __all__ = [
     "BaseConsumeMiddleware",
     "ConsumeMiddlewareChainResolver",
     "BaseAsyncConsumeMiddleware",
+    "BaseAsyncPublishMiddleware",
+    "AsyncPublishMiddleware",
+    "AsyncPublishCallable",
 ]

buz-2.26.1/src/buz/event/middleware/base_async_publish_middleware.py

@@ -0,0 +1,27 @@
+from abc import abstractmethod
+
+from buz.event import Event
+from buz.event.middleware.async_publish_middleware import AsyncPublishCallable, AsyncPublishMiddleware
+
+
+class BaseAsyncPublishMiddleware(AsyncPublishMiddleware):
+    """
+    Base class for async publish middlewares with before/after hooks.
+    Provides a template pattern for middleware that need to execute logic
+    before and after event publishing.
+    """
+
+    async def on_publish(self, event: Event, publish: AsyncPublishCallable) -> None:
+        await self._before_on_publish(event)
+        await publish(event)
+        await self._after_on_publish(event)
+
+    @abstractmethod
+    async def _before_on_publish(self, event: Event) -> None:
+        """Hook executed before publishing the event."""
+        pass
+
+    @abstractmethod
+    async def _after_on_publish(self, event: Event) -> None:
+        """Hook executed after publishing the event."""
+        pass

{buz-2.25.0 → buz-2.26.1}/src/buz/event/strategies/retry/max_retries_consume_retrier.py

@@ -15,9 +15,9 @@ class MaxRetriesConsumeRetrier(ConsumeRetrier):
     ):
         self.__consumed_event_retry_repository = consumed_event_retry_repository
         self.__max_retries = max_retries
-        self.__check_max_retries_positive()
+        self.__validate_retries()
 
-    def __check_max_retries_positive(self) -> None:
+    def __validate_retries(self) -> None:
         if self.__max_retries < 0:
             raise InvalidMaxRetriesParamException(self.__max_retries)
 
@@ -26,7 +26,9 @@ class MaxRetriesConsumeRetrier(ConsumeRetrier):
             event,
             subscribers,
         )
-        return consumed_event_retry.retries < self.__max_retries
+
+        # The number of executions is 1 (the initial execution) + the number of retries
+        return consumed_event_retry.retries < (self.__max_retries + 1)
 
     def register_retry(self, event: Event, subscribers: Sequence[MetaSubscriber]) -> None:
         consumed_event_retry = self.__consumed_event_retry_repository.find_one_by_event_and_subscriber(

{buz-2.25.0 → buz-2.26.1}/src/buz/kafka/__init__.py

@@ -22,10 +22,10 @@ from buz.kafka.infrastructure.kafka_python.kafka_python_producer import KafkaPyt
 from buz.kafka.infrastructure.serializers.byte_serializer import ByteSerializer
 from buz.kafka.infrastructure.serializers.implementations.json_byte_serializer import JSONByteSerializer
 from buz.kafka.domain.models.kafka_supported_compression_type import KafkaSupportedCompressionType
+
 from buz.event.infrastructure.buz_kafka.exceptions.kafka_event_bus_config_not_valid_exception import (
     KafkaEventBusConfigNotValidException,
 )
-from buz.event.infrastructure.buz_kafka.async_buz_kafka_event_bus import AsyncBuzKafkaEventBus
 from buz.event.infrastructure.buz_kafka.buz_kafka_event_bus import BuzKafkaEventBus
 
 
@@ -46,7 +46,6 @@ __all__ = [
     "ConsumerInitialOffsetPosition",
     "KafkaSupportedCompressionType",
     "KafkaEventBusConfigNotValidException",
-    "AsyncBuzKafkaEventBus",
     "BuzKafkaEventBus",
     "AutoCreateTopicConfiguration",
     "NotAllPartitionAssignedException",

{buz-2.25.0 → buz-2.26.1}/src/buz/kafka/infrastructure/aiokafka/aiokafka_producer.py

@@ -52,6 +52,7 @@ class AIOKafkaProducer(AsyncKafkaProducer, Generic[T]):
         self.__kafka_producer = NativeAIOKafkaProducer(
             client_id=self.__connection_config.client_id,
             bootstrap_servers=",".join(self.__connection_config.bootstrap_servers),
+            security_protocol=self.__connection_config.credentials.security_protocol.value,
             sasl_mechanism=sasl_mechanism,
             ssl_context=ssl_context,
             sasl_plain_username=self.__connection_config.credentials.user,
@@ -91,8 +92,3 @@ class AIOKafkaProducer(AsyncKafkaProducer, Generic[T]):
             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-2.25.0 → buz-2.26.1}/src/buz/kafka/infrastructure/kafka_python/kafka_python_admin_test_client.py

@@ -79,8 +79,7 @@ class KafkaPythonAdminTestClient(KafkaPythonAdminClient, KafkaAdminTestClient):
         )
 
         consumer.close()
-
-        topic_records = records[0] if len(records) > 0 else []
+        topic_records = list(sum(records, []))
 
         return topic_records
 

{buz-2.25.0 → buz-2.26.1}/src/buz/message.py

@@ -3,7 +3,7 @@ from dataclasses import field, dataclass
 from datetime import datetime
 from inspect import signature, Parameter
 from types import MappingProxyType
-from typing import Any, ClassVar, get_origin, get_args, Union
+from typing import Any, ClassVar, NewType, get_origin, get_args, Union
 from typing_extensions import Self
 
 from uuid_utils.compat import uuid7
@@ -11,6 +11,9 @@ from uuid_utils.compat import uuid7
 from buz.metadata import Metadata
 
 
+MessageId = NewType("MessageId", str)
+
+
 @dataclass(frozen=True)
 class Message(ABC):
     DATE_TIME_FORMAT: ClassVar[str] = "%Y-%m-%d %H:%M:%S.%f"

buz-2.25.0/src/buz/event/infrastructure/buz_kafka/async_buz_kafka_event_bus.py

@@ -1,108 +0,0 @@
-from logging import Logger
-from typing import Collection, Optional
-
-from buz.event import Event
-from buz.event.async_event_bus import AsyncEventBus
-from buz.event.exceptions.event_not_published_exception import EventNotPublishedException
-from buz.event.infrastructure.buz_kafka.exceptions.kafka_event_bus_config_not_valid_exception import (
-    KafkaEventBusConfigNotValidException,
-)
-from buz.event.infrastructure.buz_kafka.publish_strategy.publish_strategy import KafkaPublishStrategy
-from buz.event.middleware.async_publish_middleware import AsyncPublishMiddleware
-from buz.event.middleware.async_publish_middleware_chain_resolver import AsyncPublishMiddlewareChainResolver
-from buz.kafka.domain.exceptions.topic_already_created_exception import KafkaTopicsAlreadyCreatedException
-from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
-from buz.kafka.domain.models.create_kafka_topic import CreateKafkaTopic
-from buz.kafka.domain.services.async_kafka_producer import AsyncKafkaProducer
-from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
-
-
-class AsyncBuzKafkaEventBus(AsyncEventBus):
-    def __init__(
-        self,
-        *,
-        publish_strategy: KafkaPublishStrategy,
-        producer: AsyncKafkaProducer,
-        logger: Logger,
-        kafka_admin_client: Optional[KafkaAdminClient] = None,
-        publish_middlewares: Optional[list[AsyncPublishMiddleware]] = None,
-        auto_create_topic_configuration: Optional[AutoCreateTopicConfiguration] = None,
-    ):
-        self.__publish_middleware_chain_resolver = AsyncPublishMiddlewareChainResolver(publish_middlewares or [])
-        self.__publish_strategy = publish_strategy
-        self.__producer = producer
-        self.__topics_checked: dict[str, bool] = {}
-        self.__kafka_admin_client = kafka_admin_client
-        self.__auto_create_topic_configuration = auto_create_topic_configuration
-        self.__logger = logger
-        self.__check_kafka_admin_client_is_needed()
-
-    def __check_kafka_admin_client_is_needed(self) -> None:
-        if self.__kafka_admin_client is None and self.__auto_create_topic_configuration is not None:
-            raise KafkaEventBusConfigNotValidException(
-                "A KafkaAdminClient is needed to create topics when 'auto_create_topic_configuration' is set."
-            )
-
-    async def publish(self, event: Event) -> None:
-        await self.__publish_middleware_chain_resolver.resolve(event, self.__perform_publish)
-
-    async def __perform_publish(self, event: Event) -> None:
-        try:
-            topic = self.__publish_strategy.get_topic(event)
-
-            if self.__auto_create_topic_configuration is not None and self.__is_topic_created(topic) is False:
-                try:
-                    self.__logger.info(f"Creating missing topic: {topic}..")
-                    self.__get_kafka_admin_client().create_topics(
-                        topics=[
-                            CreateKafkaTopic(
-                                name=topic,
-                                partitions=self.__auto_create_topic_configuration.partitions,
-                                replication_factor=self.__auto_create_topic_configuration.replication_factor,
-                                configs=self.__auto_create_topic_configuration.configs,
-                            )
-                        ]
-                    )
-                    self.__logger.info(f"Created missing topic: {topic}")
-                    self.__topics_checked[topic] = True
-                except KafkaTopicsAlreadyCreatedException:
-                    pass
-
-            headers = self.__get_event_headers(event)
-            await self.__producer.produce(
-                message=event,
-                headers=headers,
-                topic=topic,
-                partition_key=event.partition_key(),
-            )
-        except Exception as exc:
-            raise EventNotPublishedException(event) from exc
-
-    def __get_kafka_admin_client(self) -> KafkaAdminClient:
-        if self.__kafka_admin_client is None:
-            raise KafkaEventBusConfigNotValidException("KafkaAdminClient is not set.")
-        return self.__kafka_admin_client
-
-    def __is_topic_created(self, topic: str) -> bool:
-        is_topic_created = self.__topics_checked.get(topic, None)
-
-        if is_topic_created is not None:
-            return is_topic_created
-
-        is_topic_created = self.__get_kafka_admin_client().is_topic_created(topic)
-        self.__topics_checked[topic] = is_topic_created
-
-        return is_topic_created
-
-    async def bulk_publish(self, events: Collection[Event]) -> None:
-        for event in events:
-            await self.publish(event)
-
-    def __get_event_headers(self, event: Event) -> dict:
-        return {"id": event.id}
-
-    async def connect(self) -> None:
-        await self.__producer.connect()
-
-    async def disconnect(self) -> None:
-        await self.__producer.disconnect()