org.jitsi.utils.logging2.LoggerImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jitsi-utils Show documentation
A set of basic utilities used in Jitsi projects
There is a newer version: 1.0-133-g6af1020
/*
 * Copyright @ 2018 - present 8x8, Inc.
 *
 * 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 org.jitsi.utils.logging2;

import java.util.*;
import java.util.function.*;
import java.util.logging.*;

/**
 * Implements {@link Logger} by delegating to
 * a {@link java.util.logging.Logger}.
 */
public class LoggerImpl implements Logger
{
    private final java.util.logging.Logger loggerDelegate;

    /**
     * The 'minimum' level a log statement must be to be logged by this Logger. For example, if this
     * is set to {@link Level#WARNING}, then only log statements at the warning level or above
     * will actually be logged.
     */
    private final Level minLogLevel;

    private final LogContext logContext;

    public LoggerImpl(String name)
    {
        this(name, Level.ALL);
    }

    public LoggerImpl(String name, Level minLogLevel)
    {
        this(name, minLogLevel, new LogContext());
    }

    public LoggerImpl(String name, LogContext logContext)
    {
        this(name, Level.ALL, logContext);
    }

    public LoggerImpl(String name, Level minLogLevel, LogContext logContext)
    {
        this.loggerDelegate = LoggerImpl.loggerFactory.apply(name);
        this.minLogLevel = minLogLevel;
        this.logContext = logContext;
    }

    /**
     * Create a new logger with the given name.  The resulting logger's {@link LogContext}
     * will be the result of merging the given {@link LogContext} with this logger's
     * {@link LogContext}.
     *
     * @param name
     * @param context
     * @return
     */
    @Override
    public Logger createChildLogger(String name, Map context)
    {
        return new LoggerImpl(name, minLogLevel, this.logContext.createSubContext(context));
    }

    @Override
    public Logger createChildLogger(String name)
    {
        // Note that we still need to create a subcontext here for the log
        // context, otherwise if other values are added later they'll affect
        // the parent's log context as well.
        return new LoggerImpl(name, minLogLevel, this.logContext.createSubContext(Collections.emptyMap()));
    }

    @Override
    public void setUseParentHandlers(boolean useParentHandlers)
    {
        loggerDelegate.setUseParentHandlers(false);
    }

    @Override
    public void addHandler(Handler handler) throws SecurityException
    {
        loggerDelegate.addHandler(handler);
    }

    @Override
    public void removeHandler(Handler handler) throws SecurityException
    {
        loggerDelegate.removeHandler(handler);
    }
    
    private boolean isLoggable(Level level)
    {
        return level.intValue() >= minLogLevel.intValue() && loggerDelegate.isLoggable(level);
    }

    private void log(Level level, Object msg, Throwable thrown)
    {
        if (!isLoggable(level))
        {
            return;
        }
        LogRecord lr = new ContextLogRecord(level, msg.toString(), logContext.getFormattedContext());
        lr.setThrown(thrown);
        lr.setLoggerName(this.loggerDelegate.getName());
        loggerDelegate.log(lr);
    }

    private void log(Level level, Object msg)
    {
        if (!isLoggable(level))
        {
            return;
        }
        LogRecord lr = new ContextLogRecord(level, msg.toString(), logContext.getFormattedContext());
        lr.setLoggerName(this.loggerDelegate.getName());
        loggerDelegate.log(lr);
    }

    private void log(Level level, Supplier msgSupplier)
    {
        if (!isLoggable(level))
        {
            return;
        }
        LogRecord lr = new ContextLogRecord(level, msgSupplier.get(), logContext.getFormattedContext());
        lr.setLoggerName(this.loggerDelegate.getName());
        loggerDelegate.log(lr);
    }

    @Override
    public void setLevel(Level level)
    {
        Handler[] handlers = loggerDelegate.getHandlers();
        for (Handler handler : handlers)
            handler.setLevel(level);

        loggerDelegate.setLevel(level);
    }

    @Override
    public Level getLevel()
    {
        // OpenJDK's Logger implementation initializes its effective level value
        // with Level.INFO.intValue(), but DOESN'T initialize the Level object.
        // So, if it hasn't been explicitly set, assume INFO.
        Level level = loggerDelegate.getLevel();
        return level != null ? level : Level.INFO;
    }

    @Override
    public void setLevelAll()
    {
        setLevel(Level.ALL);
    }

    @Override
    public void setLevelDebug()
    {
        setLevel(Level.FINE);
    }

    @Override
    public void setLevelError()
    {
        setLevel(Level.SEVERE);
    }

    @Override
    public void setLevelInfo()
    {
        setLevel(Level.INFO);
    }

    @Override
    public void setLevelOff()
    {
        setLevel(Level.OFF);
    }

    @Override
    public void setLevelTrace()
    {
        setLevel(Level.FINER);
    }

    @Override
    public void setLevelWarn()
    {
        setLevel(Level.WARNING);
    }

    @Override
    public boolean isTraceEnabled()
    {
        return isLoggable(Level.FINER);
    }

    @Override
    public void trace(Object msg)
    {
        log(Level.FINER, msg);
    }

    @Override
    public void trace(Supplier msgSupplier)
    {
        log(Level.FINER, msgSupplier);
    }

    @Override
    public boolean isDebugEnabled() {
        return isLoggable(Level.FINE);
    }

    @Override
    public void debug(Object msg)
    {
        log(Level.FINE, msg);
    }

    @Override
    public void debug(Supplier msgSupplier)
    {
        log(Level.FINE, msgSupplier);
    }

    @Override
    public boolean isInfoEnabled()
    {
        return isLoggable(Level.INFO);
    }

    @Override
    public void info(Object msg)
    {
        log(Level.INFO, msg);
    }

    @Override
    public void info(Supplier msgSupplier)
    {
       log(Level.INFO, msgSupplier);
    }

    @Override
    public boolean isWarnEnabled()
    {
        return isLoggable(Level.WARNING);
    }

    @Override
    public void warn(Object msg)
    {
        log(Level.WARNING, msg);
    }

    @Override
    public void warn(Supplier msgSupplier)
    {
        log(Level.WARNING, msgSupplier);
    }

    @Override
    public void warn(Object msg, Throwable t)
    {
        log(Level.WARNING, msg, t);
    }

    @Override
    public void error(Object msg)
    {
        log(Level.SEVERE, msg);
    }

    @Override
    public void error(Supplier msgSupplier)
    {
        log(Level.SEVERE, msgSupplier);
    }

    @Override
    public void error(Object msg, Throwable t)
    {
        log(Level.SEVERE, msg, t);
    }

    @Override
    public void addContext(Map addedContext)
    {
        logContext.addContext(addedContext);
    }

    @Override
    public void addContext(String key, String value)
    {
        logContext.addContext(key, value);
    }

    static Function loggerFactory = java.util.logging.Logger::getLogger;
}