Back to index...

	/*
	* Copyright (c) 2015, 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.internal;

	import java.security.AccessController;
	import java.security.PrivilegedAction;
	import java.util.ResourceBundle;
	import java.util.function.Supplier;
	import java.lang.System.LoggerFinder;
	import java.lang.System.Logger;
	import java.util.Objects;
	import java.util.logging.LogManager;
	import jdk.internal.logger.DefaultLoggerFinder;
	import java.util.logging.LoggingPermission;
	import sun.util.logging.PlatformLogger;
	import sun.util.logging.PlatformLogger.ConfigurableBridge.LoggerConfiguration;

	/**
	* This {@code LoggingProviderImpl} is the JDK internal implementation of the
	* {@link jdk.internal.logger.DefaultLoggerFinder} which is used by
	* the default implementation of the {@link Logger}
	* when no {@link LoggerFinder} is found
	* and {@code java.util.logging} is present.
	* When {@code java.util.logging} is present, the {@code LoggingProviderImpl}
	* is {@linkplain java.util.ServiceLoader#loadInstalled(Class) installed} as
	* an internal service provider, making it possible to use {@code java.util.logging}
	* as the backend for loggers returned by the default LoggerFinder implementation.
	* <p>
	* This implementation of {@link DefaultLoggerFinder} returns instances of
	* {@link java.lang.System.Logger} which
	* delegate to a wrapped instance of {@link java.util.logging.Logger
	* java.util.logging.Logger}.
	* <br>
	* Loggers returned by this class can therefore be configured by accessing
	* their wrapped implementation through the regular {@code java.util.logging}
	* APIs - such as {@link java.util.logging.LogManager java.util.logging.LogManager}
	* and {@link java.util.logging.Logger java.util.logging.Logger}.
	*
	* @apiNote Programmers are not expected to call this class directly.
	* Instead they should rely on the static methods defined by
	* {@link java.lang.System java.lang.System}.
	* <p>
	* To replace this default
	* {@code java.util.logging} backend, an application is expected to install
	* its own {@link java.lang.System.LoggerFinder}.
	*
	* @see java.lang.System.Logger
	* @see java.lang.System.LoggerFinder
	* @see sun.util.logging.PlatformLogger.Bridge
	* @see java.lang.System
	* @see jdk.internal.logger
	* @see jdk.internal.logger
	*
	*/
	public final class LoggingProviderImpl extends DefaultLoggerFinder {
	static final RuntimePermission LOGGERFINDER_PERMISSION =
	new RuntimePermission("loggerFinder");
	private static final LoggingPermission LOGGING_CONTROL_PERMISSION =
	new LoggingPermission("control", null);

	/**
	* Creates a new instance of LoggingProviderImpl.
	* @throws SecurityException if the calling code does not have the
	* {@code RuntimePermission("loggerFinder")}.
	*/
	public LoggingProviderImpl() {
	}

	/**
	* A logger that delegates to a java.util.logging.Logger delegate.
	*/
	static final class JULWrapper extends LoggerConfiguration
	implements System.Logger, PlatformLogger.Bridge,
	PlatformLogger.ConfigurableBridge {


	private static final java.util.logging.Level[] spi2JulLevelMapping = {
	java.util.logging.Level.ALL, // mapped from ALL
	java.util.logging.Level.FINER, // mapped from TRACE
	java.util.logging.Level.FINE, // mapped from DEBUG
	java.util.logging.Level.INFO, // mapped from INFO
	java.util.logging.Level.WARNING, // mapped from WARNING
	java.util.logging.Level.SEVERE, // mapped from ERROR
	java.util.logging.Level.OFF // mapped from OFF
	};

	private static final java.util.logging.Level[] platform2JulLevelMapping = {
	java.util.logging.Level.ALL, // mapped from ALL
	java.util.logging.Level.FINEST, // mapped from FINEST
	java.util.logging.Level.FINER, // mapped from FINER
	java.util.logging.Level.FINE, // mapped from FINE
	java.util.logging.Level.CONFIG, // mapped from CONFIG
	java.util.logging.Level.INFO, // mapped from INFO
	java.util.logging.Level.WARNING, // mapped from WARNING
	java.util.logging.Level.SEVERE, // mapped from SEVERE
	java.util.logging.Level.OFF // mapped from OFF
	};

	private final java.util.logging.Logger julLogger;


	private JULWrapper(java.util.logging.Logger logger) {
	this.julLogger = logger;
	}

	@Override
	public String getName() {
	return julLogger.getName();
	}
	@Override
	public void log(sun.util.logging.PlatformLogger.Level level, String msg, Throwable throwable) {
	julLogger.log(toJUL(level), msg, throwable);
	}

	@Override
	public void log(sun.util.logging.PlatformLogger.Level level, String format, Object... params) {
	julLogger.log(toJUL(level), format, params);
	}

	@Override
	public void log(sun.util.logging.PlatformLogger.Level level, String msg) {
	julLogger.log(toJUL(level), msg);
	}

	@Override
	public void log(sun.util.logging.PlatformLogger.Level level, Supplier<String> msgSuppier) {
	julLogger.log(toJUL(level), msgSuppier);
	}

	@Override
	public void log(sun.util.logging.PlatformLogger.Level level, Throwable thrown, Supplier<String> msgSuppier) {
	julLogger.log(toJUL(level), thrown, msgSuppier);
	}

	@Override
	public void logrb(sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle, String key, Throwable throwable) {
	julLogger.logrb(toJUL(level), bundle, key, throwable);
	}

	@Override
	public void logrb(sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle, String key, Object... params) {
	julLogger.logrb(toJUL(level), bundle, key, params);
	}

	@Override
	public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod, String msg) {
	julLogger.logp(toJUL(level), sourceClass, sourceMethod, msg);
	}

	@Override
	public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
	Supplier<String> msgSupplier) {
	julLogger.logp(toJUL(level), sourceClass, sourceMethod, msgSupplier);
	}

	@Override
	public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
	String msg, Object... params) {
	julLogger.logp(toJUL(level), sourceClass, sourceMethod, msg, params);
	}

	@Override
	public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
	String msg, Throwable thrown) {
	julLogger.logp(toJUL(level), sourceClass, sourceMethod, msg, thrown);
	}

	@Override
	public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
	Throwable thrown, Supplier<String> msgSupplier) {
	julLogger.logp(toJUL(level), sourceClass, sourceMethod,
	thrown, msgSupplier);
	}

	@Override
	public void logrb(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
	ResourceBundle bundle, String key, Object... params) {
	julLogger.logrb(toJUL(level), sourceClass, sourceMethod,
	bundle, key, params);
	}

	@Override
	public void logrb(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,
	ResourceBundle bundle, String key, Throwable thrown) {
	julLogger.logrb(toJUL(level), sourceClass, sourceMethod,
	bundle, key, thrown);
	}

	@Override
	public boolean isLoggable(sun.util.logging.PlatformLogger.Level level) {
	return julLogger.isLoggable(toJUL(level));
	}

	// -----------------------------------------------------------------
	// Generic methods taking a Level as parameter
	// -----------------------------------------------------------------


	@Override
	public boolean isLoggable(Level level) {
	return julLogger.isLoggable(toJUL(level));
	}

	@Override
	public void log(Level level, String msg) {
	julLogger.log(toJUL(level), msg);
	}

	@Override
	public void log(Level level,
	Supplier<String> msgSupplier) {
	// We need to check for null here to satisfy the contract
	// of System.Logger - because the underlying implementation
	// of julLogger will check for it only if the level is
	// loggable
	Objects.requireNonNull(msgSupplier);
	julLogger.log(toJUL(level), msgSupplier);
	}

	@Override
	public void log(Level level, Object obj) {
	// We need to check for null here to satisfy the contract
	// of System.Logger - because the underlying implementation
	// of julLogger will check for it only if the level is
	// loggable
	Objects.requireNonNull(obj);
	julLogger.log(toJUL(level), () -> obj.toString());
	}

	@Override
	public void log(Level level,
	String msg, Throwable thrown) {
	julLogger.log(toJUL(level), msg, thrown);
	}

	@Override
	public void log(Level level, Supplier<String> msgSupplier,
	Throwable thrown) {
	// We need to check for null here to satisfy the contract
	// of System.Logger - because the underlying implementation
	// of julLogger will check for it only if the level is
	// loggable
	Objects.requireNonNull(msgSupplier);
	julLogger.log(toJUL(level), thrown, msgSupplier);
	}

	@Override
	public void log(Level level,
	String format, Object... params) {
	julLogger.log(toJUL(level), format, params);
	}

	@Override
	public void log(Level level, ResourceBundle bundle,
	String key, Throwable thrown) {
	julLogger.logrb(toJUL(level), bundle, key, thrown);
	}

	@Override
	public void log(Level level, ResourceBundle bundle,
	String format, Object... params) {
	julLogger.logrb(toJUL(level), bundle, format, params);
	}

	static java.util.logging.Level toJUL(Level level) {
	if (level == null) return null;
	assert level.ordinal() < spi2JulLevelMapping.length;
	return spi2JulLevelMapping[level.ordinal()];
	}

	// ---------------------------------------------------------
	// Methods from PlatformLogger.Bridge
	// ---------------------------------------------------------

	@Override
	public boolean isEnabled() {
	return julLogger.getLevel() != java.util.logging.Level.OFF;
	}

	@Override
	public PlatformLogger.Level getPlatformLevel() {
	final java.util.logging.Level javaLevel = julLogger.getLevel();
	if (javaLevel == null) return null;
	try {
	return PlatformLogger.Level.valueOf(javaLevel.getName());
	} catch (IllegalArgumentException e) {
	return PlatformLogger.Level.valueOf(javaLevel.intValue());
	}
	}

	@Override
	public void setPlatformLevel(PlatformLogger.Level level) {
	// null is allowed here
	julLogger.setLevel(toJUL(level));
	}

	@Override
	public LoggerConfiguration getLoggerConfiguration() {
	return this;
	}

	static java.util.logging.Level toJUL(PlatformLogger.Level level) {
	// The caller will throw if null is invalid in its context.
	// There's at least one case where a null level is valid.
	if (level == null) return null;
	assert level.ordinal() < platform2JulLevelMapping.length;
	return platform2JulLevelMapping[level.ordinal()];
	}

	@Override
	public boolean equals(Object obj) {
	return (obj instanceof JULWrapper)
	&& obj.getClass() == this.getClass()
	&& ((JULWrapper)obj).julLogger == this.julLogger;
	}

	@Override
	public int hashCode() {
	return julLogger.hashCode();
	}

	// A JULWrapper is just a stateless thin shell over a JUL logger - so
	// for a given JUL logger, we could always return the same wrapper.
	//
	// This is an optimization which may - or may not - be worth the
	// trouble: if many classes use the same logger, and if each class
	// keeps a reference to that logger, then caching the wrapper will
	// be worthwhile. Otherwise, if each logger is only referred once,
	// then the cache will eat up more memory than would be necessary...
	//
	// Here is an example of how we could implement JULWrapper.of(...)
	// if we wanted to create at most one wrapper instance for each logger
	// instance:
	//
	// static final WeakHashMap<JULWrapper, WeakReference<JULWrapper>>
	// wrappers = new WeakHashMap<>();
	//
	// static JULWrapper of(java.util.logging.Logger logger) {
	//
	// // First access without synchronizing
	// final JULWrapper candidate = new JULWrapper(logger);
	// WeakReference<JULWrapper> ref = wrappers.get(candidate);
	// JULWrapper found = ref.get();
	//
	// // OK - we found it - lets return it.
	// if (found != null) return found;
	//
	// // Not found. Need to synchronize.
	// synchronized (wrappers) {
	// ref = wrappers.get(candidate);
	// found = ref.get();
	// if (found == null) {
	// wrappers.put(candidate, new WeakReference<>(candidate));
	// found = candidate;
	// }
	// }
	// assert found != null;
	// return found;
	// }
	//
	// But given that it may end up eating more memory in the nominal case
	// (where each class that does logging has its own logger with the
	// class name as logger name and stashes that logger away in a static
	// field, thus making the cache redundant - as only one wrapper will
	// ever be created anyway) - then we will simply return a new wrapper
	// for each invocation of JULWrapper.of(...) - which may
	// still prove more efficient in terms of memory consumption...
	//
	static JULWrapper of(java.util.logging.Logger logger) {
	return new JULWrapper(logger);
	}


	}

	/**
	* Creates a java.util.logging.Logger for the given module.
	* @param name the logger name.
	* @param module the module for which the logger should be created.
	* @return a Logger suitable for use in the given module.
	*/
	private static java.util.logging.Logger demandJULLoggerFor(final String name,
	Module module) {
	final LogManager manager = LogManager.getLogManager();
	final SecurityManager sm = System.getSecurityManager();
	if (sm == null) {
	return logManagerAccess.demandLoggerFor(manager, name, module);
	} else {
	final PrivilegedAction<java.util.logging.Logger> pa =
	() -> logManagerAccess.demandLoggerFor(manager, name, module);
	return AccessController.doPrivileged(pa, null, LOGGING_CONTROL_PERMISSION);
	}
	}

	/**
	* {@inheritDoc}
	*
	* @apiNote The logger returned by this method can be configured through
	* its {@linkplain java.util.logging.LogManager#getLogger(String)
	* corresponding java.util.logging.Logger backend}.
	*
	* @return {@inheritDoc}
	* @throws SecurityException if the calling code doesn't have the
	* {@code RuntimePermission("loggerFinder")}.
	*/
	@Override
	protected Logger demandLoggerFor(String name, Module module) {
	final SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
	sm.checkPermission(LOGGERFINDER_PERMISSION);
	}
	return JULWrapper.of(demandJULLoggerFor(name,module));
	}

	public static interface LogManagerAccess {
	java.util.logging.Logger demandLoggerFor(LogManager manager,
	String name, Module module);
	}

	// Hook for tests
	public static LogManagerAccess getLogManagerAccess() {
	final SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
	sm.checkPermission(LOGGING_CONTROL_PERMISSION);
	}
	// Triggers initialization of accessJulLogger if not set.
	if (logManagerAccess == null) LogManager.getLogManager();
	return logManagerAccess;
	}


	private static volatile LogManagerAccess logManagerAccess;
	public static void setLogManagerAccess(LogManagerAccess accesLoggers) {
	final SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
	sm.checkPermission(LOGGING_CONTROL_PERMISSION);
	}
	logManagerAccess = accesLoggers;
	}

	}

Back to index...