Sends multiple events to Riemann in a single message

        :param events: A list or iterable of ``Event`` objects
        :returns: The response message from Riemann
343712
def send_events(self, events):
        
        message = riemann_client.riemann_pb2.Msg()
        for event in events:
            message.events.add().MergeFrom(event)
        return self.transport.send(message)
445938
def send(self, event, message):
        
        self.connection.send({
            'reason': ['request', 'send'],
            'content': {
                'reason': event,
                'request_id': self.request_counter,
                'content': message,
            },
        })
        self.request_counter = self.request_counter + 1
1350840
def getEvents(self):
        

        url = "https://redunda.sobotics.org/events.json"
        data = parse.urlencode({"key": self.key}).encode()

        req = request.Request(url, data)
        
        response = request.urlopen(req)

        return json.loads(response.read().decode("utf-8"))
292066
def process_events(args):
    """"""
    client = EventsClient.from_config()
    client.set_debug(True)
    if args.get:
        response = client.get_events()
    elif args.flush:
        response = client.flush_events()
    return response
909086
def query(self, query):
        
        if isinstance(self.transport, riemann_client.transport.UDPTransport):
            raise Exception('Cannot query the Riemann server over UDP')
        response = self.send_query(query)
        return [self.create_dict(e) for e in response.events]
876809
function sendEvent(eventName, sendRecursiveArguments, isUnhandledPass) {
  sendRecursiveArguments.unshift(eventName, this.get('currentState'), isUnhandledPass);
  return sendRecursively.apply(this, sendRecursiveArguments);
}
360436
def events(self, all_instances=None, instance_ids=None, filters=None):
        """"""
        params = {}
        if filters:
            params["filters"] = make_filters(filters)
        if instance_ids:
            params['InstanceIds'] = instance_ids
        statuses = self.status(all_instances, **params)
        event_list = []
        for status in statuses:
            if status.get("Events"):
                for event in status.get("Events"):
                    event[u"InstanceId"] = status.get('InstanceId')
                    event_list.append(event)
        return event_list
1329950
def appliesToEvent(self, event):
        '''  '''
        return (
            event in self.individualEvents.all() or
            event.session in self.eventSessions.all() or
            event.category in self.seriesCategories.all() or
            event.category in self.eventCategories.all()
        )
721322
def _FormatMessage(self, event):
    
    message, _ = self._output_mediator.GetFormattedMessages(event)
    if message is None:
      data_type = getattr(event, 'data_type', 'UNKNOWN')
      raise errors.NoFormatterFound(
          'Unable to find event formatter for: {0:s}.'.format(data_type))

    return message
1330286
def events(self, from_dt=None, to_dt=None):
        
        self.refresh_client(from_dt, to_dt)
        return self.response['Event']
66817
def send_messages(events)
      $logger.debug { "ApiClient#send_messages(#{events.inspect})" }
      messages_api = TriglavClient::MessagesApi.new(@api_client)
      handle_error { messages_api.send_messages(events) }
    end
366045
def bind_events(self, events):
        '''
        '''
        evs = self._events
        if evs and events:
            for event in evs.values():
                if event.name in events:
                    event.bind(events[event.name])
402385
def wrap_iter_with_message_events(
    request_or_response_iter,
    span,
    message_event_type
):
    
    for message_id, message in enumerate(request_or_response_iter, start=1):
        add_message_event(
            proto_message=message,
            span=span,
            message_event_type=message_event_type,
            message_id=message_id
        )
        yield message
978206
def apply_events(events)
      events.each do |event|
        method_name = event_handler(event)
        public_send(method_name, event.data) if respond_to?(method_name)
      end
      @revision = events.last&.revision.to_i if events.last.respond_to?(:revision)
    end
1206093
def send(self, message):
        
        message = message.SerializeToString()
        self.socket.sendall(struct.pack('!I', len(message)) + message)

        length = struct.unpack('!I', self.socket.recv(4))[0]
        response = riemann_client.riemann_pb2.Msg()
        response.ParseFromString(socket_recvall(self.socket, length))

        if not response.ok:
            raise RiemannError(response.error)

        return response
1341597
def events(self):
        ''''''
        ret = []
        while True:
            e = self.poll()
            if e is None:
                break
            ret.append(e)
        return ret
1357197
def events(self):
        
        if self._events is None:
            self._events = EventList(self)
        return self._events