Refine search
@Deprecated public boolean includes(LogRecord r) { if(r.getLevel().intValue() < level) return false; // below the threshold if (name.length() == 0) { return true; // like root logger, includes everything } String logName = r.getLoggerName(); if(logName==null || !logName.startsWith(name)) return false; // not within this logger String rest = logName.substring(name.length()); return rest.startsWith(".") || rest.length()==0; }
public Boolean matches(LogRecord r) { boolean levelSufficient = r.getLevel().intValue() >= level; if (name.length() == 0) { return Boolean.valueOf(levelSufficient); // include if level matches } String logName = r.getLoggerName(); if(logName==null || !logName.startsWith(name)) return null; // not in the domain of this logger String rest = logName.substring(name.length()); if (rest.startsWith(".") || rest.length()==0) { return Boolean.valueOf(levelSufficient); // include if level matches } return null; }
/** * Determines whether the supplied log record needs to be logged. The * logging levels will be checked as well as the filter. * * @param record * the log record to be checked. * @return {@code true} if the supplied log record needs to be logged, * otherwise {@code false}. */ public boolean isLoggable(LogRecord record) { if (record == null) { throw new NullPointerException("record == null"); } if (this.level.intValue() == Level.OFF.intValue()) { return false; } else if (record.getLevel().intValue() >= this.level.intValue()) { return this.filter == null || this.filter.isLoggable(record); } return false; }
/** * {@inheritDoc} */ @Override public void publish(LogRecord record) { // ici on préfère ne pas appeler isLoggable(record) pour éviter un lock synchronized sur getLevel if (record.getLevel().intValue() < THRESHOLD.intValue()) { return; } addErrorLogToCounter(record.getLevel().getName() + ": " + record.getMessage(), record.getThrown()); }
private Logger getLogger( LogRecord record, Log log ) { int level = record.getLevel().intValue(); if ( level <= Level.FINE.intValue() ) { return log.debugLogger(); } else if ( level <= Level.INFO.intValue() ) { return log.infoLogger(); } else if ( level <= Level.WARNING.intValue() ) { return log.warnLogger(); } else { return log.errorLogger(); } }
/** * Convert a java.util.logging call to its equivalent Redwood logging call. * Currently, the WARNING log level becomes Redwood WARNING flag, the SEVERE log level becomes Redwood.ERR, and anything at FINE or lower becomes Redwood.DBG * CONFIG and INFO don't map to a Redwood tag. */ @Override public void publish(LogRecord record) { String message = record.getMessage(); Level level = record.getLevel(); Object tag = null; if (level == Level.WARNING) { tag = Redwood.WARN; } else if (level == Level.SEVERE) { tag = Redwood.ERR; } else if (level.intValue() <= Level.FINE.intValue()) { tag = Redwood.DBG; } if (tag == null) { Redwood.log(message); } else { Redwood.log(tag, message); } }
protected void callPlainSLF4JLogger(Logger slf4jLogger, LogRecord record) { String i18nMessage = getMessageI18N(record); int julLevelValue = record.getLevel().intValue(); if (julLevelValue <= TRACE_LEVEL_THRESHOLD) { slf4jLogger.trace(i18nMessage, record.getThrown()); } else if (julLevelValue <= DEBUG_LEVEL_THRESHOLD) { slf4jLogger.debug(i18nMessage, record.getThrown()); } else if (julLevelValue <= INFO_LEVEL_THRESHOLD) { slf4jLogger.info(i18nMessage, record.getThrown()); } else if (julLevelValue <= WARN_LEVEL_THRESHOLD) { slf4jLogger.warn(i18nMessage, record.getThrown()); } else { slf4jLogger.error(i18nMessage, record.getThrown()); } }
@Override public void publish(LogRecord record) { if (getFormatter() == null) { setFormatter(new SimpleFormatter()); } try { String message = getFormatter().format(record); if (record.getLevel().intValue() >= Level.WARNING.intValue()) { System.err.write(message.getBytes()); } else { if (record.getLevel().intValue() >= Level.INFO.intValue()) { System.out.write(message.getBytes()); } else { if (verbosity == Verbosity.VERBOSE) { System.out.write(message.getBytes()); } } } } catch (Exception exception) { reportError(null, exception, ErrorManager.FORMAT_FAILURE); } } @Override
/** * Put a given {@code LogRecord} into internal buffer. If given record is * not loggable, just return. Otherwise it is stored in the buffer. * Furthermore if the record's level is not less than the push level, the * push action is triggered to output all the buffered records to the target * handler, and the target handler will publish them. * * @param record * the log record */ @Override public synchronized void publish(LogRecord record) { if (!isLoggable(record)) { return; } if (cursor >= size) { cursor = 0; } buffer[cursor++] = record; if (record.getLevel().intValue() >= push.intValue()) { push(); } }
/** * @see java.util.logging.Handler#publish(java.util.logging.LogRecord) */ public void publish(LogRecord record) { try { if (isLoggable(record)) { final int level = record.getLevel().intValue(); if (level >=Level.WARNING.intValue() && level < Level.OFF.intValue()) { ++errorCount; } if (!hasErrors) { hasErrors = level >= Level.WARNING.intValue() && level < Level.OFF.intValue(); } try { String formattedRecord = getFormatter().format(record); textArea.append(formattedRecord); } catch (RuntimeException e) { reportError(e.toString(), e, ErrorManager.WRITE_FAILURE); } } } catch (Exception e) { reportError(e.toString(), e, ErrorManager.GENERIC_FAILURE); } }
private LogWrapper(Cache cache) { logger = Logger.getLogger(this.getClass().getCanonicalName()); if (cache != null && !cache.isClosed()) { logger.addHandler(cache.getLogger().getHandler()); CommandResponseWriterHandler handler = new CommandResponseWriterHandler(); handler.setFilter(record -> record.getLevel().intValue() >= Level.FINE.intValue()); handler.setLevel(Level.FINE); logger.addHandler(handler); } logger.setUseParentHandlers(false); }
protected void callLocationAwareLogger(LocationAwareLogger lal, LogRecord record) { int julLevelValue = record.getLevel().intValue(); int slf4jLevel; if (julLevelValue <= TRACE_LEVEL_THRESHOLD) { slf4jLevel = LocationAwareLogger.TRACE_INT; } else if (julLevelValue <= DEBUG_LEVEL_THRESHOLD) { slf4jLevel = LocationAwareLogger.DEBUG_INT; } else if (julLevelValue <= INFO_LEVEL_THRESHOLD) { slf4jLevel = LocationAwareLogger.INFO_INT; } else if (julLevelValue <= WARN_LEVEL_THRESHOLD) { slf4jLevel = LocationAwareLogger.WARN_INT; } else { slf4jLevel = LocationAwareLogger.ERROR_INT; } String i18nMessage = getMessageI18N(record); lal.log(null, FQCN, slf4jLevel, i18nMessage, null, record.getThrown()); }
@Override public void publish(final LogRecord record) { if (isLoggable(record)) { try { if (logWriter instanceof LogWriterLogger) { ((LogWriterLogger) logWriter).log(record.getLevel().intValue(), getMessage(record), record.getThrown()); } else { ((LogWriterImpl) logWriter).put(record.getLevel().intValue(), getMessage(record), record.getThrown()); } } catch (GemFireException ex) { reportError(null, ex, ErrorManager.WRITE_FAILURE); } } } }
private LogEntry logEntryFor(LogRecord record) throws Exception { String payload = getFormatter().format(record); Level level = record.getLevel(); LogEntry.Builder builder = LogEntry.newBuilder(Payload.StringPayload.of(payload)) .setTimestamp(record.getMillis()) .setSeverity(severityFor(level)); if (!baseLevel.equals(level)) { builder .addLabel("levelName", level.getName()) .addLabel("levelValue", String.valueOf(level.intValue())); } for (LoggingEnhancer enhancer : enhancers) { enhancer.enhanceLogEntry(builder); } return builder.build(); }