Java Level.DEBUG属性代码示例

public String format(LoggingEvent event){
    if( event.getLevel() == Level.FATAL){
        return fatalErrorColor+super.format(event)+END_COLOR;
    }else if( event.getLevel() == Level.ERROR){
        return errorColor+super.format(event)+END_COLOR;
    }if( event.getLevel() == Level.WARN){
        return super.format(event);
//        return warnColor+super.format(event)+END_COLOR;
    }if( event.getLevel() == Level.INFO){
        return super.format(event);
//        return infoColor+super.format(event)+END_COLOR;
    }if( event.getLevel() == Level.DEBUG){
        return super.format(event);
//        return debugColor+super.format(event)+END_COLOR;
    }else{
        throw new RuntimeException("Unsupported Level "+event.toString());
    }
    }
 

public static Level intToLevel(int intLevel) {
	switch(intLevel) {
	case TRACE_INFO: return Level.INFO;
	case TRACE_DEBUG: return Level.DEBUG;
	case TRACE_ERROR: return Level.ERROR;
	case TRACE_WARN: return Level.WARN;
	case TRACE_TRACE: return Level.TRACE;
	case TRACE_FATAL: return Level.FATAL;
	}
	return Level.OFF;
}
 

public Level getLevel(int traceLevel) {
     if ( traceLevel == TRACE_INFO ) {
        return Level.INFO;
    } else if ( traceLevel == TRACE_ERROR ) {
        return Level.ERROR;
    } else if ( traceLevel == TRACE_DEBUG) {
        return Level.DEBUG;
    } else if (traceLevel == TRACE_TRACE) {
        return Level.ALL;
    } else {
        return Level.OFF;
    }
}
 

private void setLogLevel(String level) {
    Level newLevel = Level.ERROR;
    level = level.substring(level.lastIndexOf(' ') + 1);
    switch (level) {
        case "Debug":
            newLevel = Level.DEBUG;
            break;
        case "Info":
            newLevel = Level.INFO;
            break;
        case "Warn":
            newLevel = Level.WARN;
            break;
        case "Error":
            newLevel = Level.ERROR;
            break;
    }
    Logger.getRootLogger().setLevel(newLevel);
    logger.setLevel(newLevel);
    ConsoleAppender ca = (ConsoleAppender)Logger.getRootLogger().getAppender("stdout");
    if (ca != null) {
        ca.setThreshold(newLevel);
    }
    FileAppender fa = (FileAppender)Logger.getRootLogger().getAppender("FILE");
    if (fa != null) {
        fa.setThreshold(newLevel);
    }
}
 

@Test
public void testSimple() throws Exception {
  Configuration conf = new Configuration();
  conf.set("hadoop.security.authentication", "simple");
  MiniRPCBenchmark mb = new MiniRPCBenchmark(Level.DEBUG);
  mb.runMiniBenchmark(conf, 10, null, null);
}
 

/**
 * Determines the log level represented by the configuration setting. If the
 * stored value does not match any of the supported log levels, the default
 * log level INFO will be used.
 * 
 * @param logLevel
 *            The log level information read from the configuration
 *            settings.
 * @return The log4j compliant log level to be used.
 */
private static Level determineLogLevel(String logLevel) {
    Level level = Level.INFO;
    if (DEBUG_LOG_LEVEL.equals(logLevel)) {
        level = Level.DEBUG;
    } else if (WARN_LOG_LEVEL.equals(logLevel)) {
        level = Level.WARN;
    } else if (ERROR_LOG_LEVEL.equals(logLevel)) {
        level = Level.ERROR;
    } else if (INFO_LOG_LEVEL.equals(logLevel)) {
        level = Level.INFO;
    }
    return level;
}
 

@Override
public synchronized void writeToLog(int messageLogLevel, String message) {
	Priority priority = Level.TRACE;
	if (messageLogLevel == Log.LOGLEVEL_FATAL_ERROR) priority = Level.FATAL;
	else if (messageLogLevel == Log.LOGLEVEL_EXCEPTION) priority = Level.ERROR;
	else if (messageLogLevel == Log.LOGLEVEL_WARNING) priority = Level.WARN;
	else if (messageLogLevel == Log.LOGLEVEL_MESSAGE) priority = Level.INFO;
	else if (messageLogLevel == Log.LOGLEVEL_DEBUG) priority = Level.DEBUG;
	else if (messageLogLevel == Log.LOGLEVEL_DEBUG2) priority = Level.TRACE;
	else if (messageLogLevel == Log.LOGLEVEL_DEBUG3) priority = Level.TRACE;
	logger.log(priority, message);
}
 

public static boolean enableDebugLoggingIfRequired(
    org.apache.hadoop.conf.Configuration conf) {

  boolean result = false;

  try {

    Level desiredOraOopLoggingLevel =
        Level.toLevel(conf.get(OraOopConstants.ORAOOP_LOGGING_LEVEL),
            Level.INFO);

    Level sqoopLogLevel =
        Logger.getLogger(Sqoop.class.getName()).getParent().getLevel();

    if (desiredOraOopLoggingLevel == Level.DEBUG
        || desiredOraOopLoggingLevel == Level.ALL
        || sqoopLogLevel == Level.DEBUG || sqoopLogLevel == Level.ALL) {

      Category oraOopLogger =
          Logger.getLogger(OraOopManagerFactory.class.getName()).getParent();
      oraOopLogger.setLevel(Level.DEBUG);
      LOG.debug("Enabled OraOop debug logging.");
      result = true;

      conf.set(OraOopConstants.ORAOOP_LOGGING_LEVEL, Level.DEBUG.toString());
    }
  } catch (Exception ex) {
    LOG.error(String.format(
        "Unable to determine whether debug logging should be enabled.\n%s",
        getFullExceptionMessage(ex)));
  }

  return result;
}
 

/**
 * Set logging level to given value. If not explicitly
 * specified, default level is used from *logger* properties file.
 * (As of the time writing - simplelogger.properties is used as default.)
 * <p/>
 * NOTE: SLF4J is not capable of changing log levels programatically!
 * We have to change the System/File property of given underlying logger.
 *
 * @param logLevel logging level to be logger set to
 */
public static void setLogLevel(String logLevel) {
    org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger("com.redhat.mqe.jms");
    Level level;
    switch (logLevel.toLowerCase()) {
        case "all":
            level = Level.ALL;
            break;
        case "trace":
            level = Level.TRACE;
            break;
        case "debug":
            level = Level.DEBUG;
            break;
        case "info":
            level = Level.INFO;
            break;
        case "warn":
            level = Level.WARN;
            break;
        case "error":
            level = Level.ERROR;
            break;
        case "fatal":
            level = Level.FATAL;
            break;
        case "off":
            level = Level.OFF;
            break;
        default:
            level = Level.INFO;
    }
    LogManager.getRootLogger().setLevel(level);
    logger.setLevel(level);
}