CriticalLogMiddleware

async def after_consume(self, err: Optional[Exception]) -> None:
    """A function to handle the result of consuming a resource asynchronously.

    Args:
        err : Optional exception that occurred during consumption

    Raises:
        err : If an exception occurred during consumption
    """
    if err is not None:
        raise err

async def after_processed(
    self,
    exc_type: Optional[Type[BaseException]] = None,
    exc_val: Optional[BaseException] = None,
    exec_tb: Optional[TracebackType] = None,
) -> bool:
    """Asynchronously called after processing.

    Args:
        exc_type (Optional[Type[BaseException]]): Type of the exception raised during processing.
        exc_val (Optional[BaseException]): Value of the exception raised during processing.
        exec_tb (Optional[TracebackType]): Traceback of the exception raised during processing.

    Returns:
        bool: True if the method is successfully executed.
    """
    if self.logger is not None:
        c = context.get_local("log_context")

        if exc_type and exc_val:
            self.logger.error(
                f"{exc_type.__name__}: {exc_val}",
                exc_info=exc_val,
                extra=c,
            )

        self.logger.log(self.log_level, "Processed", extra=c)
    return True

async def after_publish(self, err: Optional[Exception]) -> None:
    """Asynchronous function to handle the after publish event.

    Args:
        err: Optional exception that occurred during the publish

    Returns:
        None

    Raises:
        Exception: If an error occurred during the publish
    """
    if err is not None:
        raise err

@asynccontextmanager
async def consume_scope(self, msg: DecodedMessage) -> AsyncIterator[DecodedMessage]:
    """Asynchronously consumes a message and returns an asynchronous iterator of decoded messages.

    Args:
        msg: The decoded message to consume.

    Yields:
        An asynchronous iterator of decoded messages.

    Returns:
        An asynchronous iterator of decoded messages.

    Raises:
        Exception: If an error occurs while consuming the message.

    AsyncIterator:
        An asynchronous iterator that yields decoded messages.

    Note:
        This function is an async function.
    """
    err: Optional[Exception]
    try:
        yield await self.on_consume(msg)
    except Exception as e:
        err = e
    else:
        err = None
    await self.after_consume(err)

async def on_consume(self, msg: DecodedMessage) -> DecodedMessage:
    if self.logger is not None:
        c = context.get_local("log_context")
        self.logger.log(self.log_level, "Received", extra=c)

    return await super().on_consume(msg)

async def on_publish(self, msg: SendableMessage) -> SendableMessage:
    """Asynchronously handle a publish event.

    Args:
        msg: The message to be published.

    Returns:
        The published message.
    """
    return msg

async def on_receive(self) -> None:
    pass

@asynccontextmanager
async def publish_scope(
    self, msg: SendableMessage
) -> AsyncIterator[SendableMessage]:
    """Publish a message and return an async iterator.

    Args:
        msg: The message to be published.

    Yields:
        A sendable message.

    Returns:
        An async iterator of sendable messages.

    Raises:
        Exception: If an error occurs during publishing.

    """
    err: Optional[Exception]
    try:
        yield await self.on_publish(msg)
    except Exception as e:
        err = e
    else:
        err = None
    await self.after_publish(err)