try {
                metadata = readMetadata(metadataFile);
            } catch (RepositoryMetadataReadException e) {
                if (getLogger().isDebugEnabled()) {
                    getLogger().warn(e.getMessage(), e);
                } else {
                    getLogger().warn(e.getMessage());
                }
                return setRepository;
            }

          val activeLogger = getLogger("")
          activeLogger.addHandler(handler)
          activeLogger.level = Level.ALL

          getLogger("jdk.event.security").level = Level.INFO
          getLogger("org.conscrypt").level = Level.INFO
        } else {
          if (showHttp2Frames) {
            val activeLogger = getLogger(Http2::class.java.name)
            activeLogger.level = Level.FINE

    @Rule
    public ExpectedException exception = ExpectedException.none();

    private final Logger logger = Logger.getLogger(getClass());

    /**
     * @throws Exception
     */
    @Test
    public void testGetLogger() throws Exception {
        assertThat(Logger.getLogger(getClass()), is(sameInstance(Logger.getLogger(getClass()))));
    }

    /**
     * @throws Exception
     */
    @Test

import org.codelibs.fess.mylasta.direction.FessConfig;
import org.codelibs.fess.util.ComponentUtil;

public class FessFileTransformer extends AbstractFessFileTransformer {
    private static final Logger logger = LogManager.getLogger(FessFileTransformer.class);

    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {
            logger.debug("Initialize {}", this.getClass().getSimpleName());
        }

import org.codelibs.fess.mylasta.direction.FessConfig;
import org.codelibs.fess.util.ComponentUtil;

public class FessStandardTransformer extends AbstractFessFileTransformer {
    private static final Logger logger = LogManager.getLogger(FessStandardTransformer.class);

    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {
            logger.debug("Initialize {}", this.getClass().getSimpleName());
        }

import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

/**
 * @author shinsuke
 *
 */
public class CrawlerStatsHelper {
    private static final Logger logger = LogManager.getLogger(CrawlerStatsHelper.class);

    private static final String BEGIN_KEY = "begin";

    protected Logger statsLogger = null;

    protected String loggerName = "fess.log.crawler.stats";

import org.codelibs.core.log.Logger;

/**
 * Utility class for Thread class
 *
 * @author shinsuke
 *
 */
public abstract class ThreadUtil {

    private static final Logger logger = Logger.getLogger(ThreadUtil.class);

    public static void sleep(final long millis) {
        if (millis < 1L) {
            return;
        }
        try {
            Thread.sleep(millis);

import org.codelibs.fess.dict.DictionaryFile;
import org.codelibs.fess.dict.DictionaryItem;

public class CharMappingCreator extends DictionaryCreator {
    private static final Logger logger = LogManager.getLogger(CharMappingCreator.class);

    public CharMappingCreator() {
        super("mapping.*\\.txt");
    }

    @PostConstruct
    public void register() {
        if (logger.isInfoEnabled()) {

import org.codelibs.fess.dict.DictionaryFile;
import org.codelibs.fess.dict.DictionaryItem;

public class SynonymCreator extends DictionaryCreator {
    private static final Logger logger = LogManager.getLogger(SynonymCreator.class);

    public SynonymCreator() {
        super("synonym.*\\.txt");
    }

    @PostConstruct
    public void register() {
        if (logger.isInfoEnabled()) {

    /**
     * {@link Logger}を返します。
     *
     * @param clazz
     *            ロガーのカテゴリとなるクラス。{@literal null}であってはいけません
     * @return {@link Logger}
     */
    public static synchronized Logger getLogger(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        if (!initialized) {
            initialize();
        }
        Logger logger = loggers.get(clazz);
        if (logger == null) {