build.gradle

apply plugin: 'groovy'
apply plugin: 'idea'

repositories {
    mavenCentral()
}

dependencies {
    compile 'org.slf4j:slf4j-api:1.7.5'
    compile 'org.eclipse.persistence:eclipselink:2.5.2'
    compile 'org.codehaus.groovy:groovy-all:2.3.4'
}

Slf4jSessionLogger.groovy

package com.initvoid.org.eclipse.persistence.logging

import org.eclipse.persistence.logging.AbstractSessionLog
import org.eclipse.persistence.logging.SessionLogEntry
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import org.slf4j.MDC

public class Slf4jSessionLogger extends AbstractSessionLog
{
    private static final String MDC_SESSION_KEY     = 'EclipseLink.Session'
    private static final String MDC_CONNECTION_KEY  = 'EclipseLink.Connection'
    private static final String MDC_THREAD_KEY      = 'EclipseLink.Thread'
    private static final String MDC_DATE_KEY        = 'EclipseLink.Date'

    private static String getLoggerName (String sessionName, String namespace)
    {
        def nameBuilder = new StringBuilder('org.eclipse.persistence.logging')
        if (sessionName != null)
        {
            nameBuilder << '.session'
            if (!sessionName.empty)
            {
                nameBuilder << '.'
                nameBuilder << sessionName
            }
        }
        if (namespace == null || namespace?.empty)
        {
            nameBuilder << '.default'
        }
        else
        {
            nameBuilder << '.'
            nameBuilder << namespace
        }
        nameBuilder.toString()
    }

    private static Logger getLogger (String sessionName, String namespace)
    {
        def loggerName = getLoggerName(sessionName, namespace)
        LoggerFactory.getLogger(loggerName)
    }

    private static Logger getLogger (SessionLogEntry entry)
    {
        getLogger(entry.session?.name, entry.nameSpace)
    }

    private Logger getLogger (String namespace)
    {
        getLogger(session?.name, namespace)
    }

    /**
     * {@inheritDoc}
     */
    @Override
    boolean shouldLog(int level, String category)
    {
        def logger = getLogger(category)
        def slf4jLevel = Slf4jLevel.getByEclipseLinkLevel(level)
        return logEnabled(logger, slf4jLevel)
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void log(SessionLogEntry entry)
    {
        def logger  = getLogger(entry)
        def level   = Slf4jLevel.getByEclipseLinkLevel(entry.level)
        
        if(!logEnabled(logger, level))
        {
            return
        }

        def message    = formatMessage(entry)
        def exception  = entry.exception
        
        try 
        {
            populateMdc(entry)
            if (exception)
            {
                logMessage(logger, level, message, exception)
            }
            else
            {
                logMessage(logger, level, message)
            }
        }
        finally
        {
            clearMdc()
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    boolean shouldPrintThread()
    {
        shouldPrintThread == null ? false : shouldPrintThread.booleanValue()
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean shouldDisplayData()
    {
        shouldDisplayData == null ? false : shouldDisplayData.booleanValue()
    }

    private void populateMdc (SessionLogEntry entry)
    {
        if (entry.date != null)
        {
            MDC.put(MDC_DATE_KEY, getDateString(entry.date))
        }
        if (entry.session != null)
        {
            MDC.put(MDC_SESSION_KEY, getSessionString(entry.session))
        }
        if (entry.connection != null)
        {
            MDC.put(MDC_CONNECTION_KEY, getConnectionString(entry.connection))
        }
        if (entry.thread != null) 
        {
            MDC.put(MDC_THREAD_KEY, getThreadString(entry.thread))
        }
    }

    private static void clearMdc ()
    {
        MDC.remove(MDC_DATE_KEY)
        MDC.remove(MDC_SESSION_KEY)
        MDC.remove(MDC_CONNECTION_KEY)
        MDC.remove(MDC_THREAD_KEY)
    }

    private static boolean logEnabled(Logger logger, Slf4jLevel level)
    {
        switch (level)
        {
            case Slf4jLevel.TRACE:
                return logger.traceEnabled
            case Slf4jLevel.DEBUG:
                return logger.debugEnabled
            case Slf4jLevel.INFO:
                return logger.infoEnabled
            case Slf4jLevel.WARN:
                return logger.warnEnabled
            case Slf4jLevel.ERROR:
                return logger.errorEnabled
            case Slf4jLevel.OFF:
                return false
            default:
                return logger.infoEnabled
        }
    }

    private static void logMessage(Logger logger, Slf4jLevel level, String message, Throwable exception)
    {
        switch (level)
        {
            case Slf4jLevel.TRACE:
                logger.trace(message, exception)
                break
            case Slf4jLevel.DEBUG:
                logger.debug(message, exception)
                break
            case Slf4jLevel.INFO:
                logger.info(message, exception)
                break
            case Slf4jLevel.WARN:
                logger.warn(message, exception)
                break
            case Slf4jLevel.ERROR:
                logger.error(message, exception)
                break
            case Slf4jLevel.OFF:
                throw new UnsupportedOperationException()
                break
            default:
                logger.info(message, exception)
                break
        }
    }
    
    private static void logMessage(Logger logger, Slf4jLevel level, String message)
    {
        switch (level)
        {
            case Slf4jLevel.TRACE:
                logger.trace(message)
                break
            case Slf4jLevel.DEBUG:
                logger.debug(message)
                break
            case Slf4jLevel.INFO:
                logger.info(message)
                break
            case Slf4jLevel.WARN:
                logger.warn(message)
                break
            case Slf4jLevel.ERROR:
                logger.error(message)
                break
            case Slf4jLevel.OFF:
                throw new UnsupportedOperationException()
                break
            default:
                logger.info(message)
                break
        }
    }
    
    private static enum Slf4jLevel
    {
        ALL([]),
        TRACE([
            EclipseLinkLevel.ALL,
            EclipseLinkLevel.FINEST
        ]),
        DEBUG([
            EclipseLinkLevel.FINER,
            EclipseLinkLevel.FINE
        ]),
        INFO([
            EclipseLinkLevel.CONFIG,
            EclipseLinkLevel.INFO
        ]),
        WARN([
            EclipseLinkLevel.WARNING
        ]),
        ERROR([
            EclipseLinkLevel.SEVERE
        ]),
        OFF([
            EclipseLinkLevel.OFF
        ])

        final List<EclipseLinkLevel> eclipseLinkLevels

        private static final Map<EclipseLinkLevel, Slf4jLevel> ECLIPSE_LINK_MAP = new HashMap<>()

        static {
            for (def slf4jLevel in values())
            {
                for (def eclipseLinkLevel in slf4jLevel.eclipseLinkLevels)
                {
                    ECLIPSE_LINK_MAP[eclipseLinkLevel] = slf4jLevel
                }
            }
        }

        public static Slf4jLevel getByEclipseLinkLevel(EclipseLinkLevel eclipseLinkLevel)
        {
            ECLIPSE_LINK_MAP[eclipseLinkLevel]
        }

        public static Slf4jLevel getByEclipseLinkLevel(int eclipseLinkLevel)
        {
            getByEclipseLinkLevel(EclipseLinkLevel.getByLevelValue(eclipseLinkLevel))
        }

        private Slf4jLevel (List<EclipseLinkLevel> eclipseLinkLevels)
        {
            this.eclipseLinkLevels = eclipseLinkLevels
        }
    }

    private static enum EclipseLinkLevel
    {
        ALL     (ALL,     ALL_LABEL,     Slf4jLevel.TRACE),
        FINEST  (FINEST,  FINEST_LABEL,  Slf4jLevel.TRACE),
        FINER   (FINER,   FINER_LABEL,   Slf4jLevel.DEBUG),
        FINE    (FINE,    FINE_LABEL,    Slf4jLevel.DEBUG),
        CONFIG  (CONFIG,  CONFIG_LABEL,  Slf4jLevel.INFO),
        INFO    (INFO,    INFO_LABEL,    Slf4jLevel.INFO),
        WARNING (WARNING, WARNING_LABEL, Slf4jLevel.WARN),
        SEVERE  (SEVERE,  SEVERE_LABEL,  Slf4jLevel.ERROR),
        OFF     (OFF,     OFF_LABEL,     Slf4jLevel.OFF),

        final int         eclipseLinkLevelValue
        final String      eclipseLinkLevelLabel
        final Slf4jLevel  slf4jLevel

        private static final Map<Integer, EclipseLinkLevel> ECLIPSE_LINK_MAP = new HashMap<>()

        static {
            for (def level in values())
            {
                ECLIPSE_LINK_MAP[level.eclipseLinkLevelValue] = level
            }
        }

        public static EclipseLinkLevel getByLevelValue (int levelValue)
        {
            ECLIPSE_LINK_MAP[levelValue]
        }

        private EclipseLinkLevel (int eclipseLinkLevelValue, String eclipseLinkLevelLabel, Slf4jLevel slf4jLevel)
        {
            this.eclipseLinkLevelValue  = eclipseLinkLevelValue
            this.eclipseLinkLevelLabel  = eclipseLinkLevelLabel
            this.slf4jLevel             = slf4jLevel
        }
    }

}