nl.demon.shadowland.freedumbytes.java.util.logging.jersey.Slf4jLoggingFeatureLevelWrapper Maven / Gradle / Ivy

Go to download
package nl.demon.shadowland.freedumbytes.java.util.logging.jersey;


import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

import org.slf4j.LoggerFactory;

import lombok.extern.slf4j.Slf4j;


/**
 * Jersey {@code LoggingFeature} Slf4j Wrapper to handle all logging of package or class as if of supplied level and uses {@link #isLoggable} to check if {@code log4j.xml} is set to this level or higher.
 *
 * 
 * Alternative Logger for Jersey {@code LoggingFeature} that doesn't require {@code SLF4JBridgeHandler}.
 * 
 * 
 * The jul-to-slf4j.jar artifact includes a {@code java.util.logging} (jul) handler, namely {@code SLF4JBridgeHandler}, which routes all incoming jul records to the SLF4J API.
 * 
 * 
 * If you are concerned about application performance, then use of {@code SLF4JBridgeHandler} is appropriate only if any one of the following two conditions is true:
 * 
 *
 * 
 * few j.u.l. logging statements are in play;
 * {@code LevelChangePropagator} has been installed.
 * 
 *
 * @see Bridging legacy APIs
 * @see How to make Jersey to use SLF4J instead of JUL?
 * @see Eclipse EE4J Jersey logging
 * @see Apache CXF logging
 */
@Slf4j
public class Slf4jLoggingFeatureLevelWrapper extends Logger
{
  private static final int TRACE_LEVEL_THRESHOLD = Level.FINEST.intValue();
  private static final int DEBUG_LEVEL_THRESHOLD = Level.FINE.intValue();
  private static final int INFO_LEVEL_THRESHOLD = Level.INFO.intValue();
  private static final int WARN_LEVEL_THRESHOLD = Level.WARNING.intValue();

  private String name;
  private Level asIfLevel;


  public Slf4jLoggingFeatureLevelWrapper(Class clazz, String resourceBundleName, Level asIfLevel)
  {
    this(clazz.getName(), resourceBundleName, asIfLevel);
  }


  public Slf4jLoggingFeatureLevelWrapper(String name, String resourceBundleName, Level asIfLevel)
  {
    super(name, resourceBundleName);

    this.name = name;
    this.asIfLevel = asIfLevel;
  }


  @Override
  public boolean isLoggable(Level julLevel)
  {
    boolean isLoggable;
    int asIfLevelValue = asIfLevel.intValue();

    if (asIfLevelValue <= TRACE_LEVEL_THRESHOLD)
    {
      isLoggable = getLogger().isTraceEnabled();
    }
    else if (asIfLevelValue <= DEBUG_LEVEL_THRESHOLD)
    {
      isLoggable = getLogger().isDebugEnabled();
    }
    else if (asIfLevelValue <= INFO_LEVEL_THRESHOLD)
    {
      isLoggable = getLogger().isInfoEnabled();
    }
    else if (asIfLevelValue <= WARN_LEVEL_THRESHOLD)
    {
      isLoggable = getLogger().isWarnEnabled();
    }
    else
    {
      isLoggable = getLogger().isErrorEnabled();
    }

    log.debug("isLoggable {} for original level {} but overruled with asIfLevel {}", isLoggable, julLevel, asIfLevel);

    return isLoggable;
  }


  @Override
  public void log(LogRecord record)
  {
    int julLevelValue = asIfLevel.intValue();
    log.debug("record loggername {}, level {} and overrule asIfLevel {}", record.getLoggerName(), record.getLevel(), asIfLevel);

    if (julLevelValue <= TRACE_LEVEL_THRESHOLD)
    {
      getLogger().trace(record.getMessage());
    }
    else if (julLevelValue <= DEBUG_LEVEL_THRESHOLD)
    {
      getLogger().debug(record.getMessage());
    }
    else if (julLevelValue <= INFO_LEVEL_THRESHOLD)
    {
      getLogger().info(record.getMessage());
    }
    else if (julLevelValue <= WARN_LEVEL_THRESHOLD)
    {
      getLogger().warn(record.getMessage());
    }
    else
    {
      getLogger().error(record.getMessage());
    }
  }


  private org.slf4j.Logger getLogger()
  {
    return LoggerFactory.getLogger(name);
  }
}