Java Level.INFO属性代码示例

private static Level convert(final LogLevel logLevel) {
    switch (logLevel) {
        case FATAL:
            return Level.FATAL;
        case ERROR:
            return Level.ERROR;
        case WARN:
            return Level.WARN;
        case INFO:
            return Level.INFO;
        case DEBUG:
            return Level.DEBUG;
        case TRACE:
            return Level.TRACE;
        case OFF:
            return Level.OFF;
        default:
            return Level.toLevel(logLevel.name());
    }
}
 

@Override
public int getLogWriterLevel() {
  final Level log4jLevel = this.logWrapper.getLevel();

  if (log4jLevel == Level.OFF) {
    return InternalLogWriter.NONE_LEVEL;
  } else if (log4jLevel == Level.FATAL) {
    return InternalLogWriter.SEVERE_LEVEL;
  } else if (log4jLevel == Level.ERROR) {
    return InternalLogWriter.ERROR_LEVEL;
  } else if (log4jLevel == Level.WARN) {
    return InternalLogWriter.WARNING_LEVEL;
  } else if (log4jLevel == Level.INFO) {
    return InternalLogWriter.INFO_LEVEL;
  } else if (log4jLevel == Level.DEBUG) {
    return InternalLogWriter.FINE_LEVEL;
  } else if (log4jLevel == Level.TRACE) {
    return InternalLogWriter.FINER_LEVEL;
  } else if (log4jLevel == Level.ALL) {
    return InternalLogWriter.ALL_LEVEL;
  }

  throw new IllegalStateException(
      "Level " + log4jLevel + " could not be mapped to LogWriter level.");
}
 

protected Level toLevel(InternalLogLevel level) {
    switch (level) {
        case INFO:
            return Level.INFO;
        case DEBUG:
            return Level.DEBUG;
        case WARN:
            return Level.WARN;
        case ERROR:
            return Level.ERROR;
        case TRACE:
            return Level.TRACE;
        default:
            throw new Error();
    }
}
 

public static int log4jLevelToLogWriterLevel(final Level log4jLevel) {
  if (log4jLevel == Level.FATAL) {
    return InternalLogWriter.SEVERE_LEVEL;
  } else if (log4jLevel == Level.ERROR) {
    return InternalLogWriter.ERROR_LEVEL;
  } else if (log4jLevel == Level.WARN) {
    return InternalLogWriter.WARNING_LEVEL;
  } else if (log4jLevel == Level.INFO) {
    return InternalLogWriter.INFO_LEVEL;
  } else if (log4jLevel == Level.DEBUG) {
    return InternalLogWriter.FINE_LEVEL;
  } else if (log4jLevel == Level.TRACE) {
    return InternalLogWriter.FINEST_LEVEL;
  } else if (log4jLevel == Level.ALL) {
    return InternalLogWriter.ALL_LEVEL;
  } else if (log4jLevel == Level.OFF) {
    return InternalLogWriter.NONE_LEVEL;
  }

  throw new IllegalArgumentException("Unknown Log4J level [" + log4jLevel + "].");
}
 

@Override
public void append(LogEvent event) {
    String message = event.getMessage().getFormattedMessage();
    if (event.getLevel() == Level.TRACE && event.getLoggerName().endsWith("lucene.iw")) {
    }
    if (event.getLevel() == Level.INFO
        && message.contains("updating [index.merge.scheduler.max_thread_count] from [10000] to [1]")) {
        sawUpdateMaxThreadCount = true;
    }
    if (event.getLevel() == Level.INFO
        && message.contains("updating [index.merge.scheduler.auto_throttle] from [true] to [false]")) {
        sawUpdateAutoThrottle = true;
    }
}
 

@Override
public void apply(Pointer voidPtr1, int levelID, Pointer formatPtr, Pointer args) {
    Level level;
    switch(levelID) { // SEE FFmpeg libavutil/log.h
        case AV_LOG_QUIET:
        case AV_LOG_TRACE:
            level = Level.TRACE; break;
        case AV_LOG_PANIC:
        case AV_LOG_FATAL:
            level = Level.FATAL; break;
        case AV_LOG_ERROR:
            level = Level.ERROR; break;
        case AV_LOG_WARNING:
            level = Level.WARN; break;
        case AV_LOG_INFO:
            level = Level.INFO; break;
        case AV_LOG_VERBOSE:
        case AV_LOG_DEBUG:
            level = Level.DEBUG; break;
        default:
            level = Level.DEBUG;
    }

    Memory line = new Memory(128L);
    Avutil55Library.INSTANCE.av_log_format_line(voidPtr1, levelID, formatPtr, args, line.share(0), 128, prefix);
    String message = String.format(line.getString(0), args).trim();
    logger.log(level, message);
}
 

/************************************************************
 * Methods to support backwards compatibility between levels.
 ************************************************************/

public static Level logWriterLeveltoLog4jLevel(final int logWriterLevel) {
  switch (logWriterLevel) {
    case InternalLogWriter.SEVERE_LEVEL:
      return Level.FATAL;
    case InternalLogWriter.ERROR_LEVEL:
      return Level.ERROR;
    case InternalLogWriter.WARNING_LEVEL:
      return Level.WARN;
    case InternalLogWriter.CONFIG_LEVEL:
      return Level.INFO;
    case InternalLogWriter.INFO_LEVEL:
      return Level.INFO;
    case InternalLogWriter.FINE_LEVEL:
      return Level.DEBUG;
    case InternalLogWriter.FINER_LEVEL:
      return Level.DEBUG;
    case InternalLogWriter.FINEST_LEVEL:
      return Level.TRACE;
    case InternalLogWriter.ALL_LEVEL:
      return Level.ALL;
    case InternalLogWriter.NONE_LEVEL:
      return Level.OFF;
  }

  throw new IllegalArgumentException("Unknown LogWriter level [" + logWriterLevel + "].");
}
 

public static Level logWriterNametoLog4jLevel(String levelName) {
  if ("all".equalsIgnoreCase(levelName)) {
    return Level.ALL;
  }
  if ("finest".equalsIgnoreCase(levelName)) {
    return Level.TRACE;
  }
  if ("finer".equalsIgnoreCase(levelName)) {
    return Level.DEBUG;
  }
  if ("fine".equalsIgnoreCase(levelName)) {
    return Level.DEBUG;
  }
  if ("config".equalsIgnoreCase(levelName)) {
    return Level.INFO;
  }
  if ("info".equalsIgnoreCase(levelName)) {
    return Level.INFO;
  }
  if ("warning".equalsIgnoreCase(levelName)) {
    return Level.WARN;
  }
  if ("error".equalsIgnoreCase(levelName)) {
    return Level.ERROR;
  }
  if ("severe".equalsIgnoreCase(levelName)) {
    return Level.FATAL;
  }
  if ("none".equalsIgnoreCase(levelName)) {
    return Level.OFF;
  }

  throw new IllegalArgumentException("Unknown LogWriter level [" + levelName + "].");
}
 

@Test
public void cacheLogWriterMessageShouldMatchCustomConfig() throws Exception {
  String logLogger = LogService.MAIN_LOGGER_NAME;
  Level logLevel = Level.INFO;
  String logMessage = "this is a log statement from " + testName.getMethodName();

  LogWriter logger = this.cache.getLogger();
  assertThat(LogService.isUsingGemFireDefaultConfig()).as(LogService.getConfigInformation())
      .isFalse();

  BasicAppender.clearEvents();

  logger.info(logMessage);

  BasicAppender appender = BasicAppender.getInstance();
  assertThat(appender).isNotNull();
  assertThat(appender.events().size()).isGreaterThan(0);

  LogEvent event = null;
  for (LogEvent logEvent : appender.events()) {
    if (logEvent.getMessage().getFormattedMessage().contains(logMessage)) {
      event = logEvent;
      break;
    }
  }

  assertThat(event).isNotNull();

  assertThat(event.getLoggerName()).isEqualTo(logLogger);
  assertThat(event.getLevel()).isEqualTo(logLevel);
  assertThat(event.getMessage().getFormattedMessage()).isEqualTo(logMessage);

  assertThat(systemOutRule.getLog()).contains(logLevel.name());
  assertThat(systemOutRule.getLog()).contains(logMessage);
  assertThat(systemOutRule.getLog()).contains(CONFIG_LAYOUT_PREFIX);
  assertThat(systemOutRule.getLog())
      .containsPattern(defineLogStatementRegex(logLevel, logMessage));
}
 

/**
 * Log config constructor with default log level of INFO
 * @author ThatsNoMoon
 */
public Log4JConfig() {
    JUKEBOT_LOG_LEVEL = Level.DEBUG;
    LIB_LOG_LEVEL = Level.INFO;
}