/*
 * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */


package sun.util.logging;

import java.lang.ref.WeakReference;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import sun.misc.JavaLangAccess;
import sun.misc.SharedSecrets;

Platform logger provides an API for the JRE components to log messages. This enables the runtime components to eliminate the static dependency of the logging facility and also defers the java.util.logging initialization until it is enabled. In addition, the PlatformLogger API can be used if the logging module does not exist. If the logging facility is not enabled, the platform loggers will output log messages per the default logging configuration (see below). In this implementation, it does not log the the stack frame information issuing the log message. When the logging facility is enabled (at startup or runtime), the java.util.logging.Logger will be created for each platform logger and all log messages will be forwarded to the Logger to handle. Logging facility is "enabled" when one of the following conditions is met: 1) a system property "java.util.logging.config.class" or "java.util.logging.config.file" is set 2) java.util.logging.LogManager or java.util.logging.Logger is referenced that will trigger the logging initialization. Default logging configuration: global logging level = INFO handlers = java.util.logging.ConsoleHandler java.util.logging.ConsoleHandler.level = INFO java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter Limitation: /lib/logging.properties is the system-wide logging configuration defined in the specification and read in the default case to configure any java.util.logging.Logger instances. Platform loggers will not detect if /lib/logging.properties is modified. In other words, unless the java.util.logging API is used at runtime or the logging system properties is set, the platform loggers will use the default setting described above. The platform loggers are designed for JDK developers use and this limitation can be workaround with setting -Djava.util.logging.config.file system property.
Since:1.7
/** * Platform logger provides an API for the JRE components to log * messages. This enables the runtime components to eliminate the * static dependency of the logging facility and also defers the * java.util.logging initialization until it is enabled. * In addition, the PlatformLogger API can be used if the logging * module does not exist. * * If the logging facility is not enabled, the platform loggers * will output log messages per the default logging configuration * (see below). In this implementation, it does not log the * the stack frame information issuing the log message. * * When the logging facility is enabled (at startup or runtime), * the java.util.logging.Logger will be created for each platform * logger and all log messages will be forwarded to the Logger * to handle. * * Logging facility is "enabled" when one of the following * conditions is met: * 1) a system property "java.util.logging.config.class" or * "java.util.logging.config.file" is set * 2) java.util.logging.LogManager or java.util.logging.Logger * is referenced that will trigger the logging initialization. * * Default logging configuration: * global logging level = INFO * handlers = java.util.logging.ConsoleHandler * java.util.logging.ConsoleHandler.level = INFO * java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter * * Limitation: * <JAVA_HOME>/lib/logging.properties is the system-wide logging * configuration defined in the specification and read in the * default case to configure any java.util.logging.Logger instances. * Platform loggers will not detect if <JAVA_HOME>/lib/logging.properties * is modified. In other words, unless the java.util.logging API * is used at runtime or the logging system properties is set, * the platform loggers will use the default setting described above. * The platform loggers are designed for JDK developers use and * this limitation can be workaround with setting * -Djava.util.logging.config.file system property. * * @since 1.7 */
public class PlatformLogger { /* * These constants should be shortcuts to Level enum constants that * the clients of sun.util.logging.PlatformLogger require no source * modification and avoid the conversion from int to Level enum. * * This can be done when JavaFX is converted to use the new PlatformLogger.Level API. */ public static final int OFF = Integer.MAX_VALUE; public static final int SEVERE = 1000; public static final int WARNING = 900; public static final int INFO = 800; public static final int CONFIG = 700; public static final int FINE = 500; public static final int FINER = 400; public static final int FINEST = 300; public static final int ALL = Integer.MIN_VALUE;
PlatformLogger logging levels.
/** * PlatformLogger logging levels. */
public static enum Level { // The name and value must match that of {@code java.util.logging.Level}s. // Declare in ascending order of the given value for binary search. ALL, FINEST, FINER, FINE, CONFIG, INFO, WARNING, SEVERE, OFF;
Associated java.util.logging.Level lazily initialized in JavaLoggerProxy's static initializer only once when java.util.logging is available and enabled. Only accessed by JavaLoggerProxy.
/** * Associated java.util.logging.Level lazily initialized in * JavaLoggerProxy's static initializer only once * when java.util.logging is available and enabled. * Only accessed by JavaLoggerProxy. */
/* java.util.logging.Level */ Object javaLevel; // ascending order for binary search matching the list of enum constants private static final int[] levelValues = new int[] { PlatformLogger.ALL, PlatformLogger.FINEST, PlatformLogger.FINER, PlatformLogger.FINE, PlatformLogger.CONFIG, PlatformLogger.INFO, PlatformLogger.WARNING, PlatformLogger.SEVERE, PlatformLogger.OFF }; public int intValue() { return levelValues[this.ordinal()]; } static Level valueOf(int level) { switch (level) { // ordering per the highest occurrences in the jdk source // finest, fine, finer, info first case PlatformLogger.FINEST : return Level.FINEST; case PlatformLogger.FINE : return Level.FINE; case PlatformLogger.FINER : return Level.FINER; case PlatformLogger.INFO : return Level.INFO; case PlatformLogger.WARNING : return Level.WARNING; case PlatformLogger.CONFIG : return Level.CONFIG; case PlatformLogger.SEVERE : return Level.SEVERE; case PlatformLogger.OFF : return Level.OFF; case PlatformLogger.ALL : return Level.ALL; } // return the nearest Level value >= the given level, // for level > SEVERE, return SEVERE and exclude OFF int i = Arrays.binarySearch(levelValues, 0, levelValues.length-2, level); return values()[i >= 0 ? i : (-i-1)]; } } private static final Level DEFAULT_LEVEL = Level.INFO; private static boolean loggingEnabled; static { loggingEnabled = AccessController.doPrivileged( new PrivilegedAction<Boolean>() { public Boolean run() { String cname = System.getProperty("java.util.logging.config.class"); String fname = System.getProperty("java.util.logging.config.file"); return (cname != null || fname != null); } }); // force loading of all JavaLoggerProxy (sub)classes to make JIT de-optimizations // less probable. Don't initialize JavaLoggerProxy class since // java.util.logging may not be enabled. try { Class.forName("sun.util.logging.PlatformLogger$DefaultLoggerProxy", false, PlatformLogger.class.getClassLoader()); Class.forName("sun.util.logging.PlatformLogger$JavaLoggerProxy", false, // do not invoke class initializer PlatformLogger.class.getClassLoader()); } catch (ClassNotFoundException ex) { throw new InternalError(ex.getMessage()); } } // Table of known loggers. Maps names to PlatformLoggers. private static Map<String,WeakReference<PlatformLogger>> loggers = new HashMap<>();
Returns a PlatformLogger of a given name.
/** * Returns a PlatformLogger of a given name. */
public static synchronized PlatformLogger getLogger(String name) { PlatformLogger log = null; WeakReference<PlatformLogger> ref = loggers.get(name); if (ref != null) { log = ref.get(); } if (log == null) { log = new PlatformLogger(name); loggers.put(name, new WeakReference<>(log)); } return log; }
Initialize java.util.logging.Logger objects for all platform loggers. This method is called from LogManager.readPrimordialConfiguration().
/** * Initialize java.util.logging.Logger objects for all platform loggers. * This method is called from LogManager.readPrimordialConfiguration(). */
public static synchronized void redirectPlatformLoggers() { if (loggingEnabled || !LoggingSupport.isAvailable()) return; loggingEnabled = true; for (Map.Entry<String, WeakReference<PlatformLogger>> entry : loggers.entrySet()) { WeakReference<PlatformLogger> ref = entry.getValue(); PlatformLogger plog = ref.get(); if (plog != null) { plog.redirectToJavaLoggerProxy(); } } }
Creates a new JavaLoggerProxy and redirects the platform logger to it
/** * Creates a new JavaLoggerProxy and redirects the platform logger to it */
private void redirectToJavaLoggerProxy() { DefaultLoggerProxy lp = DefaultLoggerProxy.class.cast(this.loggerProxy); JavaLoggerProxy jlp = new JavaLoggerProxy(lp.name, lp.level); // the order of assignments is important this.javaLoggerProxy = jlp; // isLoggable checks javaLoggerProxy if set this.loggerProxy = jlp; } // DefaultLoggerProxy may be replaced with a JavaLoggerProxy object // when the java.util.logging facility is enabled private volatile LoggerProxy loggerProxy; // javaLoggerProxy is only set when the java.util.logging facility is enabled private volatile JavaLoggerProxy javaLoggerProxy; private PlatformLogger(String name) { if (loggingEnabled) { this.loggerProxy = this.javaLoggerProxy = new JavaLoggerProxy(name); } else { this.loggerProxy = new DefaultLoggerProxy(name); } }
A convenience method to test if the logger is turned off. (i.e. its level is OFF).
/** * A convenience method to test if the logger is turned off. * (i.e. its level is OFF). */
public boolean isEnabled() { return loggerProxy.isEnabled(); }
Gets the name for this platform logger.
/** * Gets the name for this platform logger. */
public String getName() { return loggerProxy.name; }
Returns true if a message of the given level would actually be logged by this logger.
Deprecated:Use isLoggable(Level) instead.
/** * Returns true if a message of the given level would actually * be logged by this logger. * * @deprecated Use isLoggable(Level) instead. */
@Deprecated public boolean isLoggable(int levelValue) { return isLoggable(Level.valueOf(levelValue)); }
Gets the current log level. Returns 0 if the current effective level is not set (equivalent to Logger.getLevel() returns null).
Deprecated:Use level() instead
/** * Gets the current log level. Returns 0 if the current effective level is * not set (equivalent to Logger.getLevel() returns null). * * @deprecated Use level() instead */
@Deprecated public int getLevel() { Level level = loggerProxy.getLevel(); return level != null ? level.intValue() : 0; }
Sets the log level.
Deprecated:Use setLevel(Level) instead
/** * Sets the log level. * * @deprecated Use setLevel(Level) instead */
@Deprecated public void setLevel(int newLevel) { loggerProxy.setLevel(newLevel == 0 ? null : Level.valueOf(newLevel)); }
Returns true if a message of the given level would actually be logged by this logger.
/** * Returns true if a message of the given level would actually * be logged by this logger. */
public boolean isLoggable(Level level) { if (level == null) { throw new NullPointerException(); } // performance-sensitive method: use two monomorphic call-sites JavaLoggerProxy jlp = javaLoggerProxy; return jlp != null ? jlp.isLoggable(level) : loggerProxy.isLoggable(level); }
Get the log level that has been specified for this PlatformLogger. The result may be null, which means that this logger's effective level will be inherited from its parent.
Returns: this PlatformLogger's level
/** * Get the log level that has been specified for this PlatformLogger. * The result may be null, which means that this logger's * effective level will be inherited from its parent. * * @return this PlatformLogger's level */
public Level level() { return loggerProxy.getLevel(); }
Set the log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded. The level value OFF can be used to turn off logging.

If the new level is null, it means that this node should inherit its level from its nearest ancestor with a specific (non-null) level value.

Params:
  • newLevel – the new value for the log level (may be null)
/** * Set the log level specifying which message levels will be * logged by this logger. Message levels lower than this * value will be discarded. The level value {@link #OFF} * can be used to turn off logging. * <p> * If the new level is null, it means that this node should * inherit its level from its nearest ancestor with a specific * (non-null) level value. * * @param newLevel the new value for the log level (may be null) */
public void setLevel(Level newLevel) { loggerProxy.setLevel(newLevel); }
Logs a SEVERE message.
/** * Logs a SEVERE message. */
public void severe(String msg) { loggerProxy.doLog(Level.SEVERE, msg); } public void severe(String msg, Throwable t) { loggerProxy.doLog(Level.SEVERE, msg, t); } public void severe(String msg, Object... params) { loggerProxy.doLog(Level.SEVERE, msg, params); }
Logs a WARNING message.
/** * Logs a WARNING message. */
public void warning(String msg) { loggerProxy.doLog(Level.WARNING, msg); } public void warning(String msg, Throwable t) { loggerProxy.doLog(Level.WARNING, msg, t); } public void warning(String msg, Object... params) { loggerProxy.doLog(Level.WARNING, msg, params); }
Logs an INFO message.
/** * Logs an INFO message. */
public void info(String msg) { loggerProxy.doLog(Level.INFO, msg); } public void info(String msg, Throwable t) { loggerProxy.doLog(Level.INFO, msg, t); } public void info(String msg, Object... params) { loggerProxy.doLog(Level.INFO, msg, params); }
Logs a CONFIG message.
/** * Logs a CONFIG message. */
public void config(String msg) { loggerProxy.doLog(Level.CONFIG, msg); } public void config(String msg, Throwable t) { loggerProxy.doLog(Level.CONFIG, msg, t); } public void config(String msg, Object... params) { loggerProxy.doLog(Level.CONFIG, msg, params); }
Logs a FINE message.
/** * Logs a FINE message. */
public void fine(String msg) { loggerProxy.doLog(Level.FINE, msg); } public void fine(String msg, Throwable t) { loggerProxy.doLog(Level.FINE, msg, t); } public void fine(String msg, Object... params) { loggerProxy.doLog(Level.FINE, msg, params); }
Logs a FINER message.
/** * Logs a FINER message. */
public void finer(String msg) { loggerProxy.doLog(Level.FINER, msg); } public void finer(String msg, Throwable t) { loggerProxy.doLog(Level.FINER, msg, t); } public void finer(String msg, Object... params) { loggerProxy.doLog(Level.FINER, msg, params); }
Logs a FINEST message.
/** * Logs a FINEST message. */
public void finest(String msg) { loggerProxy.doLog(Level.FINEST, msg); } public void finest(String msg, Throwable t) { loggerProxy.doLog(Level.FINEST, msg, t); } public void finest(String msg, Object... params) { loggerProxy.doLog(Level.FINEST, msg, params); }
Abstract base class for logging support, defining the API and common field.
/** * Abstract base class for logging support, defining the API and common field. */
private static abstract class LoggerProxy { final String name; protected LoggerProxy(String name) { this.name = name; } abstract boolean isEnabled(); abstract Level getLevel(); abstract void setLevel(Level newLevel); abstract void doLog(Level level, String msg); abstract void doLog(Level level, String msg, Throwable thrown); abstract void doLog(Level level, String msg, Object... params); abstract boolean isLoggable(Level level); } private static final class DefaultLoggerProxy extends LoggerProxy {
Default platform logging support - output messages to System.err - equivalent to ConsoleHandler with SimpleFormatter.
/** * Default platform logging support - output messages to System.err - * equivalent to ConsoleHandler with SimpleFormatter. */
private static PrintStream outputStream() { return System.err; } volatile Level effectiveLevel; // effective level (never null) volatile Level level; // current level set for this node (may be null) DefaultLoggerProxy(String name) { super(name); this.effectiveLevel = deriveEffectiveLevel(null); this.level = null; } boolean isEnabled() { return effectiveLevel != Level.OFF; } Level getLevel() { return level; } void setLevel(Level newLevel) { Level oldLevel = level; if (oldLevel != newLevel) { level = newLevel; effectiveLevel = deriveEffectiveLevel(newLevel); } } void doLog(Level level, String msg) { if (isLoggable(level)) { outputStream().print(format(level, msg, null)); } } void doLog(Level level, String msg, Throwable thrown) { if (isLoggable(level)) { outputStream().print(format(level, msg, thrown)); } } void doLog(Level level, String msg, Object... params) { if (isLoggable(level)) { String newMsg = formatMessage(msg, params); outputStream().print(format(level, newMsg, null)); } } boolean isLoggable(Level level) { Level effectiveLevel = this.effectiveLevel; return level.intValue() >= effectiveLevel.intValue() && effectiveLevel != Level.OFF; } // derive effective level (could do inheritance search like j.u.l.Logger) private Level deriveEffectiveLevel(Level level) { return level == null ? DEFAULT_LEVEL : level; } // Copied from java.util.logging.Formatter.formatMessage private String formatMessage(String format, Object... parameters) { // Do the formatting. try { if (parameters == null || parameters.length == 0) { // No parameters. Just return format string. return format; } // Is it a java.text style format? // Ideally we could match with // Pattern.compile("\\{\\d").matcher(format).find()) // However the cost is 14% higher, so we cheaply check for // 1 of the first 4 parameters if (format.indexOf("{0") >= 0 || format.indexOf("{1") >=0 || format.indexOf("{2") >=0|| format.indexOf("{3") >=0) { return java.text.MessageFormat.format(format, parameters); } return format; } catch (Exception ex) { // Formatting failed: use format string. return format; } } private static final String formatString = LoggingSupport.getSimpleFormat(false); // don't check logging.properties // minimize memory allocation private Date date = new Date(); private synchronized String format(Level level, String msg, Throwable thrown) { date.setTime(System.currentTimeMillis()); String throwable = ""; if (thrown != null) { StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); pw.println(); thrown.printStackTrace(pw); pw.close(); throwable = sw.toString(); } return String.format(formatString, date, getCallerInfo(), name, level.name(), msg, throwable); } // Returns the caller's class and method's name; best effort // if cannot infer, return the logger's name. private String getCallerInfo() { String sourceClassName = null; String sourceMethodName = null; JavaLangAccess access = SharedSecrets.getJavaLangAccess(); Throwable throwable = new Throwable(); int depth = access.getStackTraceDepth(throwable); String logClassName = "sun.util.logging.PlatformLogger"; boolean lookingForLogger = true; for (int ix = 0; ix < depth; ix++) { // Calling getStackTraceElement directly prevents the VM // from paying the cost of building the entire stack frame. StackTraceElement frame = access.getStackTraceElement(throwable, ix); String cname = frame.getClassName(); if (lookingForLogger) { // Skip all frames until we have found the first logger frame. if (cname.equals(logClassName)) { lookingForLogger = false; } } else { if (!cname.equals(logClassName)) { // We've found the relevant frame. sourceClassName = cname; sourceMethodName = frame.getMethodName(); break; } } } if (sourceClassName != null) { return sourceClassName + " " + sourceMethodName; } else { return name; } } }
JavaLoggerProxy forwards all the calls to its corresponding java.util.logging.Logger object.
/** * JavaLoggerProxy forwards all the calls to its corresponding * java.util.logging.Logger object. */
private static final class JavaLoggerProxy extends LoggerProxy { // initialize javaLevel fields for mapping from Level enum -> j.u.l.Level object static { for (Level level : Level.values()) { level.javaLevel = LoggingSupport.parseLevel(level.name()); } } private final /* java.util.logging.Logger */ Object javaLogger; JavaLoggerProxy(String name) { this(name, null); } JavaLoggerProxy(String name, Level level) { super(name); this.javaLogger = LoggingSupport.getLogger(name); if (level != null) { // level has been updated and so set the Logger's level LoggingSupport.setLevel(javaLogger, level.javaLevel); } } void doLog(Level level, String msg) { LoggingSupport.log(javaLogger, level.javaLevel, msg); } void doLog(Level level, String msg, Throwable t) { LoggingSupport.log(javaLogger, level.javaLevel, msg, t); } void doLog(Level level, String msg, Object... params) { if (!isLoggable(level)) { return; } // only pass String objects to the j.u.l.Logger which may // be created by untrusted code int len = (params != null) ? params.length : 0; Object[] sparams = new String[len]; for (int i = 0; i < len; i++) { sparams [i] = String.valueOf(params[i]); } LoggingSupport.log(javaLogger, level.javaLevel, msg, sparams); } boolean isEnabled() { return LoggingSupport.isLoggable(javaLogger, Level.OFF.javaLevel); }
Returns the PlatformLogger.Level mapped from j.u.l.Level set in the logger. If the j.u.l.Logger is set to a custom Level, this method will return the nearest Level.
/** * Returns the PlatformLogger.Level mapped from j.u.l.Level * set in the logger. If the j.u.l.Logger is set to a custom Level, * this method will return the nearest Level. */
Level getLevel() { Object javaLevel = LoggingSupport.getLevel(javaLogger); if (javaLevel == null) return null; try { return Level.valueOf(LoggingSupport.getLevelName(javaLevel)); } catch (IllegalArgumentException e) { return Level.valueOf(LoggingSupport.getLevelValue(javaLevel)); } } void setLevel(Level level) { LoggingSupport.setLevel(javaLogger, level == null ? null : level.javaLevel); } boolean isLoggable(Level level) { return LoggingSupport.isLoggable(javaLogger, level.javaLevel); } } }