Java Code Examples for org.apache.commons.logging.Log#error()

private void doTestInitLogging(String location, boolean refreshInterval) throws FileNotFoundException {
	if (refreshInterval) {
		Log4jConfigurer.initLogging(location, 10);
	}
	else {
		Log4jConfigurer.initLogging(location);
	}

	Log log = LogFactory.getLog(this.getClass());
	log.debug("debug");
	log.info("info");
	log.warn("warn");
	log.error("error");
	log.fatal("fatal");

	assertTrue(MockLog4jAppender.loggingStrings.contains("debug"));
	assertTrue(MockLog4jAppender.loggingStrings.contains("info"));
	assertTrue(MockLog4jAppender.loggingStrings.contains("warn"));
	assertTrue(MockLog4jAppender.loggingStrings.contains("error"));
	assertTrue(MockLog4jAppender.loggingStrings.contains("fatal"));

	Log4jConfigurer.shutdownLogging();
	assertTrue(MockLog4jAppender.closeCalled);
}
 

public static void logError(Log log, Throwable t, String msg){
	
	NoLog noLog = t.getClass().getAnnotation(NoLog.class);
	if(noLog != null){
		return;
	}
	
	if(t instanceof BaseExpectedException) {
		log.error(msg+": "+t);
		return;
	}
	
	IOException socketEx = SocketUtil.findSocketException(t);
	if(socketEx != null){
		log.error(msg+": "+new ExpectedSocketException(socketEx, t));
		return;
	}
	
	//not ExpectedException
	log.error(msg, t);
}
 

public boolean readFile(Reader reader, String readFrom, String path, String baseUrl, Log log)
{
    // At the moment it is assumed the file is Json, but that does not need to be the case.
    // We have the path including extension.
    boolean successReadingConfig = true;
    try
    {
        JsonNode jsonNode = jsonObjectMapper.readValue(reader, JsonNode.class);
        String readFromMessage = readFrom + ' ' + path;
        if (log.isTraceEnabled())
        {
            log.trace(readFromMessage + " config is: " + jsonNode);
        }
        else
        {
            log.debug(readFromMessage + " config read");
        }
        readJson(jsonNode, readFromMessage, baseUrl);
    }
    catch (Exception e)
    {
        log.error("Error reading "+path, e);
        successReadingConfig = false;
    }
    return successReadingConfig;
}
 

/**
 * Logs the error, builds a BadRequestException with specified details and throws it
 *
 * @param errorHandlers A List of error handler objects containing the error information
 * @param log Log instance
 * @throws BadRequestException
 */
public static void handleBadRequest(List<ErrorHandler> errorHandlers, Log log) throws BadRequestException {
    BadRequestException badRequestException = buildBadRequestException(errorHandlers);
    StringBuilder builder = new StringBuilder();

    for (int i = 0; i < errorHandlers.size(); i++) {
        ErrorHandler handler = errorHandlers.get(i);
        builder.append(handler.getErrorMessage());
        if (StringUtils.isNotBlank(handler.getErrorDescription())) {
            builder.append(":");
            builder.append(handler.getErrorDescription());
        }

        if (i < errorHandlers.size() - 1) {
            builder.append(", ");
        }
    }
    log.error(builder.toString());
    throw badRequestException;
}
 

/**
 * Logs the error, builds a ConflictException with specified details and throws it
 *
 * @param description description of the error
 * @param log Log instance
 * @throws ConflictException
 */
public static void handleResourceAlreadyExistsError(String description, Log log)
        throws ConflictException {
    ConflictException conflictException = buildConflictException(
            RestApiConstants.STATUS_CONFLICT_MESSAGE_RESOURCE_ALREADY_EXISTS, description);
    log.error(description);
    throw conflictException;
}
 

/**
 * error.
 *
 * @param vfsLog The base component Logger to use.
 * @param commonsLog The class specific Logger
 * @param message The message to log.
 */
public static void error(final Log vfsLog, final Log commonsLog, final String message) {
    if (vfsLog != null) {
        vfsLog.error(message);
    } else if (commonsLog != null) {
        commonsLog.error(message);
    }
}
 

/**
 * Determine the fallback function to use based on the dlq partition count if no
 * {@link DlqPartitionFunction} bean is provided.
 * @param dlqPartitions the partition count.
 * @param logger the logger.
 * @return the fallback.
 */
static DlqPartitionFunction determineFallbackFunction(@Nullable Integer dlqPartitions, Log logger) {
	if (dlqPartitions == null) {
		return ORIGINAL_PARTITION;
	}
	else if (dlqPartitions > 1) {
		logger.error("'dlqPartitions' is > 1 but a custom DlqPartitionFunction bean is not provided");
		return ORIGINAL_PARTITION;
	}
	else {
		return PARTITION_ZERO;
	}
}
 

@Test
public void testClassLogger() throws Exception {
    final ListAppender app = ctx.getListAppender("Class").clear();
    final Log logger = LogFactory.getLog("ClassLogger");
    logger.info("Ignored message contents.");
    logger.warn("Verifying the caller class is still correct.");
    logger.error("Hopefully nobody breaks me!");
    final List<String> messages = app.getMessages();
    assertEquals("Incorrect number of messages.", 3, messages.size());
    for (final String message : messages) {
        assertEquals("Incorrect caller class name.", this.getClass().getName(), message);
    }
}
 

/**
 * Print critical error message with red
 * @param log
 * @param message
 */
public static void printColoredError(Log log, String message) {
    if (ActsConfiguration.getInstance().isColoredLog()) {
        String tmp = replaceCrLf(message);
        log.error(colorMultiLine(AnsiColorConstants.ANSI_RED_BEGIN, tmp));
    } else {
        log.error(message);
    }
}
 

/**
 * Tests whether an exception can be logged on error level.
 */
@Test
public void testErrorWithException()
{
    final Log log = EasyMock.createMock(Log.class);
    final Throwable ex = new Exception("Test exception");
    log.error(MSG, ex);
    EasyMock.replay(log);
    final ConfigurationLogger logger = new ConfigurationLogger(log);

    logger.error(MSG, ex);
    EasyMock.verify(log);
}
 

public static void Log_VariableArgumentLengthXY(Log logger){
	logger.error(messages[MSG_ARGUMENT_LENGTH_XY]);
}
 

public final static void error(final Log log, final String message)
{
    log.error(PREFIX + message);
}
 

private static void logError(String message) {
	Log logger = LogFactory.getLog(FileUtil.class);
	logger.error(message);
}
 

public static void Log_InvalidType(Log logger, OGCType expecting, OGCType actual){
	logger.error(String.format(messages[MSG_INVALID_TYPE], expecting, actual));
}
 

public static void Log_InvalidText(Log logger, String text) {
	int limit = text.length();
	limit = limit > 80 ? 80 : limit;
	logger.error(String.format(messages[MSG_INVALID_TEXT], text.substring(0, limit)));
}
 

/**
 * Logs the error, builds a internalServerErrorException with specified details and throws it
 *
 * @param msg error message
 * @param t Throwable instance
 * @param log Log instance
 * @throws InternalServerErrorException
 */
public static void handleInternalServerError(String msg, Throwable t, Log log)
        throws InternalServerErrorException {
    InternalServerErrorException internalServerErrorException = buildInternalServerErrorException(msg);
    log.error(msg, t);
    throw internalServerErrorException;
}
 

/**
 * Logs the error, builds a internalServerErrorException with specified details and throws it
 *
 * @param msg error message
 * @param log Log instance
 * @throws InternalServerErrorException
 */
public static void handleInternalServerError(String msg, Log log)
        throws InternalServerErrorException {
    InternalServerErrorException internalServerErrorException = buildInternalServerErrorException();
    log.error(msg);
    throw internalServerErrorException;
}
 

/**
 * error.
 *
 * @param vfsLog The base component Logger to use.
 * @param commonsLog The class specific Logger
 * @param message The message to log.
 * @param t The exception, if any.
 */
public static void error(final Log vfsLog, final Log commonsLog, final String message, final Throwable t) {
    if (vfsLog != null) {
        vfsLog.error(message, t);
    } else if (commonsLog != null) {
        commonsLog.error(message, t);
    }
}
 

/**
 * print error without exceptino message
 *
 * @param logger
 * @param message
 */
public static void error(Log logger, String message) {
    logger.error(message);
    addProcessLog(message);
}
 

/**
 * Log an I18Nized message to ERROR.
 * 
 * @param logger        the logger to use
 * @param messageKey    the message key
 * @param args          the required message arguments
 */
public static final void error(Log logger, String messageKey, Object ... args)
{
    logger.error(I18NUtil.getMessage(messageKey, args));
}