com.mycila.jdk.logging.ContextualLogManager Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jdk-logging-perwebapp Show documentation
Enables to use the JDK loggers in web applications with separate logging
There is a newer version: 1.2.ga
Show newest version
/**
 * Copyright (C) 2011 Mycila 
 *
 * Licensed 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 com.mycila.jdk.logging;

import java.beans.PropertyChangeListener;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Enumeration;
import java.util.IdentityHashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.Logger;

/**
 * Use: -Djava.util.logging.manager=com.mycila.jdk.logging.ContextualLogManager
 *
 * @author Mathieu Carbou
 */
public final class ContextualLogManager extends LogManager {

    private final Map logManagers = new IdentityHashMap();

    private static AtomicReference INSTANCE = new AtomicReference();
    private static final Field loggerManagerField;
    private static final Method initializeGlobalHandlers;
    private static final Method readPrimordialConfiguration;

    static {
        try {
            readPrimordialConfiguration = LogManager.class.getDeclaredMethod("readPrimordialConfiguration");
            readPrimordialConfiguration.setAccessible(true);
            initializeGlobalHandlers = LogManager.class.getDeclaredMethod("initializeGlobalHandlers");
            initializeGlobalHandlers.setAccessible(true);
            loggerManagerField = Logger.class.getDeclaredField("manager");
            loggerManagerField.setAccessible(true);
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    public ContextualLogManager() {
        if (!INSTANCE.compareAndSet(null, this)) {
            throw new IllegalStateException("A ContextualLogManager has already been initialized !");
        }
        System.out.println("=== Initializing " + ContextualLogManager.class.getSimpleName() + " ===");
    }

    public static boolean isAvailable() {
        return INSTANCE.get() != null;
    }

    public static ContextualLogManager get() {
        ContextualLogManager manager = INSTANCE.get();
        if (manager == null)
            throw new IllegalStateException("ContextualLogManager has not been initialized by JDK Logging system");
        return manager;
    }

    public LogManager getContextualLogManager() {
        ClassLoader webappClassLoader = Thread.currentThread().getContextClassLoader();
        return logManagers.get(webappClassLoader);
    }

    public void unregisterWebapp(ClassLoader webappClassLoader) {
        LogManager manager = logManagers.remove(webappClassLoader);
        if (manager != null) {
            manager.reset();
        }
    }

    public void registerWebapp(ClassLoader webappClassLoader) {
        final String name = webappClassLoader.toString();
        final LogManager perWebapp = new LogManager() {
            @Override
            public String toString() {
                return "LogManager for Webapp with classloader " + name;
            }
        };
        System.out.println("=== Creating " + perWebapp + " ===");
        try {
            Logger root = new Logger("", null) {
                {
                    try {
                        loggerManagerField.set(this, perWebapp);
                    } catch (IllegalAccessException e) {
                        throw new RuntimeException(e.getMessage(), e);
                    }
                    initializeGlobalHandlers.invoke(perWebapp);
                    setLevel(Level.INFO);
                }

                @Override
                public String toString() {
                    return "RootLogger for " + perWebapp;
                }
            };
            Field rootLoggerField = LogManager.class.getDeclaredField("rootLogger");
            rootLoggerField.setAccessible(true);
            rootLoggerField.set(perWebapp, root);
            perWebapp.addLogger(root);
            readPrimordialConfiguration.invoke(perWebapp);
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage(), e);
        }
        logManagers.put(webappClassLoader, perWebapp);
    }

    // DELEGATE METHODS

    @Override
    public boolean addLogger(Logger logger) {
        LogManager logManager = getContextualLogManager();
        if (logManager == null) {
            return super.addLogger(logger);
        } else {
            try {
                loggerManagerField.set(logger, logManager);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e.getMessage(), e);
            }
            return logManager.addLogger(logger);
        }
    }

    @Override
    public void addPropertyChangeListener(PropertyChangeListener l) throws SecurityException {
        LogManager logManager = getContextualLogManager();
        if (logManager == null) {
            super.addPropertyChangeListener(l);
        } else {
            logManager.addPropertyChangeListener(l);
        }
    }

    @Override
    public void checkAccess() throws SecurityException {
        LogManager logManager = getContextualLogManager();
        if (logManager == null) {
            super.checkAccess();
        } else {
            logManager.checkAccess();
        }
    }

    @Override
    public Logger getLogger(String name) {
        LogManager logManager = getContextualLogManager();
        if (logManager == null) {
            return super.getLogger(name);
        } else {
            return logManager.getLogger(name);
        }
    }

    @Override
    public Enumeration getLoggerNames() {
        LogManager logManager = getContextualLogManager();
        if (logManager == null) {
            return super.getLoggerNames();
        } else {
            return logManager.getLoggerNames();
        }
    }

    @Override
    public String getProperty(String name) {
        LogManager logManager = getContextualLogManager();
        if (logManager == null) {
            return super.getProperty(name);
        } else {
            return logManager.getProperty(name);
        }
    }

    @Override
    public void readConfiguration() throws IOException, SecurityException {
        LogManager logManager = getContextualLogManager();
        if (logManager == null) {
            super.readConfiguration();
        } else {
            logManager.readConfiguration();
        }
    }

    @Override
    public void readConfiguration(InputStream ins) throws IOException, SecurityException {
        LogManager logManager = getContextualLogManager();
        if (logManager == null) {
            super.readConfiguration(ins);
        } else {
            logManager.readConfiguration(ins);
        }
    }

    @Override
    public void removePropertyChangeListener(PropertyChangeListener l) throws SecurityException {
        LogManager logManager = getContextualLogManager();
        if (logManager == null) {
            super.removePropertyChangeListener(l);
        } else {
            logManager.removePropertyChangeListener(l);
        }
    }

    @Override
    public void reset() throws SecurityException {
        LogManager logManager = getContextualLogManager();
        if (logManager == null) {
            super.reset();
        } else {
            logManager.reset();
        }
    }

}