// 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));
}
