Back to index...

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

	import java.security.AccessController;
	import java.security.PrivilegedAction;
	import java.util.function.BiFunction;
	import java.lang.System.LoggerFinder;
	import java.lang.System.Logger;
	import java.lang.ref.WeakReference;
	import java.util.Objects;
	import jdk.internal.misc.VM;
	import sun.util.logging.PlatformLogger;

	/**
	* This class is a factory for Lazy Loggers; only system loggers can be
	* Lazy Loggers.
	*/
	public final class LazyLoggers {

	static final RuntimePermission LOGGERFINDER_PERMISSION =
	new RuntimePermission("loggerFinder");

	private LazyLoggers() {
	throw new InternalError();
	}

	/**
	* This class is used to hold the factories that a Lazy Logger will use
	* to create (or map) its wrapped logger.
	* @param <L> {@link Logger} or a subclass of {@link Logger}.
	*/
	private static final class LazyLoggerFactories<L extends Logger> {

	/**
	* A factory method to create an SPI logger.
	* Usually, this will be something like LazyLoggers::getSystemLogger.
	*/
	final BiFunction<String, Module, L> loggerSupplier;


	public LazyLoggerFactories(BiFunction<String, Module, L> loggerSupplier) {
	this(Objects.requireNonNull(loggerSupplier),
	(Void)null);
	}

	private LazyLoggerFactories(BiFunction<String, Module, L> loggerSupplier,
	Void unused) {
	this.loggerSupplier = loggerSupplier;
	}

	}

	static interface LoggerAccessor {
	/**
	* The logger name.
	* @return The name of the logger that is / will be lazily created.
	*/
	public String getLoggerName();

	/**
	* Returns the wrapped logger object.
	* @return the wrapped logger object.
	*/
	public Logger wrapped();

	/**
	* A PlatformLogger.Bridge view of the wrapped logger object.
	* @return A PlatformLogger.Bridge view of the wrapped logger object.
	*/
	public PlatformLogger.Bridge platform();
	}

	/**
	* The LazyLoggerAccessor class holds all the logic that delays the creation
	* of the SPI logger until such a time that the VM is booted and the logger
	* is actually used for logging.
	*
	* This class uses the services of the BootstrapLogger class to instantiate
	* temporary loggers if appropriate.
	*/
	static final class LazyLoggerAccessor implements LoggerAccessor {

	// The factories that will be used to create the logger lazyly
	final LazyLoggerFactories<? extends Logger> factories;

	// We need to pass the actual caller module when creating the logger.
	private final WeakReference<Module> moduleRef;

	// The name of the logger that will be created lazyly
	final String name;
	// The plain logger SPI object - null until it is accessed for the
	// first time.
	private volatile Logger w;
	// A PlatformLogger.Bridge view of w.
	private volatile PlatformLogger.Bridge p;


	private LazyLoggerAccessor(String name,
	LazyLoggerFactories<? extends Logger> factories,
	Module module) {
	this(Objects.requireNonNull(name), Objects.requireNonNull(factories),
	Objects.requireNonNull(module), null);
	}

	private LazyLoggerAccessor(String name,
	LazyLoggerFactories<? extends Logger> factories,
	Module module, Void unused) {
	this.name = name;
	this.factories = factories;
	this.moduleRef = new WeakReference<>(module);
	}

	/**
	* The logger name.
	* @return The name of the logger that is / will be lazily created.
	*/
	@Override
	public String getLoggerName() {
	return name;
	}

	// must be called in synchronized block
	// set wrapped logger if not set
	private void setWrappedIfNotSet(Logger wrapped) {
	if (w == null) {
	w = wrapped;
	}
	}

	/**
	* Returns the logger SPI object, creating it if 'w' is still null.
	* @return the logger SPI object.
	*/
	public Logger wrapped() {
	Logger wrapped = w;
	if (wrapped != null) return wrapped;
	// Wrapped logger not created yet: create it.
	// BootstrapLogger has the logic to decide whether to invoke the
	// SPI or use a temporary (BootstrapLogger or SimpleConsoleLogger)
	// logger.
	wrapped = BootstrapLogger.getLogger(this);
	synchronized(this) {
	// if w has already been in between, simply drop 'wrapped'.
	setWrappedIfNotSet(wrapped);
	return w;
	}
	}

	/**
	* A PlatformLogger.Bridge view of the wrapped logger.
	* @return A PlatformLogger.Bridge view of the wrapped logger.
	*/
	public PlatformLogger.Bridge platform() {
	// We can afford to return the platform view of the previous
	// logger - if that view is not null.
	// Because that view will either be the BootstrapLogger, which
	// will redirect to the new wrapper properly, or the temporary
	// logger - which in effect is equivalent to logging something
	// just before the application initialized LogManager.
	PlatformLogger.Bridge platform = p;
	if (platform != null) return platform;
	synchronized (this) {
	if (w != null) {
	if (p == null) p = PlatformLogger.Bridge.convert(w);
	return p;
	}
	}
	// If we reach here it means that the wrapped logger may not
	// have been created yet: attempt to create it.
	// BootstrapLogger has the logic to decide whether to invoke the
	// SPI or use a temporary (BootstrapLogger or SimpleConsoleLogger)
	// logger.
	final Logger wrapped = BootstrapLogger.getLogger(this);
	synchronized(this) {
	// if w has already been set, simply drop 'wrapped'.
	setWrappedIfNotSet(wrapped);
	if (p == null) p = PlatformLogger.Bridge.convert(w);
	return p;
	}
	}

	/**
	* Makes this accessor release a temporary logger.
	* This method is called
	* by BootstrapLogger when JUL is the default backend and LogManager
	* is initialized, in order to replace temporary SimpleConsoleLoggers by
	* real JUL loggers. See BootstrapLogger for more details.
	* If {@code replace} is {@code true}, then this method will force
	* the accessor to eagerly recreate its wrapped logger.
	* Note: passing {@code replace=false} is no guarantee that the
	* method will not actually replace the released logger.
	* @param temporary The temporary logger too be released.
	* @param replace Whether the released logger should be eagerly
	* replaced.
	*/
	void release(SimpleConsoleLogger temporary, boolean replace) {
	PlatformLogger.ConfigurableBridge.LoggerConfiguration conf =
	PlatformLogger.ConfigurableBridge.getLoggerConfiguration(temporary);
	PlatformLogger.Level level = conf != null
	? conf.getPlatformLevel()
	: null;
	synchronized (this) {
	if (this.w == temporary) {
	this.w = null; this.p = null;
	}
	}
	PlatformLogger.Bridge platform = replace \|\| level != null
	? this.platform() : null;

	if (level != null) {
	conf = (platform != null && platform != temporary)
	? PlatformLogger.ConfigurableBridge.getLoggerConfiguration(platform)
	: null;
	if (conf != null) conf.setPlatformLevel(level);
	}
	}

	/**
	* Replace 'w' by the real SPI logger and flush the log messages pending
	* in the temporary 'bootstrap' Logger. Called by BootstrapLogger when
	* this accessor's bootstrap logger is accessed and BootstrapLogger
	* notices that the VM is no longer booting.
	* @param bootstrap This accessor's bootstrap logger (usually this is 'w').
	*/
	Logger getConcreteLogger(BootstrapLogger bootstrap) {
	assert VM.isBooted();
	synchronized(this) {
	// another thread may have already invoked flush()
	if (this.w == bootstrap) {
	this.w = null; this.p = null;
	}
	}
	return this.wrapped();
	}

	PlatformLogger.Bridge getConcretePlatformLogger(BootstrapLogger bootstrap) {
	assert VM.isBooted();
	synchronized(this) {
	// another thread may have already invoked flush()
	if (this.w == bootstrap) {
	this.w = null; this.p = null;
	}
	}
	return this.platform();
	}

	// Creates the wrapped logger by invoking the SPI.
	Logger createLogger() {
	final Module module = moduleRef.get();
	if (module == null) {
	throw new IllegalStateException("The module for which this logger"
	+ " was created has been garbage collected");
	}
	return this.factories.loggerSupplier.apply(name, module);
	}

	/**
	* Creates a new lazy logger accessor for the named logger. The given
	* factories will be use when it becomes necessary to actually create
	* the logger.
	* @param <T> An interface that extends {@link Logger}.
	* @param name The logger name.
	* @param factories The factories that should be used to create the
	* wrapped logger.
	* @return A new LazyLoggerAccessor.
	*/
	public static LazyLoggerAccessor makeAccessor(String name,
	LazyLoggerFactories<? extends Logger> factories, Module module) {
	return new LazyLoggerAccessor(name, factories, module);
	}

	}

	/**
	* An implementation of {@link Logger} that redirects all calls to a wrapped
	* instance of {@code Logger}.
	*/
	private static class LazyLoggerWrapper
	extends AbstractLoggerWrapper<Logger> {

	final LoggerAccessor loggerAccessor;

	public LazyLoggerWrapper(LazyLoggerAccessor loggerSinkSupplier) {
	this(Objects.requireNonNull(loggerSinkSupplier), (Void)null);
	}

	private LazyLoggerWrapper(LazyLoggerAccessor loggerSinkSupplier,
	Void unused) {
	this.loggerAccessor = loggerSinkSupplier;
	}

	@Override
	final Logger wrapped() {
	return loggerAccessor.wrapped();
	}

	@Override
	PlatformLogger.Bridge platformProxy() {
	return loggerAccessor.platform();
	}

	}

	// Do not expose this outside of this package.
	private static volatile LoggerFinder provider;
	@SuppressWarnings("removal")
	private static LoggerFinder accessLoggerFinder() {
	LoggerFinder prov = provider;
	if (prov == null) {
	// no need to lock: it doesn't matter if we call
	// getLoggerFinder() twice - since LoggerFinder already caches
	// the result.
	// This is just an optimization to avoid the cost of calling
	// doPrivileged every time.
	final SecurityManager sm = System.getSecurityManager();
	prov = sm == null ? LoggerFinder.getLoggerFinder() :
	AccessController.doPrivileged(
	(PrivilegedAction<LoggerFinder>)LoggerFinder::getLoggerFinder);
	provider = prov;
	}
	return prov;
	}

	// Avoid using lambda here as lazy loggers could be created early
	// in the bootstrap sequence...
	private static final BiFunction<String, Module, Logger> loggerSupplier =
	new BiFunction<>() {
	@Override
	public Logger apply(String name, Module module) {
	return LazyLoggers.getLoggerFromFinder(name, module);
	}
	};

	private static final LazyLoggerFactories<Logger> factories =
	new LazyLoggerFactories<>(loggerSupplier);



	// A concrete implementation of Logger that delegates to a System.Logger,
	// but only creates the System.Logger instance lazily when it's used for
	// the first time.
	// The JdkLazyLogger uses a LazyLoggerAccessor objects, which relies
	// on the logic embedded in BootstrapLogger to avoid loading the concrete
	// logger provider until the VM has finished booting.
	//
	private static final class JdkLazyLogger extends LazyLoggerWrapper {
	JdkLazyLogger(String name, Module module) {
	this(LazyLoggerAccessor.makeAccessor(name, factories, module),
	(Void)null);
	}
	private JdkLazyLogger(LazyLoggerAccessor holder, Void unused) {
	super(holder);
	}
	}

	/**
	* Gets a logger from the LoggerFinder. Creates the actual concrete
	* logger.
	* @param name name of the logger
	* @param module module on behalf of which the logger is created
	* @return The logger returned by the LoggerFinder.
	*/
	@SuppressWarnings("removal")
	static Logger getLoggerFromFinder(String name, Module module) {
	final SecurityManager sm = System.getSecurityManager();
	if (sm == null) {
	return accessLoggerFinder().getLogger(name, module);
	} else {
	return AccessController.doPrivileged((PrivilegedAction<Logger>)
	() -> {return accessLoggerFinder().getLogger(name, module);},
	null, LOGGERFINDER_PERMISSION);
	}
	}

	/**
	* Returns a (possibly lazy) Logger for the caller.
	*
	* @param name the logger name
	* @param module The module on behalf of which the logger is created.
	* If the module is not loaded from the Boot ClassLoader,
	* the LoggerFinder is accessed and the logger returned
	* by {@link LoggerFinder#getLogger(java.lang.String, java.lang.Module)}
	* is returned to the caller directly.
	* Otherwise, the logger returned by
	* {@link #getLazyLogger(java.lang.String, java.lang.Module)}
	* is returned to the caller.
	*
	* @return a (possibly lazy) Logger instance.
	*/
	public static final Logger getLogger(String name, Module module) {
	if (DefaultLoggerFinder.isSystem(module)) {
	return getLazyLogger(name, module);
	} else {
	return getLoggerFromFinder(name, module);
	}
	}

	/**
	* Returns a (possibly lazy) Logger suitable for system classes.
	* Whether the returned logger is lazy or not depend on the result
	* returned by {@link BootstrapLogger#useLazyLoggers()}.
	*
	* @param name the logger name
	* @param module the module on behalf of which the logger is created.
	* @return a (possibly lazy) Logger instance.
	*/
	public static final Logger getLazyLogger(String name, Module module) {

	// BootstrapLogger has the logic to determine whether a LazyLogger
	// should be used. Usually, it is worth it only if:
	// - the VM is not yet booted
	// - or, the backend is JUL and there is no configuration
	// - or, the backend is a custom backend, as we don't know what
	// that is going to load...
	// So if for instance the VM is booted and we use JUL with a custom
	// configuration, we're not going to delay the creation of loggers...
	final boolean useLazyLogger = BootstrapLogger.useLazyLoggers();
	if (useLazyLogger) {
	return new JdkLazyLogger(name, module);
	} else {
	// Directly invoke the LoggerFinder.
	return getLoggerFromFinder(name, module);
	}
	}

	}

Back to index...