Refine search
private void log(Level level, Object message, Throwable t, Object... params) { if (!logger.isLoggable(level)) { return; } String msg = (message == null) ? "NULL" : message.toString(); LogRecord record = new LogRecord(level, msg); record.setLoggerName(logger.getName()); if (t != null) { record.setThrown(t); } else if (params != null && params.length != 0 && params[params.length - 1] instanceof Throwable) { // The exception may be the last parameters (SLF4J uses this convention). record.setThrown((Throwable) params[params.length - 1]); } // This will disable stack trace lookup inside JUL. If someone wants location info, they can use their own formatter // or use a different logging framework like sl4j, or log4j record.setSourceClassName(null); record.setParameters(params); logger.log(record); }
/** * Closes the item and logs error to the log in the case of error. * Logging will be performed on the {@code WARNING} level. * @param toClose Item to close. Nothing will happen if it is {@code null} * @param logger Logger, which receives the error * @param closeableName Name of the closeable item * @param closeableOwner String representation of the closeable holder * @since 2.19, but TODO update once un-restricted */ @Restricted(NoExternalUse.class) public static void closeAndLogFailures(@CheckForNull Closeable toClose, @Nonnull Logger logger, @Nonnull String closeableName, @Nonnull String closeableOwner) { if (toClose == null) { return; } try { toClose.close(); } catch(IOException ex) { LogRecord record = new LogRecord(Level.WARNING, "Failed to close {0} of {1}"); record.setParameters(new Object[] { closeableName, closeableOwner }); record.setThrown(ex); logger.log(record); } }
@SuppressWarnings("deprecation") // setMillis is deprecated in JDK 9 protected Object writeReplace() { LogRecord serialized = new LogRecord(getLevel(), getMessage()); serialized.setLoggerName(getLoggerName()); serialized.setResourceBundle(getResourceBundle()); serialized.setResourceBundleName(getResourceBundleName()); serialized.setSourceClassName(getSourceClassName()); serialized.setSourceMethodName(getSourceMethodName()); serialized.setSequenceNumber(getSequenceNumber()); serialized.setParameters(getParameters()); serialized.setThreadID(getThreadID()); serialized.setMillis(getMillis()); serialized.setThrown(getThrown()); return serialized; } }
protected void log(Throwable t, Level level, String msg, Object[] objs) { LogRecord lr = createLogRecord(level, msg); if(t != null) { lr.setThrown(t); } if(objs != null) { //serializeCheck(objs); lr.setParameters(objs); } getLogger().log(lr); } protected void logp(Object clazz, String methodName, Throwable t, Level level, String msg, Object[] objs) {
/** * Gets a localized log record. * * @param level The log record level. * @param key The resource key. * @param arg0 The parameter for the log message, or {@code null}. * @return The log record. */ public LogRecord getLogRecord(final Level level, final int key, final Object arg0) { final LogRecord record = new LogRecord(level, String.valueOf(key)); record.setResourceBundle(this); if (arg0 != null) { record.setParameters(toArray(arg0)); } return record; }
private static void log(Level level, String msg, Throwable thrown, Object... params) { if (!LOGGER.isLoggable(level)) { return; } LogRecord rec = new LogRecord(level, msg); // Set the loggerName of the LogRecord with the current logger rec.setLoggerName(LOGGER.getName()); rec.setParameters(params); rec.setThrown(thrown); LOGGER.log(rec); }
/** Like {@link Logger#log(Level, String, Object)}, except with a throwable arg */ public void log(String msg, Object param1, @Nullable Throwable thrown) { if (!LOG.isLoggable(Level.FINE)) return; // fine level to not fill logs LogRecord lr = new LogRecord(Level.FINE, msg); Object params[] = {param1}; lr.setParameters(params); if (thrown != null) lr.setThrown(thrown); LOG.log(lr); }
protected void log(Throwable t, Level level, String msg, Object[] objs) { LogRecord lr = createLogRecord(level, msg); if(t != null) { lr.setThrown(t); } if(objs != null) { //serializeCheck(objs); lr.setParameters(objs); } getLogger().log(lr); } protected void logp(Object clazz, String methodName, Throwable t, Level level, String msg, Object[] objs) {
protected Object writeReplace() { final LogRecord replacement = new LogRecord(getLevel(), getMessage()); replacement.setResourceBundle(getResourceBundle()); replacement.setLoggerName(getLoggerName()); replacement.setMillis(getMillis()); replacement.setParameters(getParameters()); replacement.setResourceBundleName(getResourceBundleName()); replacement.setSequenceNumber(getSequenceNumber()); replacement.setSourceClassName(getSourceClassName()); replacement.setSourceMethodName(getSourceMethodName()); replacement.setThreadID(getThreadID()); replacement.setThrown(getThrown()); return replacement; }
@Deprecated public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg, Object param1) { if (isLoggable(level)) { LogRecord lr = new LogRecord(level, msg); lr.setSourceClassName(sourceClass); lr.setSourceMethodName(sourceMethod); Object[] params = {param1 }; lr.setParameters(params); doLog(lr, bundleName); } }
private void log(Level level, Object message, Throwable t, Object... params) { if (!logger.isLoggable(level)) { return; } String msg = (message == null) ? "NULL" : message.toString(); LogRecord record = new LogRecord(level, msg); record.setLoggerName(logger.getName()); if (t != null) { record.setThrown(t); } else if (params != null && params.length != 0 && params[params.length - 1] instanceof Throwable) { // The exception may be the last parameters (SLF4J uses this convention). record.setThrown((Throwable) params[params.length - 1]); } // This will disable stack trace lookup inside JUL. If someone wants location info, they can use their own // formatter // or use a different logging framework like sl4j, or log4j record.setSourceClassName(null); record.setParameters(params); logger.log(record); }
try { if(thread!=null && thread.isAlive()) { logger.log(this.getSlowLoggingLevel(), "{0} thread is still running. Execution aborted.", name); return; thread.start(); } catch (Throwable t) { LogRecord lr = new LogRecord(this.getErrorLoggingLevel(), "{0} thread failed with error"); lr.setThrown(t); lr.setParameters(new Object[]{name}); logger.log(lr);
protected Object writeReplace() { final LogRecord replacement = new LogRecord(getLevel(), getMessage()); replacement.setResourceBundle(getResourceBundle()); replacement.setLoggerName(getLoggerName()); replacement.setMillis(getMillis()); replacement.setParameters(getParameters()); replacement.setResourceBundleName(getResourceBundleName()); replacement.setSequenceNumber(getSequenceNumber()); replacement.setSourceClassName(getSourceClassName()); replacement.setSourceMethodName(getSourceMethodName()); replacement.setThreadID(getThreadID()); replacement.setThrown(getThrown()); return replacement; }
@Deprecated public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg, Object[] params) { if (isLoggable(level)) { LogRecord lr = new LogRecord(level, msg); lr.setSourceClassName(sourceClass); lr.setSourceMethodName(sourceMethod); lr.setParameters(params); doLog(lr, bundleName); } }
/** * Logs a message indicating that a method is exited. A log record with log * level {@code Level.FINER}, log message "RETURN", the specified source * class name, source method name and return value is submitted for logging. * * @param sourceClass * the source class name. * @param sourceMethod * the source method name. * @param result * the return value of the method call. */ public void exiting(String sourceClass, String sourceMethod, Object result) { if (!internalIsLoggable(Level.FINER)) { return; } LogRecord record = new LogRecord(Level.FINER, "RETURN" + " {0}"); record.setLoggerName(this.name); record.setSourceClassName(sourceClass); record.setSourceMethodName(sourceMethod); record.setParameters(new Object[] { result }); setResourceBundle(record); log(record); }
InetAddress ia = InetAddress.getByName(address); if(!(ia instanceof Inet4Address)) { LOGGER.log(Level.FINE, "{0} is not an IPv4 address", address); continue; LOGGER.log(Level.FINE, "{0} didn't respond to ping", address); continue; } catch (IOException e) { LogRecord lr = new LogRecord(Level.FINE, "Failed to parse {0}"); lr.setThrown(e); lr.setParameters(new Object[]{address}); LOGGER.log(lr);
protected Object writeReplace() { final LogRecord replacement = new LogRecord(getLevel(), getMessage()); replacement.setResourceBundle(getResourceBundle()); replacement.setLoggerName(getLoggerName()); replacement.setMillis(getMillis()); replacement.setParameters(getParameters()); replacement.setResourceBundleName(getResourceBundleName()); replacement.setSequenceNumber(getSequenceNumber()); replacement.setSourceClassName(getSourceClassName()); replacement.setSourceMethodName(getSourceMethodName()); replacement.setThreadID(getThreadID()); replacement.setThrown(getThrown()); return replacement; }
@Deprecated public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg, Object[] params) { if (isLoggable(level)) { LogRecord lr = new LogRecord(level, msg); lr.setSourceClassName(sourceClass); lr.setSourceMethodName(sourceMethod); lr.setParameters(params); doLog(lr, bundleName); } }
/** * Logs a message of the specified level with the supplied parameter. The * message is then transmitted to all subscribed handlers. * * @param logLevel * the level of the given message. * @param msg * the message to log. * @param param * the parameter associated with the event that is logged. */ public void log(Level logLevel, String msg, Object param) { if (!internalIsLoggable(logLevel)) { return; } LogRecord record = new LogRecord(logLevel, msg); record.setLoggerName(this.name); record.setParameters(new Object[] { param }); setResourceBundle(record); log(record); }
public InputStream getInputStream() throws java.io.FileNotFoundException { if (fixIt == null) { if (ERR.isLoggable(Level.FINE)) { LogRecord rec = new LogRecord(Level.FINE, "MSG_CACHED_INPUT_STREAM"); rec.setParameters(new Object[] { this }); rec.setResourceBundle(NbBundle.getBundle(MIMESupport.class)); ERR.log(rec); } InputStream is = fileObj.getInputStream(); fixIt = new CachedInputStream(is); } fixIt.cacheToStart(); return fixIt; }