Logger globalLogger = Logger.getLogger("global"); Handler[] handlers = globalLogger.getHandlers(); for(Handler handler : handlers) { globalLogger.removeHandler(handler); }
public JdkLoggerAdapter() { try { InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream("logging.properties"); if (in != null) { LogManager.getLogManager().readConfiguration(in); } else { System.err.println("No such logging.properties in classpath for jdk logging config!"); } } catch (Throwable t) { System.err.println("Failed to load logging.properties in classpath for jdk logging config, cause: " + t.getMessage()); } try { Handler[] handlers = java.util.logging.Logger.getLogger(GLOBAL_LOGGER_NAME).getHandlers(); for (Handler handler : handlers) { if (handler instanceof FileHandler) { FileHandler fileHandler = (FileHandler) handler; Field field = fileHandler.getClass().getField("files"); File[] files = (File[]) field.get(fileHandler); if (files != null && files.length > 0) { file = files[0]; } } } } catch (Throwable t) { } }
private void removeTextAreaLogHandler(GCModelLoader modelLoader) { Logger logger = modelLoader.getGcResource().getLogger(); for (int i = logger.getHandlers().length - 1; i >= 0; --i) { if (logger.getHandlers()[i] instanceof TextAreaLogHandler) { logger.removeHandler(logger.getHandlers()[i]); } } }
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); }
//get the top Logger Logger topLogger = java.util.logging.Logger.getLogger(""); // Handler for console (reuse it if it already exists) Handler consoleHandler = null; //see if there is already a console handler for (Handler handler : topLogger.getHandlers()) { if (handler instanceof ConsoleHandler) { //found the console handler consoleHandler = handler; break; } } if (consoleHandler == null) { //there was no console handler found, create a new one consoleHandler = new ConsoleHandler(); topLogger.addHandler(consoleHandler); } //set the console handler to fine: consoleHandler.setLevel(java.util.logging.Level.FINEST);
/** * 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); } } }
/** * Configures a logger to use the sphinx4-log-formatter. * @param logger logger to configure */ public static void configureLogger(Logger logger) { logger.setUseParentHandlers(false); boolean hasHandler = false; for (Handler handler : logger.getHandlers()) { if (handler.getFormatter() instanceof SphinxLogFormatter) { hasHandler = true; break; } } if (!hasHandler) { ConsoleHandler handler = new ConsoleHandler(); handler.setFormatter(new SphinxLogFormatter()); logger.addHandler(handler); } }
public JdkLoggerAdapter() { try { InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream("logging.properties"); if (in != null) { LogManager.getLogManager().readConfiguration(in); } else { System.err.println("No such logging.properties in classpath for jdk logging config!"); } } catch (Throwable t) { System.err.println("Failed to load logging.properties in classpath for jdk logging config, cause: " + t.getMessage()); } try { Handler[] handlers = java.util.logging.Logger.getLogger(GLOBAL_LOGGER_NAME).getHandlers(); for (Handler handler : handlers) { if (handler instanceof FileHandler) { FileHandler fileHandler = (FileHandler) handler; Field field = fileHandler.getClass().getField("files"); File[] files = (File[]) field.get(fileHandler); if (files != null && files.length > 0) { file = files[0]; } } } } catch (Throwable t) { } }
/** * 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); } }
private static void fineLogging() { //get the top Logger: Logger topLogger = java.util.logging.Logger.getLogger(""); // Handler for console (reuse it if it already exists) Handler consoleHandler = null; //see if there is already a console handler for (Handler handler : topLogger.getHandlers()) { if (handler instanceof ConsoleHandler) { //found the console handler consoleHandler = handler; break; } } if (consoleHandler == null) { //there was no console handler found, create a new one consoleHandler = new ConsoleHandler(); topLogger.addHandler(consoleHandler); } //set the console handler to fine: consoleHandler.setLevel(java.util.logging.Level.FINEST); }
public static void disableLogging() { LogManager.getLogManager().reset(); setGlobalLogLevel(Level.OFF); while (Logger.getLogger("").getHandlers().length > 0) { Logger.getLogger("").removeHandler(Logger.getLogger("").getHandlers()[0]); } } }
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;
private static void addOrSetHandler(final Handler handler) { if (LOGGER.getHandlers().length == 0) { LOGGER.addHandler(handler); } else { LOGGER.getHandlers()[0] = handler; } }
/** * Invoking this method removes/unregisters/detaches all handlers currently attached to the root logger * @since 1.6.5 */ public static void removeHandlersForRootLogger() { java.util.logging.Logger rootLogger = getRootLogger(); java.util.logging.Handler[] handlers = rootLogger.getHandlers(); for (int i = 0; i < handlers.length; i++) { rootLogger.removeHandler(handlers[i]); } }
@NoWarning("LG_LOST_LOGGER_DUE_TO_WEAK_REFERENCE") public static void main(String[] args) throws Throwable { java.util.logging.Handler[] handlers = java.util.logging.Logger.getLogger("").getHandlers(); for (java.util.logging.Handler handler : handlers) { handler.setLevel(Level.ALL); } jerseyLogger.setLevel(Level.ALL); }
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 setConsoleLevel(Level level) { // get the top Logger: Logger topLogger = java.util.logging.Logger.getLogger(""); // Handler for console (reuse it if it already exists) Handler consoleHandler = null; // see if there is already a console handler for (Handler handler : topLogger.getHandlers()) { if (handler instanceof ConsoleHandler) { // found the console handler consoleHandler = handler; break; } } if (consoleHandler == null) { // there was no console handler found, create a new one consoleHandler = new ConsoleHandler(); topLogger.addHandler(consoleHandler); } // set the console handler level: consoleHandler.setLevel(level); consoleHandler.setFormatter(new SimpleFormatter()); }
Handler[] handlers = Logger.getLogger("").getHandlers(); impl.removeHandler(h);
/** * Removes the standard Android log handler due to an issue with not logging * entries lower than INFO level and adds a handler that produces * JME formatted log messages. */ protected void initializeLogHandler() { Logger log = LogManager.getLogManager().getLogger(""); for (Handler handler : log.getHandlers()) { if (log.getLevel() != null && log.getLevel().intValue() <= Level.FINE.intValue()) { Log.v("AndroidHarness", "Removing Handler class: " + handler.getClass().getName()); } log.removeHandler(handler); } Handler handler = new AndroidLogHandler(); log.addHandler(handler); handler.setLevel(Level.ALL); }
@Override protected void setup(Binder binder) { LogManager manager = LogManager.getLogManager(); LogConfig logConfig = buildConfigObject(LogConfig.class); if (logConfig.getLogActive()) { if (!Arrays.stream(manager.getLogger("").getHandlers()) .anyMatch(e -> e instanceof SentryHandler)) { Logger rootLogger = manager.getLogger(""); SentryClient client = Sentry.init(SENTRY_DSN); if (logConfig.getTags() != null) { for (String item : Splitter.on(',').split(logConfig.getTags())) { String[] split = item.split("=", 2); client.addTag(split[0], split.length > 1 ? split[1] : "true"); } } client.setRelease(RakamClient.RELEASE); SentryHandler sentryHandler = new SentryHandler(); sentryHandler.setLevel(Level.SEVERE); rootLogger.addHandler(sentryHandler); } } }