Java 类org.slf4j.helpers.NOPLogger 实例源码

/**
 * {@inheritDoc}
 * <p>Attempts to find the <strong>real</strong> {@code Logger} instance that
 * is doing the heavy lifting and routes the request to an instance of
 * {@link CasDelegatingLogger}. The instance is cached by the logger name.</p>
 */
@Override
public Logger getLogger(final String name) {
    if (StringUtils.isBlank(name)) {
        return NOPLogger.NOP_LOGGER;
    }
    synchronized (loggerMap) {
        if (!loggerMap.containsKey(name)) {
            final Logger logger = getRealLoggerInstance(name);
            loggerMap.put(name, new CasDelegatingLogger(logger));
        }
        return loggerMap.get(name);
    }
}

/**
 * {@inheritDoc}
 * <p>Attempts to find the <strong>real</strong> <code>Logger</code> instance that
 * is doing the heavy lifting and routes the request to an instance of
 * {@link CasDelegatingLogger}. The instance is cached by the logger name.</p>
 */
@Override
public Logger getLogger(final String name) {
    if (StringUtils.isBlank(name)) {
        return NOPLogger.NOP_LOGGER;
    }
    synchronized (loggerMap) {
        if (!loggerMap.containsKey(name)) {
            final Logger logger = getRealLoggerInstance(name);
            loggerMap.put(name, new CasDelegatingLogger(logger));
        }
        return loggerMap.get(name);
    }
}

/**
 * {@inheritDoc}
 * <p>Attempts to find the <strong>real</strong> {@code Logger} instance that
 * is doing the heavy lifting and routes the request to an instance of
 * {@link CasDelegatingLogger}. The instance is cached by the logger name.</p>
 */
@Override
public Logger getLogger(final String name) {
    if (StringUtils.isBlank(name)) {
        return NOPLogger.NOP_LOGGER;
    }
    synchronized (loggerMap) {
        if (!loggerMap.containsKey(name)) {
            final Logger logger = getRealLoggerInstance(name);
            loggerMap.put(name, new CasDelegatingLogger(logger));
        }
        return loggerMap.get(name);
    }
}

/**
 * {@inheritDoc}
 * <p>Attempts to find the <strong>real</strong> <code>Logger</code> instance that
 * is doing the heavy lifting and routes the request to an instance of
 * {@link CasDelegatingLogger}. The instance is cached by the logger name.</p>
 */
@Override
public Logger getLogger(final String name) {
    if (StringUtils.isBlank(name)) {
        return NOPLogger.NOP_LOGGER;
    }
    synchronized (loggerMap) {
        if (!loggerMap.containsKey(name)) {
            final Logger logger = getRealLoggerInstance(name);
            loggerMap.put(name, new CasDelegatingLogger(logger));
        }
        return loggerMap.get(name);
    }
}

public LoggingSlf4jImpl(Class<?> clazz) {
    final PrintStream filterOut = new PrintStream(System.err) {
        public void println(String logger) {
            if (!logger.startsWith("SLF4J"))
                super.println(logger);
        }
    };
    System.setErr(filterOut);
    logger = LoggerFactory.getLogger(clazz);
    System.setErr(System.err);
    if (logger == null) {
        logger = NOPLogger.NOP_LOGGER;
    }
}

protected LogProcessResult processLog(LogSource source, Account account, String jvmId, boolean sync, GCAnalyse analyze) throws IOException {
    LogProcessResult x = checkAnalyzeCorrect(analyze.id(), jvmId, account.id(), analyze);
    if (x != null) return x;

    Logger log;
    File logFile = null;
    if (analyze.isContinuous()) {
        log = NOPLogger.NOP_LOGGER;
    } else {
        logFile = java.nio.file.Files.createTempFile("gcplot_log", ".log").toFile();
        log = createLogger(logFile);
    }

    Pair<ParseResult, ParsingState> p = parseAndPersist(source, jvmId, analyze, log);
    ParseResult pr = p.getLeft();
    ParsingState ps = p.getRight();

    if (pr.isSuccessful()) {
        updateAnalyzeInfo(analyze.id(), jvmId, account.id(), pr, ps);
        if (pr.getAgesStates().size() > 0) {
            persistObjectAges(analyze.id(), jvmId, pr);
        }
    } else {
        LOG.debug(pr.getException().get().getMessage(), pr.getException().get());
        log.error(pr.getException().get().getMessage(), pr.getException().get());
        return new LogProcessResult(ErrorMessages.buildJson(ErrorMessages.INTERNAL_ERROR));
    }

    if (logFile != null) {
        truncateFile(logFile, getConfig().readLong(ConfigProperty.PARSE_LOG_MAX_FILE_SIZE));
        uploadLogFile(sync, analyze.id(), jvmId, account.username(), logFile);
    }

    return LogProcessResult.SUCCESS;
}

@Override
public void log(Class<?> logSource, String msg, Object...args){
    Logger logger = this.logger;
    if(logger==null || NOPLogger.class.isInstance(logger)){
        logger = JFishLoggerFactory.getLogger(logSource);
    }
    logger.info(msg, args);
}

protected TimeLogger getTimeLogger(){
    TimeLogger logger = this.timeLogger;
    if(logger==null){
        Slf4jTimeLogger slf4j = new Slf4jTimeLogger();
        if(slf4j.getLogger() instanceof NOPLogger){
            logger = new TimerOutputer();
        }else{
            logger = slf4j;
        }
        this.timeLogger = logger;
    }
    return logger;
}

private Optional<Integer> getNumThreadsFromCommand(SingularityExecutorTaskProcessCallable taskProcess, Optional<Integer> dockerPid, String commandFormat) throws InterruptedException, ProcessFailedException {
  SimpleProcessManager checkThreadsProcessManager = new SimpleProcessManager(NOPLogger.NOP_LOGGER);
  List<String> cmd = ImmutableList.of("/bin/sh", "-c", String.format(commandFormat, dockerPid.or(taskProcess.getCurrentPid().get())));
  List<String> output = checkThreadsProcessManager.runCommandWithOutput(cmd);
  if (output.isEmpty()) {
    LOG.warn("Output from ls was empty ({})", cmd);
    return Optional.absent();
  } else {
    return Optional.of(Integer.parseInt(output.get(0)));
  }
}

public boolean isOk() {
    return logger.getClass() != NOPLogger.class;
}

public static Logger getLogger() {
    if ((instance == null) || (instance.logger == null))
        return NOPLogger.NOP_LOGGER;
    else
        return instance.logger;
}

public Logger getLogger(String name) {
    return NOPLogger.NOP_LOGGER;
}

public void testLogger() {
    Logger logger = LoggerFactory.getLogger(NoBindingTest.class);
    logger.debug("hello" + diff);
    assertTrue(logger instanceof NOPLogger);
}

@Before
public void beforeEach() {
    resolver = new DatabaseRealmResolver(DIRECTORY_PATH, null, null, System::currentTimeMillis, NOPLogger.NOP_LOGGER);
}

public Logger getLogger(String name) {
    return NOPLogger.NOP_LOGGER;
}

@Test
public void dontFailOnNoCloseMethod() {
    SafeCloseUtil.close(new Object(), NOPLogger.NOP_LOGGER);
}