Log an error to the SLF4J Logger with <code>ERROR</code> priority.
966304
public void error(Object message, Throwable t)
    {
        getLogger().error(message.toString(), t);
    }
1294912
def error(self, event=None, *args, **kw):
        
        if not self._logger.isEnabledFor(logging.ERROR):
            return

        kw = self._add_base_info(kw)
        kw['level'] = "error"
        return self._proxy_to_logger('error', event, *args, **kw)
1211719
public void error(Object message) {
        doLog(Level.ERROR, FQCN, message, null, null);
    }
694033
def _log_and_raise_exception(msg, data, cls=FoursquareException):
  """"""
  data = u'{0}'.format(data)
  # We put data as a argument for log.error() so error tracking systems such
  # as Sentry will properly group errors together by msg only
  log.error(u'{0}: %s'.format(msg), data)
  raise cls(u'{0}: {1}'.format(msg, data))
1314016
def safe_log_error(self, error: Exception, *info: str):
        """"""
        self.__do_safe(lambda: self.logger.error(error, *info))
76999
public static void logError(String message, Throwable t) {
		logError(message + SEP + getMessage(t));
	}
486969
public void error(final String msg) {
        if (proxy.isErrorEnabled()) {
            if (proxy instanceof LocationAwareLogger) {
                ((LocationAwareLogger) proxy).log(null, FQCN, LocationAwareLogger.ERROR_INT, msg, null, null);
            } else {
                proxy.error(msg);
            }
        }
    }
260958
public void error(Object message, Throwable t)
    {
        if (IS12)
        {
            getLogger().log(FQCN, Level.ERROR, message, t);
        }
        else
        {
            getLogger().log(FQCN, Level.ERROR, message, t);
        }
    }
160849
@Override
    public void error( F0<String> msg )
    {
        if ( compilerLogger.isErrorEnabled() )
        {
            String msgString = msg.apply();
            errors.append( msgString ).append( '\n' );
            compilerLogger.error( msgString );
        }
    }
42534
public void error(Object message, Throwable t) {
        doLog(Level.ERROR, FQCN, message, null, t);
    }
1064614
@Override
    public void error(Throwable t) {
        log.log(Level.SEVERE, t.getMessage(), t);
    }
1238373
public static void printError(Object caller, Object message)
	{
		
		StringBuilder text = new StringBuilder();

		Class<?> c = callerBuilder(caller, text);

		if(message instanceof Throwable)
			getLog(c).error(text.append(stackTrace((Throwable)message)));
		else
			getLog(c).error(text.append(message));

	}
1304972
@Override
	public void registerErrorHandler(ErrorHandler handler) {
		if (handler != null) {
			this.errorHandlers.add(handler);
			Collections.sort(this.errorHandlers, DefaultErrorManager.PRIORITY_COMPARATOR);
		}
	}
449761
public static void error(Log log, String format, Object... arguments) {
		error(log, null, format, arguments);
	}
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);
	}
842412
public void logError(String moduleName, String beanName, String methodName)
    {
        Tr.error(tc, ivError.getMessageId(), new Object[] { beanName, moduleName, methodName, ivField });
    }
288277
public void error(Object o) {
        if (o instanceof Throwable) {
            logger.error(o, (Throwable) o);
        } else {
            logger.error(o);
        }
    }