// actual initialization process from a given input stream 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); }
// Package private method to get a Level property. // If the property is not defined or cannot be parsed // we return the given default value. Level getLevelProperty(String name, Level defaultValue) { String val = getProperty(name); if (val == null) { return defaultValue; } try { return Level.parse(val.trim()); } catch (Exception ex) { return defaultValue; } }
/** * Returns the value of a configuration property as a Level. * This function is a helper used by the Classpath implementation * of java.util.logging, it is <em>not</em> specified in the * logging API. * * @param propertyName the name of the configuration property. * * @param defaultValue the value that will be returned if the * property is not defined, or if * {@link Level.parse(java.lang.String)} does not like * the property value. */ static Level getLevelProperty(String propertyName, Level defaultValue) { try { return Level.parse(getLogManager().getProperty(propertyName)); } catch (Exception ex) { return defaultValue; } }
public Object process() throws xMethodException { boolean valid = true; String why = ""; String level = this.getArguments("level"); try { Level log_level = Level.parse(level); xLogger.setXliveObjectLoggerLevel(log_level); } catch (Exception e) { valid = false; why = e.getMessage(); } setReturnArguments("valid", String.valueOf(valid)); setReturnArguments("why", why); return getServiceContext().doNextProcess(); }
static { try { final Level level = Level.parse(System.getProperty(getLoggerName(), "WARNING")); final Handler[] handlers = Logger.getLogger("").getHandlers(); for (final Handler handler : handlers) { handler.setLevel(level); } logger.setLevel(level); } catch (final Exception e) { System.out.println("Exception " + e + " in Aparapi logging setup"); e.printStackTrace(); } };
/** * startLogger initializes and returns a file at logLoc with the results of logging at level * logLevel. * * @param logLoc location of the output log file- a string * @param logLevel logging level (is parsed by level.parse()) * @return Logger object to log to. */ public Logger startLogger(String logLoc, String logLevel) { try { fh = new FileHandler(logLoc); // sets output log file at logLoc } catch (SecurityException e) { e.printStackTrace(); System.err.println("SecurityException establishing logger. Exiting...\n"); System.exit(1); } catch (IOException e) { e.printStackTrace(); System.err.println("IOException establishing logger. Exiting...\n"); System.exit(1); } fh.setFormatter(new SimpleFormatter()); // format of log is 'human-readable' simpleformat logger.addHandler(fh); // attach formatter to logger logger.setLevel(Level.parse(logLevel)); // set log level return logger; }
public synchronized void readConfiguration(InputStream inputStream) throws IOException, SecurityException { Properties newProperties; Enumeration keys; checkAccess(); newProperties = new Properties(); newProperties.load(inputStream); this.properties = newProperties; keys = newProperties.propertyNames(); while (keys.hasMoreElements()) { String key = (String) keys.nextElement(); String value = newProperties.getProperty(key); if (value == null) continue; if (key.endsWith(".level")) { String loggerName = key.substring(0, key.length() - 6); Logger logger = getLogger(loggerName); if (logger != null) { try { logger.setLevel(Level.parse(value)); } catch (Exception _) { } continue; } } } /* The API specification does not talk about the * property name that is distributed with the * PropertyChangeEvent. With test code, it could * be determined that the Sun J2SE 1.4 reference * implementation uses null for the property name. */ pcs.firePropertyChange(null, null, null); }
public HostInfo(InetAddress address, String name) { super(); String SLevel = System.getProperty("jmdns.debug"); if (SLevel == null) SLevel = "INFO"; logger.setLevel(Level.parse(SLevel)); this.address = address; this.name = name; if (address != null) { try { interfaze = NetworkInterface.getByInetAddress(address); } catch (Exception exception) { // FIXME Shouldn't we take an action here? logger.log(Level.WARNING, "LocalHostInfo() exception ", exception); } } }
public void setLoggerLevel(String loggerName, String levelName) { if (loggerName == null) { throw new NullPointerException("loggerName is null"); } Logger logger = logManager.getLogger(loggerName); if (logger == null) { throw new IllegalArgumentException("Logger " + loggerName + "does not exist"); } Level level = null; if (levelName != null) { // parse will throw IAE if logLevel is invalid level = Level.parse(levelName); } logger.setLevel(level); }
public static void setup(LoggerConfig config) { Logger log = config.getRootLogger(); DefaultFormatter.setAppId(config.getLogFileName()); try { File logDir = Directories.getLogDir(); if (!logDir.exists()) { logDir.mkdirs(); } FileHandler fileHandler = new FileHandler( config.getLogFilePattern(), config.getMaxBytes(), config.getMaxFiles(), config.doAppend()); LogManager manager = LogManager.getLogManager(); // retrieve the Level-setting from the property file for the FileHandler Level level = Level.ALL; String val = manager.getProperty(FileHandler.class.getName() + ".level"); if (val != null) { try { level = Level.parse(val.trim()); } catch (Exception ex) { } } fileHandler.setLevel(level); log.addHandler(fileHandler); } catch (Exception e) { System.err.println( TextUtils.merge( "Unable to setup log file for ''{0}''. Reason: {1}", config.getLogFileName(), e.getLocalizedMessage())); } for (Handler handler : log.getHandlers()) { handler.setFormatter(config.getFormatter()); // ugly hack: don't display this error message in the console until we // get feedback from tomcat-users mailing list, // see http://mail-archives.apache.org/mod_mbox/tomcat-users/201104.mbox/browser if (handler instanceof ConsoleHandler) { handler.setFilter( new Filter() { @Override public boolean isLoggable(LogRecord record) { if (record.getMessage().equals("persistentManager.swapInInvalid")) { return false; } return true; } }); } } // report this even when in WARN-loglevel Logger initLOGGER = Logger.getLogger("Init"); Level level = initLOGGER.getLevel(); try { initLOGGER.setLevel(Level.INFO); initLOGGER.info( "-----------------------------------------------------------------------------"); initLOGGER.info( TextUtils.merge( "easyTravel Demo Application - Copyright (C) 2010-{0,date,yyyy} dynaTrace software GmbH", new Date())); initLOGGER.info( "-----------------------------------------------------------------------------"); Version version = Version.read(); initLOGGER.info("Version: " + version.toString()); initLOGGER.info("Build Date: " + version.getBuilddate()); initLOGGER.info("Platform: " + getPlatformDescription()); } finally { // restore previous level initLOGGER.setLevel(level); } }
/** * Returns the current log level used by all <code>java.util.logging</code> loggers. * * @return the current log level used by all <code>java.util.logging</code> loggers. */ public static Level getLogLevel() { return Level.parse( MuConfiguration.getVariable(MuConfiguration.LOG_LEVEL, MuConfiguration.DEFAULT_LOG_LEVEL)); }