Logs process error
4201
def _on_process_error(self, error):
        
        if self is None:
            return
        if error not in PROCESS_ERROR_STRING:
            error = -1
        if not self._prevent_logs:
            _logger().warning(PROCESS_ERROR_STRING[error])
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);
	}
668184
def error(self, message, *args, **kwargs):
        
        self._log(logging.ERROR, message, *args, **kwargs)
608154
def rmtree_log_error (func, path, exc):
    """"""
    msg = "Error in %s(%s): %s" % (func.__name__, path, str(exc[1]))
    util.log_error(msg)
204319
def python_logging_error_handler(level, root_says_abort, location, msg):
    
    from ..utils import quickroot as QROOT

    if not Initialized.value:
        try:
            QROOT.kTRUE
        except AttributeError:
            # Python is exiting. Do nothing.
            return
        QROOT.kInfo, QROOT.kWarning, QROOT.kError, QROOT.kFatal, QROOT.kSysError
        QROOT.gErrorIgnoreLevel
        Initialized.value = True

    try:
        QROOT.kTRUE
    except RuntimeError:
        # Note: If the above causes us problems, it's because this logging
        #       handler has been called multiple times already with an
        #       exception. In that case we need to force upstream to raise it.
        _, exc, traceback = sys.exc_info()
        caller = sys._getframe(2)
        re_execute_with_exception(caller, exc, traceback)

    if level < QROOT.gErrorIgnoreLevel:
        # Needed to silence some "normal" startup warnings
        # (copied from PyROOT Utility.cxx)
        return

    if sys.version_info[0] >= 3:
        location = location.decode('utf-8')
        msg = msg.decode('utf-8')

    log = ROOT_log.getChild(location.replace("::", "."))

    if level >= QROOT.kSysError or level >= QROOT.kFatal:
        lvl = logging.CRITICAL
    elif level >= QROOT.kError:
        lvl = logging.ERROR
    elif level >= QROOT.kWarning:
        lvl = logging.WARNING
    elif level >= QROOT.kInfo:
        lvl = logging.INFO
    else:
        lvl = logging.DEBUG

    if not SANE_REGEX.match(msg):
        # Not ASCII characters. Escape them.
        msg = repr(msg)[1:-1]

    # Apply fixups to improve consistency of errors/warnings
    lvl, msg = fixup_msg(lvl, msg)

    log.log(lvl, msg)

    # String checks are used because we need a way of (un)forcing abort without
    # modifying a global variable (gErrorAbortLevel) for the multithread tests
    abort = lvl >= ABORT_LEVEL or "rootpy.ALWAYSABORT" in msg or root_says_abort
    if abort and not "rootpy.NEVERABORT" in msg:
        caller = sys._getframe(1)

        try:
            # We can't raise an exception from here because ctypes/PyROOT swallows it.
            # Hence the need for dark magic, we re-raise it within a trace.
            from .. import ROOTError
            raise ROOTError(level, location, msg)
        except RuntimeError:
            _, exc, traceback = sys.exc_info()

        if SHOWTRACE.enabled:
            from traceback import print_stack
            print_stack(caller)

        if DANGER.enabled:
            # Avert your eyes, dark magic be within...
            re_execute_with_exception(caller, exc, traceback)

    if root_says_abort:
        log.critical("abort().. expect a stack trace")
        ctypes.CDLL(None).abort()
578860
def on_processing_error(self):
        
        duration = time.time() - self.last_failure
        if duration > self.MAX_ERROR_WINDOW:
            LOGGER.info('Resetting failure window, %i seconds since last',
                        duration)
            self.reset_error_counter()
        self.counters[self.ERROR] += 1
        self.last_failure = time.time()
        if self.too_many_errors:
            LOGGER.critical('Error threshold exceeded (%i), shutting down',
                            self.counters[self.ERROR])
            self.shutdown_connections()
1212797
function handleError(err) {

  // Print error message.
  console.log(chalk.red(err.message));

  // Print stack trace.
  console.log(chalk.red(kbox.getStackTrace(err)));

  // Log error to local log.
  return kbox.core.log.error(err)
  // Report error to stats server.
  .then(function() {
    return kbox.metrics.reportError(err);
  })
  // Exit the process with a failure.
  .finally(function() {
    process.exit(1);
  });

}
987156
function(errMsg, err) {
      this.newline();
      doLog('*******************************************************************');
      doLog('* ERROR                                                           *');
      doLog('*******************************************************************');

      if (generalUtils.isEmpty(err)) {
        doLog(errMsg);
      } else {
        doLogError(errMsg, err);
      }
      this.newline();
    }
433279
public static void error(Logger log, String methodName, Object... params) {
        log.error(buildMethodLogString(methodName, params));
    }
350909
def error(message = nil, ex = nil, data = nil, &block)
      log(ERROR, message, ex, data, block)
    end
892775
def error(msg, log_file=None):
        """"""
        UtilClass.print_msg(msg + os.linesep)
        if log_file is not None:
            UtilClass.writelog(log_file, msg, 'append')
        raise RuntimeError(msg)
542895
function processLogs() {
  var calcs = 0;
  for (var i in stats) {
    stats[i].average = stats[i].totalTime / stats[i].count;
    calcs += stats[i].calcs;
  }
  var time1 = meaningfulTime();
  var time2 = meaningfulTime();
  console.error("TRACER TOTAL OVERHEAD", (calcs*timeDiff(time2, time1)).toFixed(2)+'ms');

  while (Object.keys(stats).length > 0) {
    var biggest = 0;
    var biggestPath = Object.keys(stats)[0];
    for (var path in stats) {
      if (stats[path].average >= biggest) {
        biggestPath = path;
        biggest = stats[path].average;
      }
    }
    console.error("TRACER TOTAL",
                  stats[biggestPath].min.toFixed(2)+'ms',
                  stats[biggestPath].average.toFixed(2)+'ms',
                  stats[biggestPath].max.toFixed(2)+'ms',
                  stats[biggestPath].count,
                  biggestPath);
    delete stats[biggestPath];
  }
}
1037364
def log_rmtree_error(func, arg, exc_info):
    """"""
    logging.warning("Failure during '%s(%s)': %s", func.__name__, arg, exc_info[1])
539403
function log(err) {
    if (_logger) {
      if (typeof(err) == 'string') {
        err = { message: err, code: 0 }
      }
      _logger(err);
    }
  }
1083317
def error(self, msg, indent=0, **kwargs):
        """"""
        return self.logger.error(self._indent(msg, indent), **kwargs)
176360
def log_exception(fn_name, exception, retry_count, **kwargs):
    
    _log_exception_hook(fn_name, exception, retry_count, **kwargs)
864287
def error(self, message):
        
        if Settings.ErrorLogs:
            self._write_log("error", Settings.LogTime, message)