buz 2.12.0rc2__py3-none-any.whl → 2.13.1rc1__py3-none-any.whl

buz/event/__init__.py

@@ -1,11 +1,19 @@
 from buz.event.event import Event
 from buz.event.subscriber import Subscriber
+from buz.event.async_subscriber import AsyncSubscriber
 from buz.event.base_subscriber import BaseSubscriber
+from buz.event.base_async_subscriber import BaseAsyncSubscriber
 from buz.event.event_bus import EventBus
+from buz.event.meta_subscriber import MetaSubscriber
+from buz.event.meta_base_subscriber import MetaBaseSubscriber
 
 __all__ = [
     "Event",
     "Subscriber",
+    "AsyncSubscriber",
     "BaseSubscriber",
+    "BaseAsyncSubscriber",
     "EventBus",
+    "MetaSubscriber",
+    "MetaBaseSubscriber",
 ]

buz/event/async_subscriber.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+from buz.event import Event
+from buz.event.meta_subscriber import MetaSubscriber
+
+
+class AsyncSubscriber(MetaSubscriber, ABC):
+    @abstractmethod
+    async def consume(self, event: Event) -> None:
+        pass

buz/event/async_worker.py

@@ -1,4 +1,5 @@
 import asyncio
+from logging import Logger
 from signal import SIGTERM, SIGINT
 
 from buz.event.strategies.execution_strategy.async_execution_strategy import AsyncExecutionStrategy
@@ -7,18 +8,20 @@ from buz.event.strategies.execution_strategy.async_execution_strategy import Asy
 class AsyncWorker:
     def __init__(
         self,
+        logger: Logger,
         execution_strategy: AsyncExecutionStrategy,
     ) -> None:
         self.__execution_strategy = execution_strategy
+        self.__logger = logger
 
     async def start(self) -> None:
         loop = asyncio.get_running_loop()
         loop.add_signal_handler(SIGINT, self.stop)
         loop.add_signal_handler(SIGTERM, self.stop)
-        print("Starting buz worker...")
+        self.__logger.info("Starting buz worker...")
         await self.__execution_strategy.start()
-        print("Buz worker stopped gracefully")
+        self.__logger.info("Buz worker stopped gracefully")
 
     def stop(self) -> None:
-        print("Stopping buz worker...")
+        self.__logger.info("Stopping buz worker...")
         self.__execution_strategy.request_stop()

buz/event/base_async_subscriber.py

@@ -0,0 +1,8 @@
+from abc import ABC
+
+from buz.event.async_subscriber import AsyncSubscriber
+from buz.event.meta_base_subscriber import MetaBaseSubscriber
+
+
+class BaseAsyncSubscriber(AsyncSubscriber, MetaBaseSubscriber, ABC):
+    pass

buz/event/base_subscriber.py

@@ -1,22 +1,7 @@
-from typing import Type, get_type_hints
-
-from buz.event import Event
+from abc import ABC
 from buz.event import Subscriber
+from buz.event.meta_base_subscriber import MetaBaseSubscriber
 
 
-class BaseSubscriber(Subscriber):
-    @classmethod
-    def fqn(cls) -> str:
-        return f"subscriber.{cls.__module__}.{cls.__name__}"
-
-    @classmethod
-    def handles(cls) -> Type[Event]:
-        consume_types = get_type_hints(cls.consume)
-
-        if "event" not in consume_types:
-            raise TypeError("event parameter not found in consume method")
-
-        if not issubclass(consume_types["event"], Event):
-            raise TypeError("event parameter is not an buz.event.Event subclass")
-
-        return consume_types["event"]
+class BaseSubscriber(Subscriber, MetaBaseSubscriber, ABC):
+    pass

buz/event/dead_letter_queue/dlq_criteria.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+from typing import ClassVar, Union
+
+from buz.event.dead_letter_queue.dlq_record import DlqRecordId
+
+
+@dataclass(frozen=True)
+class DlqCriteria:
+    UNSET_VALUE: ClassVar[object] = object()
+
+    dlq_record_id: Union[DlqRecordId, None, object] = UNSET_VALUE

buz/event/dead_letter_queue/dlq_record.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass, fields
+from datetime import datetime
+from typing import Any, ClassVar
+from uuid import UUID
+
+DlqRecordId = UUID
+
+
+@dataclass
+class DlqRecord:
+    DATE_TIME_FORMAT: ClassVar[str] = "%Y-%m-%d %H:%M:%S.%f"
+
+    id: DlqRecordId
+    event_id: UUID
+    subscriber_fqn: str
+    event_payload: dict
+    exception_type: str
+    exception_message: str
+    last_failed_at: datetime
+
+    def mark_as_failed(self) -> None:
+        self.last_failed_at = datetime.now()
+
+    def get_attrs(self) -> dict[str, Any]:
+        attrs = {}
+        for field in fields(self):
+            property_name = field.name
+            property_value = getattr(self, property_name)
+            attrs[property_name] = property_value
+
+        return attrs

buz/event/dead_letter_queue/dlq_repository.py

@@ -0,0 +1,23 @@
+from abc import ABC, abstractmethod
+from typing import Sequence
+
+from buz.event.dead_letter_queue.dlq_criteria import DlqCriteria
+from buz.event.dead_letter_queue.dlq_record import DlqRecord, DlqRecordId
+
+
+class DlqRepository(ABC):
+    @abstractmethod
+    def save(self, dlq_record: DlqRecord) -> None:
+        pass
+
+    @abstractmethod
+    def find_one_or_fail_by_criteria(self, criteria: DlqCriteria) -> DlqRecord:
+        pass
+
+    @abstractmethod
+    def delete(self, dlq_record_id: DlqRecordId) -> None:
+        pass
+
+    @abstractmethod
+    def bulk_delete(self, dlq_record_ids: Sequence[DlqRecordId]) -> None:
+        pass

buz/event/exceptions/worker_execution_exception.py

@@ -0,0 +1,3 @@
+class WorkerExecutionException(Exception):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)

buz/event/infrastructure/buz_kafka/base_buz_aiokafka_async_consumer.py

@@ -0,0 +1,289 @@
+from abc import abstractmethod
+import traceback
+from asyncio import Lock, gather, Semaphore, Event as AsyncIOEvent, sleep
+from datetime import timedelta, datetime
+from itertools import cycle
+from logging import Logger
+from typing import AsyncIterator, Coroutine, Optional, Sequence, Type, TypeVar
+
+from aiokafka import TopicPartition
+from aiokafka.coordinator.assignors.abstract import AbstractPartitionAssignor
+from aiokafka.coordinator.assignors.roundrobin import RoundRobinPartitionAssignor
+
+from buz.event import Event
+from buz.event.async_consumer import AsyncConsumer
+from buz.event.exceptions.worker_execution_exception import WorkerExecutionException
+from buz.event.infrastructure.buz_kafka.consume_strategy.consume_strategy import KafkaConsumeStrategy
+from buz.event.infrastructure.buz_kafka.kafka_event_subscriber_executor import KafkaEventSubscriberExecutor
+from buz.event.infrastructure.models.consuming_task import ConsumingTask
+from buz.event.meta_subscriber import MetaSubscriber
+from buz.kafka import (
+    KafkaConnectionConfig,
+    ConsumerInitialOffsetPosition,
+)
+from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
+from buz.kafka.domain.models.kafka_poll_record import KafkaPollRecord
+from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
+from buz.kafka.infrastructure.aiokafka.aiokafka_consumer import AIOKafkaConsumer
+from buz.queue.in_memory.in_memory_multiqueue_repository import InMemoryMultiqueueRepository
+from buz.queue.multiqueue_repository import MultiqueueRepository
+
+
+T = TypeVar("T", bound=Event)
+
+
+class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
+    __FALLBACK_PARTITION_ASSIGNORS = (RoundRobinPartitionAssignor,)
+
+    def __init__(
+        self,
+        *,
+        connection_config: KafkaConnectionConfig,
+        kafka_admin_client: Optional[KafkaAdminClient],
+        consume_strategy: KafkaConsumeStrategy,
+        max_queue_size: int,
+        max_records_retrieved_per_poll: int,
+        kafka_partition_assignors: tuple[Type[AbstractPartitionAssignor], ...] = (),
+        subscribers: Sequence[MetaSubscriber],
+        logger: Logger,
+        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,
+    ):
+        self.__connection_config = connection_config
+        self.__consume_strategy = consume_strategy
+        self.__kafka_partition_assignors = kafka_partition_assignors
+        self.__subscribers = subscribers
+        self._logger = logger
+        self.__consumer_initial_offset_position = consumer_initial_offset_position
+        self.__max_records_retrieved_per_poll = 1
+        self.__subscriber_per_consumer_mapper: dict[AIOKafkaConsumer, MetaSubscriber] = {}
+        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.__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 = (
+            seconds_between_executions_if_there_are_no_tasks_in_the_queue
+        )
+        self.__seconds_between_polls_if_there_are_tasks_in_the_queue = (
+            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.__task_execution_mutex = Lock()
+
+    async def run(self) -> None:
+        start_time = datetime.now()
+        await self.__generate_kafka_consumers()
+
+        if len(self.__subscriber_per_consumer_mapper) == 0:
+            self._logger.error("There are no valid subscribers to execute, finalizing consumer")
+            return
+
+        self.__create_queue_repository_per_consumer()
+        self.__initial_coroutines_created_elapsed_time = datetime.now() - start_time
+
+        start_consumption_time = datetime.now()
+        self._logger.info("Starting to consume events")
+        worker_errors = await self.__run_worker()
+        self.__events_processed_elapsed_time = datetime.now() - start_consumption_time
+
+        await self.__handle_graceful_stop(worker_errors)
+
+    async def __handle_graceful_stop(self, worker_errors: tuple[Optional[Exception], Optional[Exception]]) -> None:
+        self._logger.info("Stopping kafka consumers...")
+        await self.__manage_kafka_consumers_stopping()
+        self._logger.info("All kafka consumers stopped")
+
+        self.__print_statistics()
+
+        if self.__exceptions_are_thrown(worker_errors):
+            consume_events_exception, polling_task_exception = worker_errors
+            if consume_events_exception:
+                self._logger.error(consume_events_exception)
+            if polling_task_exception:
+                self._logger.error(polling_task_exception)
+
+            raise WorkerExecutionException("The worker was closed by an unexpected exception")
+
+    async def __run_worker(self) -> tuple[Optional[Exception], Optional[Exception]]:
+        consume_events_task = self.__consume_events_task()
+        polling_task = self.__polling_task()
+
+        try:
+            await gather(consume_events_task, polling_task)
+            return (None, None)
+        except Exception:
+            self.__should_stop.set()
+            consume_events_exception = await self.__await_exception(consume_events_task)
+            polling_task_exception = await self.__await_exception(polling_task)
+            return (consume_events_exception, polling_task_exception)
+
+    async def __await_exception(self, future: Coroutine) -> Optional[Exception]:
+        try:
+            await future
+            return None
+        except Exception as exception:
+            return exception
+
+    def __exceptions_are_thrown(self, worker_errors: tuple[Optional[Exception], Optional[Exception]]) -> bool:
+        return any([error is not None for error in worker_errors])
+
+    async def __generate_kafka_consumers(self):
+        start_time = datetime.now()
+        tasks = [self.__initialize_kafka_consumer_for_subscriber(subscriber) for subscriber in self.__subscribers]
+        await gather(*tasks)
+        self.__start_kafka_consumers_elapsed_time = datetime.now() - start_time
+
+    async def __initialize_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.__subscriber_per_consumer_mapper[kafka_consumer] = subscriber
+
+            self.__executor_per_consumer_mapper[kafka_consumer] = executor
+
+            await kafka_consumer.init()
+        except Exception:
+            self._logger.exception(
+                f"Unexpected error during Kafka subscriber '{subscriber.fqn()}' initialization. Skipping it: {traceback.format_exc()}"
+            )
+
+    @abstractmethod
+    async def _create_kafka_consumer_executor(self, subscriber: MetaSubscriber) -> KafkaEventSubscriberExecutor:
+        pass
+
+    def __create_queue_repository_per_consumer(self) -> None:
+        for kafka_consumer in self.__subscriber_per_consumer_mapper.keys():
+            self.__queue_per_consumer_mapper[kafka_consumer] = InMemoryMultiqueueRepository()
+
+    async def __polling_task(self) -> None:
+        try:
+            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:
+                    await sleep(self.__seconds_between_polls_if_there_are_tasks_in_the_queue)
+                    continue
+
+                raw_consuming_tasks = await gather(
+                    *[
+                        self.__polling_consuming_tasks(kafka_consumer=consumer)
+                        for consumer, subscriber in self.__subscriber_per_consumer_mapper.items()
+                    ]
+                )
+
+                poll_results: list[ConsumingTask] = [
+                    consuming_task for consuming_tasks in raw_consuming_tasks for consuming_task in consuming_tasks
+                ]
+                if len(poll_results) == 0:
+                    await sleep(self.__seconds_between_polls_if_there_are_no_new_tasks)
+
+                for poll_result in poll_results:
+                    queue = self.__queue_per_consumer_mapper[poll_result.consumer]
+                    queue.push(
+                        key=TopicPartition(
+                            topic=poll_result.kafka_poll_record.topic, partition=poll_result.kafka_poll_record.partition
+                        ),
+                        record=poll_result.kafka_poll_record,
+                    )
+
+        except Exception:
+            self._logger.error(f"Polling task failed with exception: {traceback.format_exc()}")
+            self.__should_stop.set()
+
+        return
+
+    async def __polling_consuming_tasks(self, kafka_consumer: AIOKafkaConsumer) -> list[ConsumingTask]:
+        async with self.__polling_tasks_semaphore:
+            results = await kafka_consumer.poll(
+                number_of_messages_to_poll=self.__max_records_retrieved_per_poll,
+            )
+        return [ConsumingTask(kafka_consumer, result) for result in results]
+
+    async def __consume_events_task(self) -> None:
+        blocked_tasks_iterator = self.generate_blocked_consuming_tasks_iterator()
+
+        async for consuming_task in blocked_tasks_iterator:
+            consumer = consuming_task.consumer
+            kafka_poll_record = consuming_task.kafka_poll_record
+            executor = self.__executor_per_consumer_mapper[consuming_task.consumer]
+
+            await executor.consume(kafka_poll_record=kafka_poll_record)
+
+            await consumer.commit_poll_record(kafka_poll_record)
+
+            self.__events_processed += 1
+
+    # This iterator return a blocked task, that will be blocked for other process (like rebalancing), until the next task will be requested
+    async def generate_blocked_consuming_tasks_iterator(self) -> AsyncIterator[ConsumingTask]:
+        consumer_queues_cyclic_iterator = cycle(self.__queue_per_consumer_mapper.items())
+        last_consumer, _ = next(consumer_queues_cyclic_iterator)
+
+        while not self.__should_stop.is_set():
+            all_queues_are_empty = all(
+                [queue.is_totally_empty() for queue in self.__queue_per_consumer_mapper.values()]
+            )
+
+            if all_queues_are_empty:
+                await sleep(self.__seconds_between_executions_if_there_are_no_tasks_in_the_queue)
+                continue
+
+            async with self.__task_execution_mutex:
+                consumer: Optional[AIOKafkaConsumer] = None
+                kafka_poll_record: Optional[KafkaPollRecord] = None
+
+                while consumer != last_consumer:
+                    consumer, queue = next(consumer_queues_cyclic_iterator)
+                    kafka_poll_record = queue.pop()
+
+                    if kafka_poll_record is not None:
+                        yield ConsumingTask(consumer, kafka_poll_record)
+                        last_consumer = consumer
+                        break
+
+        return
+
+    async def __on_partition_revoked(self, consumer: AIOKafkaConsumer, topics_partitions: set[TopicPartition]) -> None:
+        async with self.__task_execution_mutex:
+            for topic_partition in topics_partitions:
+                self.__queue_per_consumer_mapper[consumer].clear(topic_partition)
+
+    def request_stop(self) -> None:
+        self.__should_stop.set()
+        self._logger.info("Worker stop requested. Waiting for finalize the current task")
+
+    async def __manage_kafka_consumers_stopping(self) -> None:
+        for kafka_consumer in self.__subscriber_per_consumer_mapper.keys():
+            await kafka_consumer.stop()
+
+    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}")

buz/event/infrastructure/buz_kafka/buz_aiokafka_async_consumer.py

@@ -0,0 +1,102 @@
+from logging import Logger
+from typing import Optional, Sequence, Type, TypeVar
+
+from aiokafka.coordinator.assignors.abstract import AbstractPartitionAssignor
+
+from buz.event import Event
+
+from buz.event.async_subscriber import AsyncSubscriber
+from buz.event.infrastructure.buz_kafka.base_buz_aiokafka_async_consumer import BaseBuzAIOKafkaAsyncConsumer
+from buz.event.infrastructure.buz_kafka.consume_strategy.consume_strategy import KafkaConsumeStrategy
+from buz.event.infrastructure.buz_kafka.consume_strategy.kafka_on_fail_strategy import KafkaOnFailStrategy
+from buz.event.infrastructure.buz_kafka.kafka_event_async_subscriber_executor import KafkaEventAsyncSubscriberExecutor
+from buz.event.infrastructure.buz_kafka.kafka_event_subscriber_executor import KafkaEventSubscriberExecutor
+from buz.event.meta_subscriber import MetaSubscriber
+from buz.event.middleware.async_consume_middleware import AsyncConsumeMiddleware
+from buz.event.strategies.retry.consume_retrier import ConsumeRetrier
+from buz.event.strategies.retry.reject_callback import RejectCallback
+from buz.kafka import (
+    KafkaConnectionConfig,
+    ConsumerInitialOffsetPosition,
+)
+from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
+from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
+from buz.kafka.infrastructure.deserializers.bytes_to_message_deserializer import BytesToMessageDeserializer
+from buz.kafka.infrastructure.deserializers.implementations.json_bytes_to_message_deserializer import (
+    JSONBytesToMessageDeserializer,
+)
+from buz.kafka.infrastructure.serializers.kafka_header_serializer import KafkaHeaderSerializer
+
+T = TypeVar("T", bound=Event)
+
+
+class BuzAIOKafkaAsyncConsumer(BaseBuzAIOKafkaAsyncConsumer):
+    def __init__(
+        self,
+        *,
+        connection_config: KafkaConnectionConfig,
+        kafka_admin_client: Optional[KafkaAdminClient],
+        consume_strategy: KafkaConsumeStrategy,
+        on_fail_strategy: KafkaOnFailStrategy,
+        max_queue_size: int,
+        max_records_retrieved_per_poll: int,
+        kafka_partition_assignors: tuple[Type[AbstractPartitionAssignor], ...] = (),
+        subscribers: Sequence[AsyncSubscriber],
+        logger: Logger,
+        consumer_initial_offset_position: ConsumerInitialOffsetPosition,
+        deserializers_per_subscriber: dict[MetaSubscriber, BytesToMessageDeserializer[T]],
+        consume_middlewares: Optional[Sequence[AsyncConsumeMiddleware]] = None,
+        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,
+    ):
+        super().__init__(
+            connection_config=connection_config,
+            kafka_admin_client=kafka_admin_client,
+            consume_strategy=consume_strategy,
+            max_queue_size=max_queue_size,
+            max_records_retrieved_per_poll=max_records_retrieved_per_poll,
+            kafka_partition_assignors=kafka_partition_assignors,
+            subscribers=subscribers,
+            logger=logger,
+            consumer_initial_offset_position=consumer_initial_offset_position,
+            auto_create_topic_configuration=auto_create_topic_configuration,
+            seconds_between_executions_if_there_are_no_tasks_in_the_queue=seconds_between_executions_if_there_are_no_tasks_in_the_queue,
+            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,
+        )
+        self.__on_fail_strategy = on_fail_strategy
+        self.__consume_middlewares = consume_middlewares
+        self.__consume_retrier = consume_retrier
+        self.__reject_callback = reject_callback
+        self._deserializers_per_subscriber = deserializers_per_subscriber
+
+    async def _create_kafka_consumer_executor(
+        self,
+        subscriber: MetaSubscriber,
+    ) -> KafkaEventSubscriberExecutor:
+        if not isinstance(subscriber, AsyncSubscriber):
+            raise TypeError(
+                f"Subscriber {subscriber.__class__.__name__} is not a subclass of Subscriber, probably you are trying to use a synchronous subscriber"
+            )
+
+        byte_deserializer = self._deserializers_per_subscriber.get(subscriber) or JSONBytesToMessageDeserializer(
+            # todo: it looks like in next python versions the inference engine is powerful enough to ensure this type, so we can remove it when we upgrade the python version of the library
+            event_class=subscriber.handles()  # type: ignore
+        )
+
+        return KafkaEventAsyncSubscriberExecutor(
+            logger=self._logger,
+            byte_deserializer=byte_deserializer,
+            header_deserializer=KafkaHeaderSerializer(),
+            on_fail_strategy=self.__on_fail_strategy,
+            subscriber=subscriber,
+            consume_middlewares=self.__consume_middlewares,
+            consume_retrier=self.__consume_retrier,
+            reject_callback=self.__reject_callback,
+        )