'Collect data from each check and submit their data.'

@log_exceptions(log)
def run(self, checksd=None, start_event=True, configs_reloaded=False):

    log.debug('Found    {num_checks}    checks'.format(num_checks=len(checksd['initialized_checks'])))
    timer = Timer()
    if (not Platform.is_windows()):
        cpu_clock = time.clock()
    self.run_count += 1
    log.debug(('Starting    collection    run    #%s' % self.run_count))
    if checksd:
        self.initialized_checks_d = checksd['initialized_checks']
        self.init_failed_checks_d = checksd['init_failed_checks']
    payload = AgentPayload()
    if ((not self._agent_metrics) or configs_reloaded):
        for check in self.initialized_checks_d:
            if (check.name == AGENT_METRICS_CHECK_NAME):
                self._agent_metrics = check
                self.initialized_checks_d.remove(check)
                break
    self._build_payload(payload)
    metrics = payload['metrics']
    events = payload['events']
    service_checks = payload['service_checks']
    if Platform.is_windows():
        for check_name in ['memory', 'cpu', 'io', 'proc', 'system']:
            try:
                metrics.extend(self._win32_system_checks[check_name].check(self.agentConfig))
            except Exception:
                log.exception('Unable    to    get    %s    metrics', check_name)
    else:
        sys_checks = self._unix_system_checks
        for check_name in ['load', 'system', 'cpu', 'file_handles']:
            try:
                result_check = sys_checks[check_name].check(self.agentConfig)
                if result_check:
                    payload.update(result_check)
            except Exception:
                log.exception('Unable    to    get    %s    metrics', check_name)
        try:
            memory = sys_checks['memory'].check(self.agentConfig)
        except Exception:
            log.exception('Unable    to    get    memory    metrics')
        else:
            if memory:
                memstats = {'memPhysUsed': memory.get('physUsed'), 'memPhysPctUsable': memory.get('physPctUsable'), 'memPhysFree': memory.get('physFree'), 'memPhysTotal': memory.get('physTotal'), 'memPhysUsable': memory.get('physUsable'), 'memSwapUsed': memory.get('swapUsed'), 'memSwapFree': memory.get('swapFree'), 'memSwapPctFree': memory.get('swapPctFree'), 'memSwapTotal': memory.get('swapTotal'), 'memCached': memory.get('physCached'), 'memBuffers': memory.get('physBuffers'), 'memShared': memory.get('physShared'), 'memSlab': memory.get('physSlab'), 'memPageTables': memory.get('physPageTables'), 'memSwapCached': memory.get('swapCached')}
                payload.update(memstats)
        try:
            ioStats = sys_checks['io'].check(self.agentConfig)
        except Exception:
            log.exception('Unable    to    get    io    metrics')
        else:
            if ioStats:
                payload['ioStats'] = ioStats
        try:
            processes = sys_checks['processes'].check(self.agentConfig)
        except Exception:
            log.exception('Unable    to    get    processes    metrics')
        else:
            payload.update({'processes': processes})
    if (self._ganglia is not None):
        payload['ganglia'] = self._ganglia.check(self.agentConfig)
    if (self._dogstream is not None):
        dogstreamData = self._dogstream.check(self.agentConfig)
        dogstreamEvents = dogstreamData.get('dogstreamEvents', None)
        if dogstreamEvents:
            if ('dogstream' in payload['events']):
                events['dogstream'].extend(dogstreamEvents)
            else:
                events['dogstream'] = dogstreamEvents
            del dogstreamData['dogstreamEvents']
        payload.update(dogstreamData)
    if ((not Platform.is_windows()) and self._should_send_additional_data('processes')):
        gohai_processes = self._run_gohai_processes()
        if gohai_processes:
            try:
                gohai_processes_json = json.loads(gohai_processes)
                processes_snaps = gohai_processes_json.get('processes')
                if processes_snaps:
                    processes_payload = {'snaps': [processes_snaps]}
                    payload['resources'] = {'processes': processes_payload, 'meta': {'host': self.hostname}}
            except Exception:
                log.exception('Error    running    gohai    processes    collection')
    for metrics_check in self._metrics_checks:
        res = metrics_check.check(self.agentConfig)
        if res:
            metrics.extend(res)
    log_at_first_run = (log.info if self._is_first_run() else log.debug)
    check_statuses = []
    for check in self.initialized_checks_d:
        if (not self.continue_running):
            return
        log_at_first_run('Running    check    %s', check.name)
        instance_statuses = []
        metric_count = 0
        event_count = 0
        service_check_count = 0
        check_start_time = time.time()
        check_stats = None
        try:
            instance_statuses = check.run()
            current_check_metrics = check.get_metrics()
            current_check_events = check.get_events()
            check_stats = check._get_internal_profiling_stats()
            current_check_metadata = check.get_service_metadata()
            metrics.extend(current_check_metrics)
            if current_check_events:
                if (check.name not in events):
                    events[check.name] = current_check_events
                else:
                    events[check.name] += current_check_events
            metric_count = len(current_check_metrics)
            event_count = len(current_check_events)
        except Exception:
            log.exception(('Error    running    check    %s' % check.name))
        check_status = CheckStatus(check.name, instance_statuses, metric_count, event_count, service_check_count, service_metadata=current_check_metadata, library_versions=check.get_library_info(), source_type_name=(check.SOURCE_TYPE_NAME or check.name), check_stats=check_stats, check_version=check.check_version)
        service_check_tags = [('check:%s' % check.name)]
        if (check_status.status == STATUS_OK):
            status = AgentCheck.OK
        elif (check_status.status == STATUS_ERROR):
            status = AgentCheck.CRITICAL
        check.service_check('datadog.agent.check_status', status, tags=service_check_tags)
        current_check_service_checks = check.get_service_checks()
        if current_check_service_checks:
            service_checks.extend(current_check_service_checks)
        service_check_count = (len(current_check_service_checks) - 1)
        check_status.service_check_count = service_check_count
        check_statuses.append(check_status)
        check_run_time = (time.time() - check_start_time)
        log.debug(('Check    %s    ran    in    %.2f    s' % (check.name, check_run_time)))
        if self.check_timings:
            metric = 'datadog.agent.check_run_time'
            meta = {'tags': [('check:%s' % check.name)]}
            metrics.append((metric, time.time(), check_run_time, meta))
    for (check_name, info) in self.init_failed_checks_d.iteritems():
        if (not self.continue_running):
            return
        check_status = CheckStatus(check_name, None, None, None, None, check_version=info.get('version'), init_failed_error=info['error'], init_failed_traceback=info['traceback'])
        check_statuses.append(check_status)
    service_checks.append(create_service_check('datadog.agent.up', AgentCheck.OK, hostname=self.hostname))
    payload['metrics'] = metrics
    payload['events'] = events
    payload['service_checks'] = service_checks
    self._populate_payload_metadata(payload, check_statuses, start_event)
    collect_duration = timer.step()
    if self._agent_metrics:
        metric_context = {'collection_time': collect_duration, 'emit_time': self.emit_duration}
        if (not Platform.is_windows()):
            metric_context['cpu_time'] = (time.clock() - cpu_clock)
        self._agent_metrics.set_metric_context(payload, metric_context)
        self._agent_metrics.run()
        agent_stats = self._agent_metrics.get_metrics()
        payload['metrics'].extend(agent_stats)
        if self.agentConfig.get('developer_mode'):
            log.debug('\n    Agent    developer    mode    stats:    \n    {0}'.format(Collector._stats_for_display(agent_stats)))
        self._agent_metrics.get_service_metadata()
    emitter_statuses = payload.emit(log, self.agentConfig, self.emitters, self.continue_running)
    self.emit_duration = timer.step()
    try:
        CollectorStatus(check_statuses, emitter_statuses, self.hostname_metadata_cache).persist()
    except Exception:
        log.exception('Error    persisting    collector    status')
    if ((self.run_count <= FLUSH_LOGGING_INITIAL) or ((self.run_count % FLUSH_LOGGING_PERIOD) == 0)):
        log.info(('Finished    run    #%s.    Collection    time:    %ss.    Emit    time:    %ss' % (self.run_count, round(collect_duration, 2), round(self.emit_duration, 2))))
        if (self.run_count == FLUSH_LOGGING_INITIAL):
            log.info(('First    flushes    done,    next    flushes    will    be    logged    every    %s    flushes.' % FLUSH_LOGGING_PERIOD))
    else:
        log.debug(('Finished    run    #%s.    Collection    time:    %ss.    Emit    time:    %ss' % (self.run_count, round(collect_duration, 2), round(self.emit_duration, 2))))
    return payload
