How to use the eliot.Message.log function in eliot

def wait_for_stack_status(stack_id, target_status):
    """
    Poll the status of a CloudFormation stack.

    :param unicode stack_id: The AWS cloudformation stack ID.
    :param unicode target_status: The desired stack status.
    :returns: A ``Deferred`` which fires when the stack has ``target_status``.
    """
    Message.log(
        function='wait_for_stack_status',
        stack_id=stack_id,
        target_status=target_status,
    )

    def predicate():
        stack_report = get_stack_report(stack_id)
        current_status = stack_report['StackStatus']
        if current_status == target_status:
            return stack_report

    return loop_until(reactor, predicate, repeat(10, 60))

def handlePLAINTEXTServer(self, header):
        """
        Parse a complete HTTP-like Foolscap negotiation request and begin proxying
        to a destination selected based on the extract TubID.
        """
        # the client sends us a GET message
        lines = header.split("\r\n")
        if not lines[0].startswith("GET "):
            raise BananaError("not right")
        command, url, version = lines[0].split()
        if not url.startswith("/id/"):
            # probably a web browser
            raise BananaError("not right")
        targetTubID = url[4:]

        Message.log(event_type=u"handlePLAINTEXTServer", tub_id=targetTubID)

        if targetTubID == "":
            # they're asking for an old UnauthenticatedTub. Refuse.
            raise NegotiationError("secure Tubs require encryption")
        if isSubstring("Upgrade: TLS/1.0\r\n", header):
            wantEncrypted = True
        else:
            wantEncrypted = False

        Message.log(event_type=u"handlePLAINTEXTServer", want_encrypted=wantEncrypted)

        self._handleTubRequest(header, targetTubID)

def start_containers(nodes):

            Message.log(
                message_type='flocker.benchmark.container_setup:start',
                containers_per_node=per_node,
                total_nodes=len(nodes)
            )
            total = per_node * len(nodes)

            def log_progress():
                Message.log(
                    message_type='flocker.benchmark.container_setup:progress',
                    container_count=self.container_count,
                    error_count=self.error_count,
                    total_containers=total
                )
            loop = LoopingCall(log_progress)
            loop.start(10, now=False)

def instance_error(failure):
            Message.log(
                message_type="flocker:provision:aws:async_get_node:failed"
            )
            instance.terminate()
            write_failure(failure)
            return failure

def _converge_replicasets(actual, config, subscriptions, k8s, aws):
    # We don't ever have to create a ReplicaSet.  We'll just delete the ones
    # we don't need anymore.
    deletes = []
    for replicaset in actual.replicasets:
        sid = replicaset.metadata.annotations[u"subscription"]
        if sid not in actual.subscriptions:
            Message.log(condition=u"undesired", subscription=sid)
            deletes.append(replicaset.metadata)

    def delete(metadata):
        return k8s.delete(k8s.k8s.model.v1beta1.ReplicaSet(metadata=metadata))

    return list(partial(delete, metadata) for metadata in deletes)

def check_state(node):
            if node is not None:
                if node.state in target_states:
                    Message.log(
                        message_type=(
                            u"flocker:provision:libcloud:node_in_state"
                        ),
                        name=node.name,
                        id=node.id,
                        state=node.state,
                    )
                    return True
            return False

}

    success = False

    headers_required = opts['headers_required']

    if not isinstance(headers_required, dict):
        raise ParserException('headers_required must be a list of headers')

    for header in headers_required:
        if header in response.headers:
            if headers_required[header] == '.':
                continue

            if str(headers_required[header]) != response.headers[header]:
                Message.log(
                    level='status',
                    message="Header '%s: %s' different from response header '%s: %s'" % (header, headers_required[header], header, response.headers[header]))
                success = True
        else:
            success = True
    return success, scope

def got_nodes(nodes):
            for node in nodes:
                if node.uuid == target_node.uuid:
                    Message.log(
                        message_type=(
                            u"flocker:provision:libcloud:refresh_node"
                        ),
                        name=node.name,
                        id=node.id,
                        state=node.state,
                        public_ips=node.public_ips,
                        private_ips=node.private_ips,
                    )
                    return node
            return None