def _wrap_subscription(
    transport_layer, subscription_call, channel, callback, *args, **kwargs
):
    """Internal method to create an intercepting function for incoming messages
    to interpret recipes. This function is then used to subscribe to a channel
    on the transport layer.
      :param transport_layer: Reference to underlying transport object.
      :param subscription_call: Reference to the subscribing function of the
                                transport layer.
      :param channel:  Channel name to subscribe to.
      :param callback: Real function to be called when messages are received.
                       The callback will pass three arguments,
                       a RecipeWrapper object (details below), the header as
                       a dictionary structure, and the message.

      :param allow_non_recipe_messages: Pass on incoming messages that do not
                       include recipe information. In this case the first
                       argument to the callback function will be 'None'.
      :param log_extender: If the recipe contains useful contextual information
                       for log messages, such as a unique ID which can be used
                       to connect all messages originating from the same
                       recipe, then the information will be passed to this
                       function, which must be a context manager factory.
      :return:         Return value of call to subscription_call.
    """

    allow_non_recipe_messages = kwargs.pop("allow_non_recipe_messages", False)
    log_extender = kwargs.pop("log_extender", None)

    def unwrap_recipe(header, message):
        """This is a helper function unpacking incoming messages when they are
        in a recipe format. Other messages are passed through unmodified.
        :param header:  A dictionary of message headers. If the header contains
                        an entry 'workflows-recipe' then the message is parsed
                        and the embedded recipe information is passed on in a
                        RecipeWrapper object to the target function.
        :param message: Incoming deserialized message object.
        """
        if header.get("workflows-recipe") in (True, "True", "true", 1):
            rw = RecipeWrapper(message=message, transport=transport_layer)
            if log_extender and rw.environment and rw.environment.get("ID"):
                with log_extender("recipe_ID", rw.environment["ID"]):
                    return callback(rw, header, message.get("payload"))
            return callback(rw, header, message.get("payload"))
        if allow_non_recipe_messages:
            return callback(None, header, message)
        #   self.log.warning('Discarding non-recipe message:\n' + \
        #                    "First 1000 characters of header:\n%s\n" + \
        #                    "First 1000 characters of message:\n%s",
        #                    str(header)[:1000], str(message)[:1000])
        transport_layer.nack(header)

    return subscription_call(channel, unwrap_recipe, *args, **kwargs)