Logs error

    :param error: error to log
    :param cause: (optional) cause of error
557966
def log_error(*error, cause=None):
    
    thread_id = threading.current_thread().ident
    text = " ".join(error)
    if cause:
        text += " due to " + str(cause)

    logger = get_logger()
    logger.error(LOG_THREAD_FORMAT.format(thread_id, text))
753050
def log(self, cause=None, do_message=True, custom_msg=None):
        
        message = error_message(self, cause=cause)
        exc_type, exc_value, exc_traceback = sys.exc_info()
        traceback_formatted = traceback.format_exc()
        traceback_val = traceback.extract_tb(exc_traceback)

        md5 = hashlib.md5(traceback_formatted.encode('utf-8')).hexdigest()

        if md5 in self._db:
            # self.logger.debug('Exception trace logged: %s' % md5)
            return

        if custom_msg is not None and cause is not None:
            self.logger.debug('%s : %s' % (custom_msg, cause))
        elif custom_msg is not None:
            self.logger.debug(custom_msg)
        elif cause is not None:
            self.logger.debug('%s' % cause)

        self.logger.debug(traceback_formatted)
        self._db.add(md5)
1064831
public final void errorDebug(final Throwable cause, final String message)
    {
        logDebug(Level.ERROR, cause, message);
    }
774510
protected void error(String message, Element source, Throwable cause) {
    logger.error(message);
  }
1146664
public void log(Throwable error, String description) {
    log(error, null, description, null);
  }
608154
def rmtree_log_error (func, path, exc):
    """"""
    msg = "Error in %s(%s): %s" % (func.__name__, path, str(exc[1]))
    util.log_error(msg)
42534
public void error(Object message, Throwable t) {
        doLog(Level.ERROR, FQCN, message, null, t);
    }
559012
def add(self, error):
        
        if not self._path_of_(error):
            self.errors.append(error)
            self.errors.sort()
        else:
            super(ErrorTree, self).add(error)
1034357
def error(self, text):
		
		self.logger.error("{}{}".format(self.message_prefix, text))
376724
def error(self, message, *args, **kwargs):
        
        kwargs.setdefault('extra', {}).setdefault('stack', True)
        return self.logger.error(message, *args, **kwargs)
966304
public void error(Object message, Throwable t)
    {
        getLogger().error(message.toString(), t);
    }
852040
function logQueryError (dbQueryId, options, err) {
    // require log client
    if (!this.logClient) {
        return
    }
    // do not log if query options flag is false
    if (options.log === false) {
        return
    }
    // log error
    this.logClient.log('dbResponse', {
        data: {
            code: err.code,
            isOperational: err.isOperational,
            message: err.message,
        },
        dbQueryId: dbQueryId.id,
        dbResponseSuccess: false,
        dbResponseCreateTime: microTimestamp(),
    })
}
1173030
def onUserError(self, fail, message):
        
        self.log.error(fail)
        self.log.error(message)
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)
876053
public void logError(final Level level, final String message, final Error e)
	{
		try {
			Logger errors = LoggingFactory
					.getLogger(LoggingFactory.NAME_ERROR_LOGGER);

			errors.logThrowable(level, message, e);

		}
		catch (LoggingException ex) {
			ex.printStackTrace();
		}

		if (logLevel.toInt() > level.toInt()) {
			return;
		}

		logThrowable(level, message, e);
	}
1288490
def error(self, error_msg):
        
        if self.logger is not None:
            self.logger.error(error_msg)

        if self.exc is not None:
            raise self.exc(error_msg)
735954
def error(msg)
      if @logger
        msg = build_log(msg, ActionCommand::LOG_KIND_ERROR)
        @logger.error(format_log(msg))
      end
    end