@DataBoundConstructor public Target(String name, String level) { this(name,Level.parse(level)); }
public Level getLevel() { return Level.parse(String.valueOf(level)); }
private Level getLevel(String line) { try { Matcher matcher = logLinePattern.matcher(line); if (matcher.matches()) { return Level.parse(matcher.group(2)); } else { return null; } } catch (IllegalArgumentException e) { return null; // level wasn't supplied in this log line } }
private static void process(java.util.logging.Logger log, String level, PrintWriter out) throws IOException { if (level != null) { log.setLevel(java.util.logging.Level.parse(level)); out.println(MARKER + "Setting Level to " + level + " ...<br />"); } java.util.logging.Level lev; for(; (lev = log.getLevel()) == null; log = log.getParent()); out.println(MARKER + "Effective level: <b>" + lev + "</b><br />"); } }
/** * Configure the logging level. */ @edu.umd.cs.findbugs.annotations.SuppressFBWarnings("LG_LOST_LOGGER_DUE_TO_WEAK_REFERENCE") @RequirePOST public HttpResponse doConfigLogger(@QueryParameter String name, @QueryParameter String level) { Jenkins.getInstance().checkPermission(Jenkins.ADMINISTER); Level lv; if(level.equals("inherit")) lv = null; else lv = Level.parse(level.toUpperCase(Locale.ENGLISH)); Logger.getLogger(name).setLevel(lv); return new HttpRedirect("levels"); }
private Level getLevelProperty(String name, Level defaultValue) { String stringLevel = getProperty(name); if (stringLevel == null) { return defaultValue; } try { return Level.parse(stringLevel); } catch (IllegalArgumentException ex) { // If the level does not exist we fall back to default value } return defaultValue; }
private static void process(java.util.logging.Logger log, String level, PrintWriter out) throws IOException { if (level != null) { String levelToUpperCase = level.toUpperCase(); try { log.setLevel(java.util.logging.Level.parse(levelToUpperCase)); } catch (IllegalArgumentException e) { out.println(MARKER + "Bad Level : <b>" + level + "</b><br />"); } out.println(MARKER + "Setting Level to " + level + " ...<br />"); } java.util.logging.Level lev; for(; (lev = log.getLevel()) == null; log = log.getParent()); out.println(MARKER + "Effective Level: <b>" + lev + "</b><br />"); } }
private static Level getLogLevel(final String logLevelString) { try { String logLevelAsString = StringUtils.isBlank(logLevelString) ? "" : logLevelString.trim(); // trim // spaces // if // any // To support level NONE, used by GemFire if ("NONE".equalsIgnoreCase(logLevelAsString)) { logLevelAsString = Level.OFF.getName(); } // To support level ERROR, used by GemFire, fall to WARNING if ("ERROR".equalsIgnoreCase(logLevelAsString)) { logLevelAsString = Level.WARNING.getName(); } return Level.parse(logLevelAsString.toUpperCase()); } catch (IllegalArgumentException e) { System.out.println(e.getMessage()); return DEFAULT_LOGLEVEL; } }
List<ReactorListener> r = Lists.newArrayList(ServiceLoader.load(InitReactorListener.class, Thread.currentThread().getContextClassLoader())); r.add(new ReactorListener() { final Level level = Level.parse( Configuration.getStringConfigParameter("initLogLevel", "FINE") ); public void onTaskStarted(Task t) { LOGGER.log(level, "Started {0}", getDisplayName(t));
Level threshold = Level.parse(level); List<LogRecord> filtered = new ArrayList<LogRecord>(); for (LogRecord r : logs) {
/** * 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()); } }
/** * Returns a logger to use for this configurable component. The logger can be configured with the property: * 'logLevel' - The default logLevel value is defined (within the xml configuration file by the global property * 'defaultLogLevel' (which defaults to WARNING). * <p> * implementation note: the logger became configured within the constructor of the parenting configuration manager. * * @return the logger for this component * @throws edu.cmu.sphinx.util.props.PropertyException * if an error occurs */ public Logger getLogger() { Logger logger; String baseName = ConfigurationManagerUtils.getLogPrefix(cm) + ownerClass.getName(); if (instanceName != null) { logger = Logger.getLogger(baseName + '.' + instanceName); } else logger = Logger.getLogger(baseName); // if there's a logLevel set for component apply to the logger Object rawLogLevel = rawProps.get(COMP_LOG_LEVEL); if (rawLogLevel != null) logger.setLevel(rawLogLevel instanceof String ? Level.parse((String) rawLogLevel) : (Level) rawLogLevel); return logger; }
final Level level = Level.parse(Configuration.getStringConfigParameter("termLogLevel", "FINE"));
/** * Configure the logger * @param cm Configuration manager */ public static void configureLogger(ConfigurationManager cm) { // Allow others to override the logging settings. if (System.getProperty("java.util.logging.config.class") != null || System.getProperty("java.util.logging.config.file") != null) { return; } // apply the log level (if defined) for the root logger (because we're using package based logging now) String cmPrefix = getLogPrefix(cm); Logger cmRootLogger = Logger.getLogger(cmPrefix.substring(0, cmPrefix.length() - 1)); // we need to determine the root-level here, because the logManager will reset it Level rootLevel = Logger.getLogger("").getLevel(); configureLogger(cmRootLogger); String level = cm.getGlobalProperty(GLOBAL_COMMON_LOGLEVEL); if (level == null) level = Level.WARNING.getName(); cmRootLogger.setLevel(Level.parse(level)); // restore the old root logger level Logger.getLogger("").setLevel(rootLevel); }
private static void setupLogger( boolean console, String file, String levelString, boolean fullStackTraces, boolean rotate) { Logger rootLogger = Logger.getLogger(""); for (Handler handler : rootLogger.getHandlers()) { rootLogger.removeHandler(handler); } Handler handler; if (console) { handler = new ConsoleHandler(); } else { handler = new RollingFileHandler(file, rotate); } handler.setFormatter(new LogFormatter(fullStackTraces)); Level level = Level.parse(levelString.toUpperCase()); rootLogger.setLevel(level); handler.setLevel(level); handler.setFilter(record -> record != null && !record.getLoggerName().startsWith("sun")); rootLogger.addHandler(handler); }
private synchronized void readConfigurationImpl(InputStream ins) throws IOException { reset(); props.load(ins); // The RI treats the root logger as special. For compatibility, always // update the root logger's handlers. Logger root = loggers.get(""); if (root != null) { root.setManager(this); } // parse property "config" and apply setting String configs = props.getProperty("config"); if (configs != null) { StringTokenizer st = new StringTokenizer(configs, " "); while (st.hasMoreTokens()) { String configerName = st.nextToken(); getInstanceByClass(configerName); } } // set levels for logger Collection<Logger> allLoggers = loggers.values(); for (Logger logger : allLoggers) { String property = props.getProperty(logger.getName() + ".level"); if (property != null) { logger.setLevel(Level.parse(property)); } } listeners.firePropertyChange(null, null, null); }
private static void process(java.util.logging.Logger log, String level, LogInfo result) throws IOException { if (log == null) { result.setMessage("log is null."); return; } if (level != null) { log.setLevel(java.util.logging.Level.parse(level)); result.setMessage("Setting Level to " + level); } java.util.logging.Level lev; while ((lev = log.getLevel()) == null) { log = log.getParent(); } result.setLevel(lev.toString()); } }
private void initLogLevel(OptionSet options, OptionSpec<Void> optionDebug, OptionSpec<String> optionLogLevel) { Level newLogLevel = null; // --debug if (options.has(optionDebug)) { newLogLevel = Level.ALL; } // --loglevel=<level> else if (options.has(optionLogLevel)) { String newLogLevelStr = options.valueOf(optionLogLevel); try { newLogLevel = Level.parse(newLogLevelStr); } catch (IllegalArgumentException e) { showErrorAndExit("Invalid log level given " + newLogLevelStr + "'"); } } else { newLogLevel = Level.INFO; } // Add handler to existing loggers, and future ones Logging.setGlobalLogLevel(newLogLevel); // Debug output if (options.has(optionDebug)) { out.println("debug"); out.println(String.format("Application version: %s", Client.getApplicationVersionFull())); logger.log(Level.INFO, "Application version: {0}", Client.getApplicationVersionFull()); } }
)); Level loggerLevel = Level.parse(filterLevel);