From ed6eff69b65d1bd877c6fe6e7dd6955dbd400c45 Mon Sep 17 00:00:00 2001 From: Gaboso Date: Wed, 13 Jun 2018 17:01:15 -0400 Subject: [PATCH] Refactoring in Logs --- .../org/xhtmlrenderer/util/JDKXRLogger.java | 103 +++++++++--------- .../org/xhtmlrenderer/util/LoggerUtil.java | 16 +-- .../java/org/xhtmlrenderer/util/XRLog.java | 46 ++++---- .../java/org/xhtmlrenderer/util/XRLogger.java | 13 ++- .../util/XRSimpleLogFormatter.java | 94 ++++++++-------- .../xhtmlrenderer/log4j/Log4JXRLogger.java | 43 ++++---- 6 files changed, 163 insertions(+), 152 deletions(-) diff --git a/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/JDKXRLogger.java b/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/JDKXRLogger.java index 769ce6151..c3db528fc 100644 --- a/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/JDKXRLogger.java +++ b/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/JDKXRLogger.java @@ -21,31 +21,29 @@ */ package org.xhtmlrenderer.util; -import java.io.File; -import java.io.FileInputStream; -import java.io.FileNotFoundException; -import java.io.FileOutputStream; import java.io.IOException; -import java.util.logging.Level; -import java.util.logging.LogManager; -import java.util.logging.Logger; -import java.util.logging.Handler; -import java.util.logging.Formatter; -import java.util.Properties; +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.HashMap; import java.util.Iterator; import java.util.List; -import java.util.Enumeration; import java.util.Map; -import java.util.HashMap; -import java.util.ArrayList; +import java.util.Properties; +import java.util.logging.Formatter; +import java.util.logging.Handler; +import java.util.logging.Level; +import java.util.logging.Logger; /** * An {@link XRLogger} interface that uses java.util.logging. */ public class JDKXRLogger implements XRLogger { + private static boolean initPending = true; - - /** {@inheritdoc} */ + + /** + * {@inheritdoc} + */ public void log(String where, Level level, String msg) { if (initPending) { init(); @@ -54,7 +52,9 @@ public void log(String where, Level level, String msg) { getLogger(where).log(level, msg); } - /** {@inheritdoc} */ + /** + * {@inheritdoc} + */ public void log(String where, Level level, String msg, Throwable th) { if (initPending) { init(); @@ -63,7 +63,9 @@ public void log(String where, Level level, String msg, Throwable th) { getLogger(where).log(level, msg, th); } - /** {@inheritdoc} */ + /** + * {@inheritdoc} + */ public void setLevel(String logger, Level level) { getLogger(logger).setLevel(level); } @@ -90,7 +92,7 @@ private static void init() { try { Properties props = retrieveLoggingProperties(); - if(!XRLog.isLoggingEnabled()) { + if (!XRLog.isLoggingEnabled()) { Configuration.setConfigLogger(Logger.getLogger(XRLog.CONFIG)); return; } @@ -99,8 +101,6 @@ private static void init() { Configuration.setConfigLogger(Logger.getLogger(XRLog.CONFIG)); } catch (SecurityException e) { // may happen in a sandbox environment - } catch (FileNotFoundException e) { - throw new XRRuntimeException("Could not initialize logs. " + e.getLocalizedMessage(), e); } catch (IOException e) { throw new XRRuntimeException("Could not initialize logs. " + e.getLocalizedMessage(), e); } @@ -123,19 +123,20 @@ private static Properties retrieveLoggingProperties() { } private static void initializeJDKLogManager(final Properties fsLoggingProperties) throws IOException { - final List loggers = retrieveLoggers(); + final List loggers = retrieveLoggers(); configureLoggerHandlerForwarding(fsLoggingProperties, loggers); // load our properties into our log manager Enumeration keys = fsLoggingProperties.keys(); - Map handlers = new HashMap(); - Map handlerFormatterMap = new HashMap(); + Map handlers = new HashMap(); + Map handlerFormatterMap = new HashMap(); + while (keys.hasMoreElements()) { String key = (String) keys.nextElement(); String prop = fsLoggingProperties.getProperty(key); if (key.endsWith("level")) { - configureLogLevel(key.substring(0, key.lastIndexOf(".")), prop); + configureLogLevel(key.substring(0, key.lastIndexOf('.')), prop); } else if (key.endsWith("handlers")) { handlers = configureLogHandlers(loggers, prop); } else if (key.endsWith("formatter")) { @@ -146,30 +147,29 @@ private static void initializeJDKLogManager(final Properties fsLoggingProperties // formatters apply to a specific handler we have initialized previously, // hence we need to wait until we've parsed the handler class - for (Iterator it = handlerFormatterMap.keySet().iterator(); it.hasNext();) { - String handlerClassName = (String) it.next(); - String formatterClassName = (String) handlerFormatterMap.get(handlerClassName); + for (String handlerClassName : handlerFormatterMap.keySet()) { + String formatterClassName = handlerFormatterMap.get(handlerClassName); assignFormatter(handlers, handlerClassName, formatterClassName); } } - private static void configureLoggerHandlerForwarding(Properties fsLoggingProperties, List loggers) { + private static void configureLoggerHandlerForwarding(Properties fsLoggingProperties, List loggers) { String val = fsLoggingProperties.getProperty("use-parent-handler"); - boolean flag = val == null ? false : Boolean.valueOf(val).booleanValue(); - for (Iterator it = loggers.iterator(); it.hasNext();) { - Logger logger = (Logger) it.next(); + boolean flag = val != null && Boolean.valueOf(val); + for (Logger logger : loggers) { logger.setUseParentHandlers(flag); } } - private static void assignFormatter(Map handlers, String handlerClassName, String formatterClassName) { - Handler handler = (Handler) handlers.get(handlerClassName); + private static void assignFormatter(Map handlers, String handlerClassName, String formatterClassName) { + Handler handler = handlers.get(handlerClassName); + if (handler != null) { try { Class fclass = Class.forName(formatterClassName); - Formatter f = (Formatter) fclass.newInstance(); - handler.setFormatter(f); + Formatter formatter = (Formatter) fclass.newInstance(); + handler.setFormatter(formatter); } catch (ClassNotFoundException e) { throw new XRRuntimeException("Could not initialize logging properties; " + "Formatter class not found: " + formatterClassName); @@ -187,14 +187,14 @@ private static void assignFormatter(Map handlers, String handlerClassName, Strin * Returns a List of all Logger instances used by Flying Saucer from the JDK LogManager; these will * be automatically created if they aren't already available. */ - private static List retrieveLoggers() { - List loggerNames = XRLog.listRegisteredLoggers(); - List loggers = new ArrayList(loggerNames.size()); - Iterator it = loggerNames.iterator(); - while (it.hasNext()) { - final String ln = (String) it.next(); - loggers.add(Logger.getLogger(ln)); + private static List retrieveLoggers() { + List loggerNames = XRLog.listRegisteredLoggers(); + List loggers = new ArrayList(loggerNames.size()); + + for (String loggerName : loggerNames) { + loggers.add(Logger.getLogger(loggerName)); } + return loggers; } @@ -202,17 +202,16 @@ private static List retrieveLoggers() { * For each logger provided, assigns the logger an instance of the named log output handlers. Will attempt * to instantiate each handler; any which can't be instantiated will cause the method to throw a RuntimeException. * - * @param loggers List of Logger instances. + * @param loggers List of Logger instances. * @param handlerClassList A space-separated string (following the configuration convention for JDK logging - * configuration files, for handlers) of FQN of log handlers. - * + * configuration files, for handlers) of FQN of log handlers. * @return Map of handler class names to handler instances. */ - private static Map configureLogHandlers(List loggers, final String handlerClassList) { + private static Map configureLogHandlers(List loggers, final String handlerClassList) { final String[] names = handlerClassList.split(" "); - final Map handlers = new HashMap(names.length); - for (int i = 0; i < names.length; i++) { - final String name = names[i]; + final Map handlers = new HashMap(names.length); + + for (final String name : names) { try { Class handlerClass = Class.forName(name); Handler handler = (Handler) handlerClass.newInstance(); @@ -232,10 +231,8 @@ private static Map configureLogHandlers(List loggers, final String handlerClassL } // now assign each handler to each FS logger - for (Iterator iterator = loggers.iterator(); iterator.hasNext();) { - Logger logger = (Logger) iterator.next(); - for (Iterator ith = handlers.values().iterator(); ith.hasNext();) { - Handler handler = (Handler) ith.next(); + for (Logger logger : loggers) { + for (Handler handler : handlers.values()) { logger.addHandler(handler); } } diff --git a/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/LoggerUtil.java b/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/LoggerUtil.java index 00f26cf39..19ae5b463 100644 --- a/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/LoggerUtil.java +++ b/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/LoggerUtil.java @@ -20,24 +20,26 @@ */ package org.xhtmlrenderer.util; -import java.util.logging.*; +import java.util.logging.Level; +import java.util.logging.Logger; /** * Utility class for working with java.logging Logger classes * - * @author Patrick Wright + * @author Patrick Wright */ public class LoggerUtil { + /** * Instantiate a Logger for debug messages for a given class. * - * @param cls PARAM - * @return The debugLogger value + * @param cls PARAM + * @return The debugLogger value */ - public static Logger getDebugLogger( Class cls ) { - Logger l = Logger.getLogger( cls.getName() ); - l.setLevel( Level.ALL ); + public static Logger getDebugLogger(Class cls) { + Logger l = Logger.getLogger(cls.getName()); + l.setLevel(Level.ALL); return l; } diff --git a/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/XRLog.java b/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/XRLog.java index 82f8901d5..0a739cc8b 100644 --- a/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/XRLog.java +++ b/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/XRLog.java @@ -33,30 +33,31 @@ * @author empty */ public class XRLog { - private static final List LOGGER_NAMES = new ArrayList(20); - public final static String CONFIG = registerLoggerByName("org.xhtmlrenderer.config"); - public final static String EXCEPTION = registerLoggerByName("org.xhtmlrenderer.exception"); - public final static String GENERAL = registerLoggerByName("org.xhtmlrenderer.general"); - public final static String INIT = registerLoggerByName("org.xhtmlrenderer.init"); - public final static String JUNIT = registerLoggerByName("org.xhtmlrenderer.junit"); - public final static String LOAD = registerLoggerByName("org.xhtmlrenderer.load"); - public final static String MATCH = registerLoggerByName("org.xhtmlrenderer.match"); - public final static String CASCADE = registerLoggerByName("org.xhtmlrenderer.cascade"); - public final static String XML_ENTITIES = registerLoggerByName("org.xhtmlrenderer.load.xml-entities"); - public final static String CSS_PARSE = registerLoggerByName("org.xhtmlrenderer.css-parse"); - public final static String LAYOUT = registerLoggerByName("org.xhtmlrenderer.layout"); - public final static String RENDER = registerLoggerByName("org.xhtmlrenderer.render"); - private static String registerLoggerByName(final String loggerName) { - LOGGER_NAMES.add(loggerName); - return loggerName; - } + private static final List LOGGER_NAMES = new ArrayList(20); + public static final String CONFIG = registerLoggerByName("org.xhtmlrenderer.config"); + public static final String EXCEPTION = registerLoggerByName("org.xhtmlrenderer.exception"); + public static final String GENERAL = registerLoggerByName("org.xhtmlrenderer.general"); + public static final String INIT = registerLoggerByName("org.xhtmlrenderer.init"); + public static final String JUNIT = registerLoggerByName("org.xhtmlrenderer.junit"); + public static final String LOAD = registerLoggerByName("org.xhtmlrenderer.load"); + public static final String MATCH = registerLoggerByName("org.xhtmlrenderer.match"); + public static final String CASCADE = registerLoggerByName("org.xhtmlrenderer.cascade"); + public static final String XML_ENTITIES = registerLoggerByName("org.xhtmlrenderer.load.xml-entities"); + public static final String CSS_PARSE = registerLoggerByName("org.xhtmlrenderer.css-parse"); + public static final String LAYOUT = registerLoggerByName("org.xhtmlrenderer.layout"); + public static final String RENDER = registerLoggerByName("org.xhtmlrenderer.render"); private static boolean initPending = true; private static XRLogger loggerImpl; private static boolean loggingEnabled = true; + private static String registerLoggerByName(final String loggerName) { + LOGGER_NAMES.add(loggerName); + return loggerName; + } + /** * Returns a list of all loggers that will be accessed by XRLog. Each entry is a String with a logger * name, which can be used to retrieve the logger using the corresponding Logging API; example name might be @@ -64,9 +65,9 @@ private static String registerLoggerByName(final String loggerName) { * * @return List of loggers, never null. */ - public static List listRegisteredLoggers() { + public static List listRegisteredLoggers() { // defensive copy - return new ArrayList(LOGGER_NAMES); + return new ArrayList(LOGGER_NAMES); } @@ -216,7 +217,7 @@ public static synchronized void log(String where, Level level, String msg, Throw } } - public static void main(String args[]) { + public static void main(String[] args) { try { XRLog.cascade("Cascade msg"); XRLog.cascade(Level.WARNING, "Cascade msg"); @@ -264,6 +265,7 @@ public static synchronized void setLevel(String log, Level level) { /** * Whether logging is on or off. + * * @return Returns true if logging is enabled, false if not. Corresponds * to configuration file property xr.util-logging.loggingEnabled, or to * value passed to setLoggingEnabled(bool). @@ -276,8 +278,8 @@ public static synchronized boolean isLoggingEnabled() { * Turns logging on or off, without affecting logging configuration. * * @param loggingEnabled Flag whether logging is enabled or not; - * if false, all logging calls fail silently. Corresponds - * to configuration file property xr.util-logging.loggingEnabled + * if false, all logging calls fail silently. Corresponds + * to configuration file property xr.util-logging.loggingEnabled */ public static synchronized void setLoggingEnabled(boolean loggingEnabled) { XRLog.loggingEnabled = loggingEnabled; diff --git a/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/XRLogger.java b/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/XRLogger.java index baf6612b3..fe7d23075 100644 --- a/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/XRLogger.java +++ b/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/XRLogger.java @@ -25,8 +25,11 @@ * An interface whose implementations log Flying Saucer log messages. */ public interface XRLogger { - public void log(String where, Level level, String msg); - public void log(String where, Level level, String msg, Throwable th); - - public void setLevel(String logger, Level level); -} + + void log(String where, Level level, String msg); + + void log(String where, Level level, String msg, Throwable th); + + void setLevel(String logger, Level level); + +} \ No newline at end of file diff --git a/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/XRSimpleLogFormatter.java b/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/XRSimpleLogFormatter.java index 52ac6e94a..063c10c3a 100644 --- a/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/XRSimpleLogFormatter.java +++ b/flying-saucer-core/src/main/java/org/xhtmlrenderer/util/XRSimpleLogFormatter.java @@ -20,56 +20,67 @@ */ package org.xhtmlrenderer.util; -import java.io.*; +import java.io.PrintWriter; +import java.io.StringWriter; import java.text.MessageFormat; -import java.util.logging.*; +import java.util.logging.Formatter; +import java.util.logging.Handler; +import java.util.logging.LogRecord; /** * A java.util.logging.Formatter class that writes a bare-bones log messages, * with no origin class name and no date/time. * - * @author Patrick Wright + * @author Patrick Wright */ public class XRSimpleLogFormatter extends Formatter { - /** Description of the Field */ + + private static final String MSG_FMT; + + private static final String EXMSG_FMT; + private final MessageFormat mformat; - /** Description of the Field */ + private final MessageFormat exmformat; - /** Description of the Field */ - private final static String msgFmt; - /** Description of the Field */ - private final static String exmsgFmt; - /** Constructor for the XRSimpleLogFormatter object */ + static { + MSG_FMT = Configuration.valueFor("xr.simple-log-format", "{1}:\n {5}\n").trim() + "\n"; + EXMSG_FMT = Configuration.valueFor("xr.simple-log-format-throwable", "{1}:\n {5}\n{8}").trim() + "\n"; + } + + /** + * Constructor for the XRSimpleLogFormatter object + */ public XRSimpleLogFormatter() { super(); - mformat = new MessageFormat( msgFmt ); - exmformat = new MessageFormat( exmsgFmt ); + mformat = new MessageFormat(MSG_FMT); + exmformat = new MessageFormat(EXMSG_FMT); } /** * Format the given log record and return the formatted string. * - * @param record PARAM - * @return Returns + * @param record PARAM + * @return Returns */ - public String format( LogRecord record ) { - + public String format(LogRecord record) { Throwable th = record.getThrown(); String thName = ""; String thMessage = ""; String trace = null; - if ( th != null ) { + + if (th != null) { StringWriter sw = new StringWriter(); - th.printStackTrace( new PrintWriter( sw ) ); + th.printStackTrace(new PrintWriter(sw)); trace = sw.toString(); thName = th.getClass().getName(); thMessage = th.getMessage(); } - String args[] = { - String.valueOf( record.getMillis() ), + + String[] args = { + String.valueOf(record.getMillis()), record.getLoggerName(), record.getLevel().toString(), record.getSourceClassName(), @@ -78,49 +89,42 @@ public String format( LogRecord record ) { thName, thMessage, trace - }; - String log = null; - if ( th == null ) { - log = mformat.format( args ); - } else { - log = exmformat.format( args ); - } - return log; + }; + + return th == null ? mformat.format(args) : exmformat.format(args); } /** * Localize and format the message string from a log record. * - * @param record PARAM - * @return Returns + * @param record PARAM + * @return Returns */ - public String formatMessage( LogRecord record ) { - return super.formatMessage( record ); + @Override + public String formatMessage(LogRecord record) { + return super.formatMessage(record); } /** * Return the header string for a set of formatted records. * - * @param h PARAM - * @return The head value + * @param h PARAM + * @return The head value */ - public String getHead( Handler h ) { - return super.getHead( h ); + @Override + public String getHead(Handler h) { + return super.getHead(h); } /** * Return the tail string for a set of formatted records. * - * @param h PARAM - * @return The tail value + * @param h PARAM + * @return The tail value */ - public String getTail( Handler h ) { - return super.getTail( h ); - } - - static { - msgFmt = Configuration.valueFor( "xr.simple-log-format", "{1}:\n {5}\n" ).trim() + "\n"; - exmsgFmt = Configuration.valueFor( "xr.simple-log-format-throwable", "{1}:\n {5}\n{8}" ).trim() + "\n"; + @Override + public String getTail(Handler h) { + return super.getTail(h); } }// end class diff --git a/flying-saucer-log4j/src/main/java/org/xhtmlrenderer/log4j/Log4JXRLogger.java b/flying-saucer-log4j/src/main/java/org/xhtmlrenderer/log4j/Log4JXRLogger.java index 79ad69ff7..0fc23a714 100644 --- a/flying-saucer-log4j/src/main/java/org/xhtmlrenderer/log4j/Log4JXRLogger.java +++ b/flying-saucer-log4j/src/main/java/org/xhtmlrenderer/log4j/Log4JXRLogger.java @@ -19,21 +19,23 @@ */ package org.xhtmlrenderer.log4j; -import java.util.HashMap; -import java.util.Map; -import java.util.logging.Level; - import org.apache.log4j.Logger; import org.xhtmlrenderer.util.XRLog; import org.xhtmlrenderer.util.XRLogger; +import java.util.HashMap; +import java.util.Map; +import java.util.logging.Level; + public class Log4JXRLogger implements XRLogger { + private static final String DEFAULT_LOGGER_NAME = "org.xhtmlrenderer.other"; - + private static final Map LOGGER_NAME_MAP; + static { LOGGER_NAME_MAP = new HashMap(); - + LOGGER_NAME_MAP.put(XRLog.CONFIG, "org.xhtmlrenderer.config"); LOGGER_NAME_MAP.put(XRLog.EXCEPTION, "org.xhtmlrenderer.exception"); LOGGER_NAME_MAP.put(XRLog.GENERAL, "org.xhtmlrenderer.general"); @@ -47,10 +49,10 @@ public class Log4JXRLogger implements XRLogger { LOGGER_NAME_MAP.put(XRLog.LAYOUT, "org.xhtmlrenderer.layout"); LOGGER_NAME_MAP.put(XRLog.RENDER, "org.xhtmlrenderer.render"); } - - private String _defaultLoggerName = DEFAULT_LOGGER_NAME; - private Map _loggerNameMap = LOGGER_NAME_MAP; - + + private String defaultLoggerName = DEFAULT_LOGGER_NAME; + private Map loggerNameMap = LOGGER_NAME_MAP; + public void log(String where, Level level, String msg) { Logger.getLogger(getLoggerName(where)).log(toLog4JLevel(level), msg); } @@ -58,7 +60,7 @@ public void log(String where, Level level, String msg) { public void log(String where, Level level, String msg, Throwable th) { Logger.getLogger(getLoggerName(where)).log(toLog4JLevel(level), msg, th); } - + private org.apache.log4j.Level toLog4JLevel(Level level) { if (level == Level.SEVERE) { return org.apache.log4j.Level.ERROR; @@ -74,33 +76,34 @@ private org.apache.log4j.Level toLog4JLevel(Level level) { return org.apache.log4j.Level.INFO; } } - + private String getLoggerName(String xrLoggerName) { - String result = (String)_loggerNameMap.get(xrLoggerName); + String result = (String) loggerNameMap.get(xrLoggerName); if (result != null) { return result; } else { - return _defaultLoggerName; + return defaultLoggerName; } } public void setLevel(String logger, Level level) { throw new UnsupportedOperationException("log4j should be not be configured here"); } - + public Map getLoggerNameMap() { - return _loggerNameMap; + return loggerNameMap; } public void setLoggerNameMap(Map loggerNameMap) { - _loggerNameMap = loggerNameMap; + this.loggerNameMap = loggerNameMap; } public String getDefaultLoggerName() { - return _defaultLoggerName; + return defaultLoggerName; } public void setDefaultLoggerName(String defaultLoggerName) { - _defaultLoggerName = defaultLoggerName; + this.defaultLoggerName = defaultLoggerName; } -} + +} \ No newline at end of file