org.eclipse.persistence.logging.slf4j.EclipseLinkToSlf4jSessionLogger Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of eclipselink Show documentation
Framework adaptation for EclipseLink.
There is a newer version: 2.9.1
/*
 * Copyright (c) 2020 SAP SE or an SAP affiliate company. All rights reserved.
 */

package org.eclipse.persistence.logging.slf4j;

import java.util.List;

import org.eclipse.persistence.logging.AbstractSessionLog;
import org.eclipse.persistence.logging.SessionLog;
import org.eclipse.persistence.logging.SessionLogEntry;
import org.slf4j.Logger;

import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.sap.cloud.sdk.cloudplatform.exception.ShouldNotHappenException;
import com.sap.cloud.sdk.cloudplatform.logging.CloudLoggerFactory;

public class EclipseLinkToSlf4jSessionLogger extends AbstractSessionLog
{
    private enum LogLevel
    {
        TRACE,
        DEBUG,
        INFO,
        WARN,
        ERROR,
        OFF
    }

    private static final String NAMESPACE = "org.eclipselink.log";
    private static final String MISC = "misc";
    private static final String MISC_NAMESPACE = NAMESPACE + "." + MISC;

    private static final ImmutableList logLevels;

    static {
        final List levels = Lists.newArrayListWithCapacity(SessionLog.OFF + 1);

        levels.add(SessionLog.ALL, LogLevel.TRACE);
        levels.add(SessionLog.FINEST, LogLevel.TRACE);
        levels.add(SessionLog.FINER, LogLevel.TRACE);
        levels.add(SessionLog.FINE, LogLevel.TRACE);
        levels.add(SessionLog.CONFIG, LogLevel.DEBUG);
        levels.add(SessionLog.INFO, LogLevel.INFO);
        levels.add(SessionLog.WARNING, LogLevel.WARN);
        levels.add(SessionLog.SEVERE, LogLevel.ERROR);
        levels.add(SessionLog.OFF, LogLevel.OFF);

        logLevels = ImmutableList.copyOf(levels);
    }

    private static final ImmutableMap categoryToLogger;

    static {
        final ImmutableMap.Builder builder = ImmutableMap.builder();
        for( final String category : SessionLog.loggerCatagories ) {
            builder.put(category, CloudLoggerFactory.getLogger(NAMESPACE + "." + category));
        }
        builder.put(MISC, CloudLoggerFactory.getLogger(MISC_NAMESPACE));
        categoryToLogger = builder.build();
    }

    @Override
    public void log( final SessionLogEntry logEntry )
    {
        if( !shouldLog(logEntry.getLevel(), logEntry.getNameSpace()) ) {
            return;
        }

        final Logger logger = getLogger(logEntry.getNameSpace());
        final LogLevel logLevel = getLogLevel(logEntry.getLevel());

        final StringBuilder message = new StringBuilder();
        message.append(getSupplementDetailString(logEntry));
        message.append(formatMessage(logEntry));

        // append exception to message if log level is below warn
        final Throwable entryException = logEntry.getException();

        if( logLevel != LogLevel.ERROR
            && logLevel != LogLevel.WARN
            && entryException != null
            && shouldLogExceptionStackTrace() ) {
            message.append("\n").append(Throwables.getStackTraceAsString(entryException));
        }

        switch( logLevel ) {
            case TRACE:
                logger.trace(message.toString());
                break;
            case DEBUG:
                logger.debug(message.toString());
                break;
            case INFO:
                logger.info(message.toString());
                break;
            case WARN:
                if( entryException != null ) {
                    logger.warn(message.toString(), entryException);
                } else {
                    logger.warn(message.toString());
                }
                break;
            case ERROR:
                if( entryException != null ) {
                    logger.error(message.toString(), entryException);
                } else {
                    logger.error(message.toString());
                }
                break;
            default:
                throw new ShouldNotHappenException("Unknown log level: " + logLevel + ".");
        }
    }

    @Override
    public boolean shouldLog( final int level )
    {
        return shouldLog(level, MISC);
    }

    @Override
    public boolean shouldLog( final int level, final String category )
    {
        final Logger logger = getLogger(category);
        final LogLevel logLevel = getLogLevel(level);

        switch( logLevel ) {
            case TRACE:
                return logger.isTraceEnabled();
            case DEBUG:
                return logger.isDebugEnabled();
            case INFO:
                return logger.isInfoEnabled();
            case WARN:
                return logger.isWarnEnabled();
            case ERROR:
                return logger.isErrorEnabled();
            default:
                return true;
        }
    }

    private Logger getLogger( String category )
    {
        if( category == null || !categoryToLogger.containsKey(category) ) {
            category = MISC;
        }

        return categoryToLogger.get(category);
    }

    private LogLevel getLogLevel( final Integer level )
    {
        LogLevel logLevel;
        try {
            logLevel = logLevels.get(level);
        }
        catch( final IndexOutOfBoundsException e ) {
            getLogger(MISC_NAMESPACE).error("Failed to look up log level: " + level + ". Using OFF as fallback.");
            logLevel = LogLevel.OFF;
        }

        return logLevel;
    }
}