Task handling for sidecars logs.
769151
def logs_handle_job(job_uuid: str,
                    job_name: str,
                    log_lines: Optional[Union[str, Iterable[str]]],
                    temp: bool = True) -> None:
    """"""
    handle_job_logs(job_uuid=job_uuid,
                    job_name=job_name,
                    log_lines=log_lines,
                    temp=temp)
1105035
@Service
    public void log(String taskId, String log) {
        executionService.log(taskId, log);
    }
310985
private void dumpStatus(long now) {
    if (now - lastDumpStatusTime < dumpStatusPeriod) {
      return;
    }
    lastDumpStatusTime = now;
    logJobStats(infos.keySet(), TaskType.MAP);
    logJobStats(infos.keySet(), TaskType.REDUCE);
    dumpSpeculationStatus(now);
  }
661317
function (task) {
  return function (err) {
    notify.onError({
      message: task + ' failed, check the logs',
      sound: false
    })(err);
    gutil.log(gutil.colors.bgRed(task + ' error:'), gutil.colors.red(err));
  };
}
1023090
def do_handle_log(self, workunit, level, *msg_elements):
    """"""
    # If the element is a (msg, detail) pair, we ignore the detail. There's no
    # useful way to display it on the console.
    elements = [e if isinstance(e, string_types) else e[0] for e in msg_elements]
    msg = '\n' + ''.join(elements)
    if self.settings.color:
      msg = red(msg)
    self._emit(msg)
792935
def setup_task_logging_for_db
      Config.event_log = EventLog::Log.new(TaskDBWriter.new(:event_output, @task.id))
      Config.result = TaskDBWriter.new(:result_output, @task.id)
    end
1063734
public void log(AccessLog log) throws Exception {
        if (log == null) {
            return;
        }
        executorService.submit(new LogTask(log));
    }
411930
def run_track(track,
              result_hosts=None,
              crate_root=None,
              output_fmt=None,
              logfile_info=None,
              logfile_result=None,
              failfast=False,
              sample_mode='reservoir'):
    """"""
    with Logger(output_fmt=output_fmt,
                logfile_info=logfile_info,
                logfile_result=logfile_result) as log:
        executor = Executor(
            track_dir=os.path.dirname(track),
            log=log,
            result_hosts=result_hosts,
            crate_root=crate_root,
            fail_fast=failfast,
            sample_mode=sample_mode
        )
        error = executor.execute(toml.load(track))
        if error:
            sys.exit(1)
1332814
def log(self, level, *msg_elements):
    """"""
    self.report.log(self._threadlocal.current_workunit, level, *msg_elements)
210017
private synchronized void precomputeLogs(int len) {
    if(len <= ilogs.length) {
      return; // Probably done by another thread.
    }
    double[] logs = Arrays.copyOf(ilogs, len);
    for(int i = ilogs.length; i < len; i++) {
      logs[i] = FastMath.log1p(i);
    }
    this.ilogs = logs;
  }
2897
def do_running_tasks(self, arg):
        
        for task in asyncio.Task.all_tasks(loop=self.loop):
            _LOGGING.info(task)
308583
def logs_handle_build_job(job_uuid: str,
                          job_name: str,
                          log_lines: Optional[Union[str, Iterable[str]]],
                          temp: bool = True) -> None:
    """"""
    handle_build_job_logs(job_uuid=job_uuid,
                          job_name=job_name,
                          log_lines=log_lines,
                          temp=temp)
783446
def _make_log_task(self, level, msg, *args, **kwargs) -> Task:
        
        if not self.isEnabledFor(level):
            if self._dummy_task is None:
                self._dummy_task = self.__make_dummy_task()
            return self._dummy_task

        if kwargs.get("exc_info", False):
            if not isinstance(kwargs["exc_info"], BaseException):
                kwargs["exc_info"] = sys.exc_info()

        coro = self._log(  # type: ignore
            level, msg, *args, caller=self.findCaller(False), **kwargs
        )
        return self.loop.create_task(coro)
226577
function (latest_log) {
		if (latest_log !== null && latest_log.type !== "SYSTEM_DOWN") {
			LOG.warn("server crashed last time", 'handlers.system');
			LOG.event("SYSTEM_CRASHED", SR.Settings.SERVER_INFO);
		}

		LOG.event("SYSTEM_UP", SR.Settings.SERVER_INFO);
	}
541466
public function log(): void
    {
        if (file_exists(FLOW_PATH_DATA . 'Logs/Elasticsearch') && is_dir(FLOW_PATH_DATA . 'Logs/Elasticsearch') && is_writable(FLOW_PATH_DATA . 'Logs/Elasticsearch')) {
            file_put_contents($this->filename, $this->renderErrors());
            $this->logger->log($this->message, LOG_ERR, [], 'Flowpack.ElasticSearch.ContentRepositoryAdaptor', __CLASS__, __FUNCTION__);
        } else {
            $this->logger->log(sprintf('Could not write indexing errors backtrace into %s because the directory could not be created or is not writable.', FLOW_PATH_DATA . 'Logs/Elasticsearch/'), LOG_WARNING, [], 'Flowpack.ElasticSearch.ContentRepositoryAdaptor', __CLASS__, __FUNCTION__);
        }
    }
27989
private void log(ArrayList<PrintWriter> writers, RecordTypes recordType,
                   Keys[] keys, String[] values) {
    log(writers, recordType, keys, values, false);
  }
202927
def do_buggers(self, args):
        """"""
        args = args.split()
        if _debug: ConsoleCmd._debug("do_buggers %r", args)

        if not self.handlers:
            self.stdout.write("no handlers\n")
        else:
            self.stdout.write("handlers: ")
            self.stdout.write(', '.join(loggerName or '__root__' for loggerName in self.handlers))
            self.stdout.write("\n")

        loggers = logging.Logger.manager.loggerDict.keys()
        for loggerName in sorted(loggers):
            if args and (not args[0] in loggerName):
                continue

            if loggerName in self.handlers:
                self.stdout.write("* %s\n" % loggerName)
            else:
                self.stdout.write("  %s\n" % loggerName)
        self.stdout.write("\n")