org.apache.logging.log4j.spi.LoggerRegistry Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of apm-agent Show documentation
There is a newer version: 1.36.0
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache license, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the license for the specific language governing permissions and
 * limitations under the license.
 */
package org.apache.logging.log4j.spi;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import java.util.Objects;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.apache.logging.log4j.message.MessageFactory;

/**
 * Convenience class to be used by {@code LoggerContext} implementations.
 */
public class LoggerRegistry {
    private static final String DEFAULT_FACTORY_KEY = AbstractLogger.DEFAULT_MESSAGE_FACTORY_CLASS.getName();
    private final MapFactory factory;
    private final Map> map;

    /**
     * Interface to control the data structure used by the registry to store the Loggers.
     * @param  subtype of {@code ExtendedLogger}
     */
    public interface MapFactory {
        Map createInnerMap();

        Map> createOuterMap();

        void putIfAbsent(Map innerMap, String name, T logger);
    }

    /**
     * Generates ConcurrentHashMaps for use by the registry to store the Loggers.
     * @param  subtype of {@code ExtendedLogger}
     */
    public static class ConcurrentMapFactory implements MapFactory {
        @Override
        public Map createInnerMap() {
            return new ConcurrentHashMap<>();
        }

        @Override
        public Map> createOuterMap() {
            return new ConcurrentHashMap<>();
        }

        @Override
        public void putIfAbsent(final Map innerMap, final String name, final T logger) {
            ((ConcurrentMap) innerMap).putIfAbsent(name, logger);
        }
    }

    /**
     * Generates WeakHashMaps for use by the registry to store the Loggers.
     * @param  subtype of {@code ExtendedLogger}
     */
    public static class WeakMapFactory implements MapFactory {
        @Override
        public Map createInnerMap() {
            return new WeakHashMap<>();
        }

        @Override
        public Map> createOuterMap() {
            return new WeakHashMap<>();
        }

        @Override
        public void putIfAbsent(final Map innerMap, final String name, final T logger) {
            innerMap.put(name, logger);
        }
    }

    public LoggerRegistry() {
        this(new ConcurrentMapFactory());
    }

    public LoggerRegistry(final MapFactory factory) {
        this.factory = Objects.requireNonNull(factory, "factory");
        this.map = factory.createOuterMap();
    }

    private static String factoryClassKey(final Class messageFactoryClass) {
        return messageFactoryClass == null ? DEFAULT_FACTORY_KEY : messageFactoryClass.getName();
    }

    private static String factoryKey(final MessageFactory messageFactory) {
        return messageFactory == null ? DEFAULT_FACTORY_KEY : messageFactory.getClass().getName();
    }

    /**
     * Returns an ExtendedLogger.
     * @param name The name of the Logger to return.
     * @return The logger with the specified name.
     */
    public T getLogger(final String name) {
        return getOrCreateInnerMap(DEFAULT_FACTORY_KEY).get(name);
    }

    /**
     * Returns an ExtendedLogger.
     * @param name The name of the Logger to return.
     * @param messageFactory The message factory is used only when creating a logger, subsequent use does not change
     *                       the logger but will log a warning if mismatched.
     * @return The logger with the specified name.
     */
    public T getLogger(final String name, final MessageFactory messageFactory) {
        return getOrCreateInnerMap(factoryKey(messageFactory)).get(name);
    }

    public Collection getLoggers() {
        return getLoggers(new ArrayList());
    }

    public Collection getLoggers(final Collection destination) {
        for (final Map inner : map.values()) {
            destination.addAll(inner.values());
        }
        return destination;
    }

    private Map getOrCreateInnerMap(final String factoryName) {
        Map inner = map.get(factoryName);
        if (inner == null) {
            inner = factory.createInnerMap();
            map.put(factoryName, inner);
        }
        return inner;
    }

    /**
     * Detects if a Logger with the specified name exists.
     * @param name The Logger name to search for.
     * @return true if the Logger exists, false otherwise.
     */
    public boolean hasLogger(final String name) {
        return getOrCreateInnerMap(DEFAULT_FACTORY_KEY).containsKey(name);
    }

    /**
     * Detects if a Logger with the specified name and MessageFactory exists.
     * @param name The Logger name to search for.
     * @param messageFactory The message factory to search for.
     * @return true if the Logger exists, false otherwise.
     * @since 2.5
     */
    public boolean hasLogger(final String name, final MessageFactory messageFactory) {
        return getOrCreateInnerMap(factoryKey(messageFactory)).containsKey(name);
    }

    /**
     * Detects if a Logger with the specified name and MessageFactory type exists.
     * @param name The Logger name to search for.
     * @param messageFactoryClass The message factory class to search for.
     * @return true if the Logger exists, false otherwise.
     * @since 2.5
     */
    public boolean hasLogger(final String name, final Class messageFactoryClass) {
        return getOrCreateInnerMap(factoryClassKey(messageFactoryClass)).containsKey(name);
    }

    public void putIfAbsent(final String name, final MessageFactory messageFactory, final T logger) {
        factory.putIfAbsent(getOrCreateInnerMap(factoryKey(messageFactory)), name, logger);
    }
}