/** * Installs log handler to monitor all Hudson logs. */ @edu.umd.cs.findbugs.annotations.SuppressFBWarnings("LG_LOST_LOGGER_DUE_TO_WEAK_REFERENCE") private void installLogger() { Jenkins.logRecords = handler.getView(); Logger.getLogger("").addHandler(handler); }
public void close() { for (Handler handler : newHandlers) { logger.removeHandler(handler); } for (Handler handler : oldHandlers) { logger.addHandler(handler); } logger.setLevel(oldLogLevel); logger.setUseParentHandlers(true); } }
Handler handler = new FileHandler("test.log", LOG_SIZE, LOG_ROTATION_COUNT); Logger.getLogger("").addHandler(handler);
Handler fh = new FileHandler("%t/wombat.log"); Logger.getLogger("").addHandler(fh); Logger.getLogger("com.wombat").setLevel(Level.FINEST);
private static void enableHttp2FrameLogging() { frameLogger = Logger.getLogger(Http2.class.getName()); frameLogger.setLevel(Level.FINE); ConsoleHandler handler = new ConsoleHandler(); handler.setLevel(Level.FINE); handler.setFormatter(new SimpleFormatter() { @Override public String format(LogRecord record) { return Util.format("%s%n", record.getMessage()); } }); frameLogger.addHandler(handler); } }
/** * Removes previously added no-op handler for root java logger. * * @param rmvHnds Previously removed handlers. */ public static void removeJavaNoOpLogger(Collection<Handler> rmvHnds) { Logger log = Logger.getLogger(""); for (Handler h : log.getHandlers()) log.removeHandler(h); if (!F.isEmpty(rmvHnds)) { for (Handler h : rmvHnds) log.addHandler(h); } }
FileHandler fh = new FileHandler(logFileName, false); logger.addHandler(fh); logger.setLevel(Level.FINE); fh.setFormatter(new NewlineLogFormatter()); } catch (SecurityException | IOException e) {
/** * Remove all current handlers from the logger and attach it with the given log handler. * * @param logger logger * @param handler the log handler */ static void disableOtherHandlers(Logger logger, Handler handler) { if (logger == null) { return; } synchronized (logger) { Handler[] handlers = logger.getHandlers(); if (handlers == null) { return; } if (handlers.length == 1 && handlers[0].equals(handler)) { return; } logger.setUseParentHandlers(false); // Remove all current handlers. for (Handler h : handlers) { logger.removeHandler(h); } // Attach the given handler. logger.addHandler(handler); } } }
final Handler[] handlers = logger.getHandlers(); for ( Handler handler : handlers ) logger.addHandler( replacement ); logger.setLevel( Level.ALL );
logfile.append(File.separatorChar).append("opengrok%g.%u.log"); for (Handler handler : getBaseLogger().getHandlers()) { if (handler instanceof FileHandler) { FileHandler fileHandler = (FileHandler) handler; int logFilesSizeLimit = loggerIntProperty("java.util.logging.FileHandler.limit", DEFAULT_FILEHANDLER_LIMIT); int logFilesCount = loggerIntProperty("java.util.logging.FileHandler.count", DEFAULT_FILEHANDLER_COUNT); newFileHandler = new FileHandler(logfile.toString(), logFilesSizeLimit, logFilesCount); } catch (IOException e) { LOGGER.log(Level.WARNING, "Cannot create new logger FileHandler: " + logfile.toString(), e); newFileHandler.setFormatter(new FileLogFormatter()); getBaseLogger().addHandler(newFileHandler); getBaseLogger().removeHandler(fileHandler); loggerFile = logfile.toString();
File logFile = new File(logsDir, baseName + ((tmp != null && tmp.length() > 0)? tmp: ".log")); FileHandler fh = new FileHandler(logFile.getAbsolutePath(), limit, count, true); fh.setFormatter(f); logger.addHandler(fh); logger.setUseParentHandlers(false); return fh;
public ScopedLogHandlersManager(Level level, Handler... handlers) { newHandlers = handlers; logger = Logger.getLogger(PACKAGE_NAME); oldHandlers = logger.getHandlers(); oldLogLevel = logger.getLevel(); logger.setLevel(level); // The Ant logger filters itself for (Handler handler : oldHandlers) { logger.removeHandler(handler); } for (Handler handler : newHandlers) { logger.addHandler(handler); handler.setLevel(level); } logger.setUseParentHandlers(false); }
@Test tester() { Logger logger = Logger.getLogger("my junit-test logger"); LogHandler handler = new LogHandler(); handler.setLevel(Level.ALL); logger.setUseParentHandlers(false); logger.addHandler(handler); logger.setLevel(Level.ALL);
public static void addGlobalHandler(Handler targetHandler) { Logger.getLogger("").addHandler(targetHandler); }
public static void adapt() { // get the top Logger: Logger topLogger = Logger.getLogger(""); Handler oldConsoleHandler = null; // see if there is already a console handler // hopefully reasonable assumption: there's only one ConsoleHandler // TODO confirm that this will always give us all handlers (i.e. do we need to loop over all Loggers in java.util.LogManager and do this for each one?) for (Handler handler : topLogger.getHandlers()) { if (handler instanceof ConsoleHandler && !(handler instanceof RedwoodHandler)) { // found the console handler oldConsoleHandler = handler; break; } } if (oldConsoleHandler != null) { // it's safe to call this after it's been removed topLogger.removeHandler(oldConsoleHandler); } if (!addedRedwoodHandler) { Handler redwoodHandler = new JavaUtilLoggingAdaptor.RedwoodHandler(); topLogger.addHandler(redwoodHandler); addedRedwoodHandler = true; } }
public static void main(String[] args) { Logger logger = Logger.getLogger("MyLog"); FileHandler fh; try { // This block configure the logger with handler and formatter fh = new FileHandler("C:/temp/test/MyLogFile.log"); logger.addHandler(fh); SimpleFormatter formatter = new SimpleFormatter(); fh.setFormatter(formatter); // the following statement is used to log any messages logger.info("My first log"); } catch (SecurityException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } logger.info("Hi How r u?"); }
/** * Register {@link Handler log handler} to the list of root loggers. */ private void registerLogHandler() { final String recordLogLevel = getProperty(TestProperties.RECORD_LOG_LEVEL); final int recordLogLevelInt = Integer.valueOf(recordLogLevel); final Level level = Level.parse(recordLogLevel); logLevelMap.clear(); for (final Logger root : getRootLoggers()) { logLevelMap.put(root, root.getLevel()); if (root.getLevel().intValue() > recordLogLevelInt) { root.setLevel(level); } root.addHandler(getLogHandler()); } }
Logger.getGlobal().setLevel(Level.OFF); getBaseLogger().setLevel(Level.ALL); StringBuilder logfile = new StringBuilder(); logfile.append(logpath == null ? "%t" : logpath); logfile.append(File.separatorChar).append("opengrok%g.%u.log"); try { FileHandler fh = new FileHandler(logfile.toString(), loggerIntProperty("java.util.logging.FileHandler.limit", DEFAULT_FILEHANDLER_LIMIT), loggerIntProperty("java.util.logging.FileHandler.count", DEFAULT_FILEHANDLER_COUNT)); getBaseLogger().addHandler(fh); loggerFile = logfile.toString(); ch.setLevel(consolelevel); ch.setFormatter(new ConsoleFormatter()); getBaseLogger().addHandler(ch);
public Void call() { SLAVE_LOG_HANDLER = new RingBufferLogHandler(ringBufferSize); // avoid double installation of the handler. JNLP agents can reconnect to the master multiple times // and each connection gets a different RemoteClassLoader, so we need to evict them by class name, // not by their identity. for (Handler h : LOGGER.getHandlers()) { if (h.getClass().getName().equals(SLAVE_LOG_HANDLER.getClass().getName())) LOGGER.removeHandler(h); } LOGGER.addHandler(SLAVE_LOG_HANDLER); // remove Sun PKCS11 provider if present. See http://wiki.jenkins-ci.org/display/JENKINS/Solaris+Issue+6276483 try { Security.removeProvider("SunPKCS11-Solaris"); } catch (SecurityException e) { // ignore this error. } try { getChannelOrFail().setProperty("slave",Boolean.TRUE); // indicate that this side of the channel is the agent side. } catch (ChannelClosedException e) { throw new IllegalStateException(e); } return null; } private static final long serialVersionUID = 1L;
logger.setLevel(filterLevel); if (logger.getHandlers().length > 0) { Handler handler = logger.getHandlers()[0]; final Handler[] handlers = parent.getHandlers(); logger.addHandler(handler); logger.setLevel(filterLevel); handler.setLevel(filterLevel); logger.addHandler(handler);