separate console STDERR and STDOUT (#429)

Author: CarolynRountree

core/src/main/java/oracle/weblogic/deploy/logging/LoggingUtils.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Licensed under the Universal Permissive License v 1.0 as shown at http://oss.oracle.com/licenses/upl.
+ */
+package oracle.weblogic.deploy.logging;
+
+import java.text.MessageFormat;
+import java.util.Properties;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+
+import static oracle.weblogic.deploy.logging.WLSDeployLoggingConfig.ERROR_EXIT_CODE;
+
+public class LoggingUtils {
+
+    public static <T extends Handler> Class<T> getHandlerClass(String handlerName) {
+        Class<T> handler = null;
+        try {
+            Class<?> checkClass = Class.forName(handlerName);
+            handler = (Class<T>)checkClass.asSubclass(Class.forName(handlerName));
+        } catch(ClassNotFoundException | ClassCastException cnf) {
+            exitWithError(
+                    MessageFormat.format("Unable to find handler class {0} so skipping logging configuration",
+                    handlerName));
+        }
+        return handler;
+    }
+
+    public static <T extends Handler> T getHandlerInstance(Class<T> handlerClass) {
+        T handler = null;
+        try {
+            handler =  handlerClass.newInstance();
+         } catch (InstantiationException | IllegalAccessException e){
+            exitWithError(MessageFormat.format("Unable to instantiate Handler for Class {0}", handlerClass));
+        }
+        return handler;
+    }
+
+    public static <T extends Handler> T getHandlerInstance(String handlerClassName) {
+        return getHandlerInstance(LoggingUtils.<T>getHandlerClass(handlerClassName));
+    }
+
+    public static void exitWithError(String message) {
+        System.err.println(message);
+        System.exit(ERROR_EXIT_CODE);
+    }
+
+    public static LogRecord cloneRecordWithoutException(LogRecord record) {
+        LogRecord newRecord = new LogRecord(record.getLevel(), record.getMessage());
+
+        newRecord.setLoggerName(record.getLoggerName());
+        newRecord.setMillis(record.getMillis());
+        newRecord.setParameters(record.getParameters());
+        newRecord.setResourceBundle(record.getResourceBundle());
+        newRecord.setResourceBundleName(record.getResourceBundleName());
+        newRecord.setSequenceNumber(record.getSequenceNumber());
+        newRecord.setSourceClassName(record.getSourceClassName());
+        newRecord.setSourceMethodName(record.getSourceMethodName());
+        newRecord.setThreadID(record.getThreadID());
+        // Skip thrown
+        return newRecord;
+    }
+
+    public static void printLogProperties(Properties logProps, String prefix) {
+        if (logProps != null) {
+            for (String propName : logProps.stringPropertyNames()) {
+                System.err.println(prefix + propName + '=' + logProps.getProperty(propName));
+            }
+        }
+    }
+
+}

core/src/main/java/oracle/weblogic/deploy/logging/SummaryHandler.java

@@ -7,7 +7,6 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Properties;
-import java.util.logging.ConsoleHandler;
 import java.util.logging.Formatter;
 import java.util.logging.Handler;
 import java.util.logging.Level;
@@ -16,7 +15,6 @@
 import java.util.logging.MemoryHandler;
 
 import oracle.weblogic.deploy.util.WLSDeployContext;
-import oracle.weblogic.deploy.util.WLSDeployExit;
 import oracle.weblogic.deploy.util.WebLogicDeployToolingVersion;
 
 
@@ -111,16 +109,16 @@ public synchronized void logEnd(WLSDeployContext modelContext) {
     }
 
     /**
-     * The WLSDeployLoggingConfig will call this method to add to the logging.properties files.
-     * If the logging.properties already contains the property, the property in this list will be ignored.
+     * The WLSDeployLoggingConfig will call this method to add the SummaryHandler properties to the logging.properties
+     * files. If the logging.properties already contains the property, the property in this list will be ignored.
      *
      * @return properties to set in logging.properties
      */
     public static Properties getHandlerProperties() {
         Properties properties = new Properties();
         properties.setProperty(LEVEL_PROPERTY, Level.INFO.getName());
-        properties.setProperty(TARGET_PROPERTY, WLSDeployLoggingConsoleHandler.class.getName());
-        properties.setProperty(FORMATTER_PROPERTY, WLSDeployLogFormatter.class.getName());
+        properties.setProperty(TARGET_PROPERTY, WLSDeployLoggingConfig.getStdoutHandler());
+        properties.setProperty(FORMATTER_PROPERTY, WLSDeployConsoleFormatter.class.getName());
         return properties;
     }
 
@@ -207,7 +205,9 @@ public synchronized void publish(LogRecord record) {
                 super.publish(record);
             }
         }
-
+        public synchronized void push() {
+            super.push();
+        }
         int getTotalRecords() {
             return totalRecords;
         }
@@ -231,19 +231,12 @@ private int getSize(String propSize) {
         return handlerSize;
     }
 
-    private ConsoleHandler getConsoleHandler() {
-        ConsoleHandler handler = null;
-        try {
-            handler = (ConsoleHandler) Class.forName(WLSDeployLoggingConfig.getConsoleHandler()).newInstance();
-        } catch (ClassNotFoundException | IllegalAccessException cne) {
-            System.out.println("Class not found " + WLSDeployLoggingConfig.getConsoleHandler());
-        } catch (InstantiationException ie) {
-            handler = new ConsoleHandler();
-        }
+    private Handler getConsoleHandler() {
+        Handler handler = LoggingUtils.getHandlerInstance(WLSDeployLoggingConfig.getStdoutHandler());
+        handler.setFilter(null);
         return handler;
     }
 
-
     private LogRecord getLogRecord(String msg, Object... params) {
         LogRecord record = new LogRecord(Level.INFO, msg);
         record.setLoggerName(LOGGER.getName());

core/src/main/java/oracle/weblogic/deploy/logging/WLSDeployConsoleErrorFilter.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Licensed under the Universal Permissive License v 1.0 as shown at http://oss.oracle.com/licenses/upl.
+ */
+package oracle.weblogic.deploy.logging;
+
+import java.util.logging.Filter;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+
+/**
+ * This Class queries the information in the LogRecord to determine if it can be written to the OutputStream
+ * associated with Error log record types.
+ */
+public class WLSDeployConsoleErrorFilter implements Filter {
+
+    @Override
+    public boolean isLoggable(LogRecord record) {
+        boolean stdErr = false;
+        int level = record.getLevel() == null ? 0 : record.getLevel().intValue();
+        if (level == Level.WARNING.intValue() || level == Level.SEVERE.intValue()) {
+            stdErr = true;
+        }
+        return stdErr;
+    }
+
+}

core/src/main/java/oracle/weblogic/deploy/logging/WLSDeployConsoleFormatter.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Licensed under the Universal Permissive License v 1.0 as shown at http://oss.oracle.com/licenses/upl.
+ */
+package oracle.weblogic.deploy.logging;
+
+import java.util.logging.Formatter;
+import java.util.logging.LogRecord;
+
+/**
+ * This class removes the Exception record from the LogRecord before formatting so that a
+ * stack trace will not print to the Console. The WLSDeployLogFormatter is by default called to
+ * format the LogRecord into a localized String. To select a different formatter, inject
+ * that instance into the set formatter of this Instance.
+ */
+public class WLSDeployConsoleFormatter extends Formatter {
+
+    // Default Formatter if another is not injected
+    private Formatter formatter = new WLSDeployLogFormatter();
+
+    public String format(LogRecord logRecord) {
+        LogRecord cloned = LoggingUtils.cloneRecordWithoutException(logRecord);
+        return formatter.format(cloned);
+    }
+
+    public void setFormatter(Formatter formatter) {
+        if (formatter != null) {
+            this.formatter = formatter;
+        }
+    }
+
+}

core/src/main/java/oracle/weblogic/deploy/logging/WLSDeployConsoleOutFilter.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Licensed under the Universal Permissive License v 1.0 as shown at http://oss.oracle.com/licenses/upl.
+ */
+package oracle.weblogic.deploy.logging;
+
+import java.util.logging.Filter;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+
+/**
+ * This Class queries the information in the LogRecord to determine if it can be written to the OutputStream
+ * associated with standard console log record types.
+ */
+public class WLSDeployConsoleOutFilter implements Filter {
+
+    @Override
+    public boolean isLoggable(LogRecord record) {
+        boolean stdOut = true;
+        int level = record.getLevel() == null ? 0 : record.getLevel().intValue();
+        if (level == Level.WARNING.intValue() || level == Level.SEVERE.intValue()) {
+            stdOut = false;
+        }
+        return stdOut;
+    }
+
+}

core/src/main/java/oracle/weblogic/deploy/logging/WLSDeployCustomizeLoggingConfig.java

@@ -8,8 +8,13 @@
 
 import java.lang.reflect.Method;
 import java.text.MessageFormat;
-import java.util.*;
-import java.util.logging.Handler;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * Use this class to add custom handlers to the root WLSDEPLOY logger. The WLSDeployLoggingConfig
@@ -21,10 +26,10 @@
  * WLSDEPLOY_LOG_HANDLERS_ENV_VARIABLE. The property in the logging.properties file takes precedence
  * over the environment variable.
  *
- * <p>This class will check each handler in the list to see if it has implemented the WLSDEPLOY_HANDLER_METHOD. This method
- * returns a handler's properties. Any property that already exists in the logging.properties will be discarded -
- * as logging.properties takes precedence. Any property that does not start with the handler class name will
- * be rejected. This class' ONLY purpose is to dynamically add a handler and/or its properties to the
+ * <p>This class will check each handler in the list to see if it has implemented the WLSDEPLOY_HANDLER_METHOD.
+ * This method returns a handler's properties. Any property that already exists in the logging.properties
+ * will be discarded - as logging.properties takes precedence. Any property that does not start with the handler
+ * class name will be rejected. This class' ONLY purpose is to dynamically add a handler and/or its properties to the
  * WLSDEPLOY root logger.
  *
  * <p>The WLSDEPLOY logger is instantiated by WLSDeployLoggingConfig (and thus, the handlers are
@@ -75,25 +80,12 @@ private static Set<String> findExtraHandlers(Properties logProps) {
     }
 
     private static Class<?> getHandlerClass(String handlerName) {
-        String message = null;
-        Class<?> handler = null;
-        try {
-            handler = Class.forName(handlerName);
-            if (!Handler.class.isAssignableFrom(handler)) {
-                message = MessageFormat.format("Class {0} is not a Handler", handlerName);
-            }
-        } catch(ClassNotFoundException cnf) {
-            message = MessageFormat.format("Unable to find handler class {0} so skipping logging configuration",
-                    handlerName);
-        }
-        if (message != null) {
-            System.err.println(message);
-            System.exit(ERROR_EXIT_CODE);
-        }
-        return handler;
+        return LoggingUtils.getHandlerClass(handlerName);
     }
 
     private static void addHandlerProperties(Properties logProps, Class<?> clazz) {
+        // Uncomment to debug the properties
+        // LoggingUtils.printLogProperties(logProps, "Before:  ");
         Properties props = null;
         // a forEach would be good here!
         String clazzName = clazz.getName();
@@ -125,6 +117,8 @@ private static void addHandlerProperties(Properties logProps, Class<?> clazz) {
                 }
             }
         }
+        // Uncomment to debug the log properties
+        // LoggingUtils.printLogProperties(logProps, "After:  ");
     }
 
 }