try {
            if (logger.isDebugEnabled()) {
                logger.debug("Shutting down thread executor.");
            }
            executor.shutdown();
            executor.awaitTermination(executorTerminationTimeout, TimeUnit.SECONDS);
        } catch (final InterruptedException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to interrupt executor.", e);
            }

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.fess.helper.CrawlerStatsHelper.StatsKeyObject;
import org.codelibs.fess.unit.UnitFessTestCase;
import org.codelibs.fess.util.ComponentUtil;

public class CrawlerStatsHelperTest extends UnitFessTestCase {

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

}

public abstract interface class okhttp3/logging/HttpLoggingInterceptor$Logger {
	public static final field Companion Lokhttp3/logging/HttpLoggingInterceptor$Logger$Companion;
	public static final field DEFAULT Lokhttp3/logging/HttpLoggingInterceptor$Logger;
	public abstract fun log (Ljava/lang/String;)V
}

public final class okhttp3/logging/HttpLoggingInterceptor$Logger$Companion {
}

    }

  fun enable(
    loggerClass: String,
    handler: Handler = logHandler(),
  ): Closeable {
    val logger = Logger.getLogger(loggerClass)
    if (configuredLoggers.add(logger)) {
      logger.addHandler(handler)
      logger.level = Level.FINEST
    }
    return Closeable {
      logger.removeHandler(handler)
    }
  }

  fun enable(loggerClass: KClass<*>) = enable(loggerClass.java.name)

	"fmt"
	"hash"
	"io"
)

// Tagger is the interface that wraps the basic ETag method.
type Tagger interface {
	ETag() ETag
}

type wrapReader struct {
	io.Reader
	Tagger
}

var _ Tagger = wrapReader{} // compiler check

// ETag returns the ETag of the underlying Tagger.
func (r wrapReader) ETag() ETag {
	if r.Tagger == nil {
		return nil
	}
	return r.Tagger.ETag()
}

        if (logger.isDebugEnabled()) {
            logger.debug("Create thumbnail task: {}", task);
        }
        return task;
    }

    @Override
    public boolean generate(final String thumbnailId, final File outputFile) {
        if (logger.isDebugEnabled()) {
            logger.debug("Generate Thumbnail: {}", thumbnailId);
        }

                    crawler.addExcludeFilter(urlValue);
                    if (logger.isInfoEnabled()) {
                        logger.info("Excluded URL from failures: {}", urlValue);
                    }
                });
            }

            if (logger.isDebugEnabled()) {
                logger.debug("Crawling {}", urlsStr);
            }

            crawler.setBackground(true);

import org.codelibs.fess.util.InputStreamThread;
import org.codelibs.fess.util.JobProcess;
import org.codelibs.fess.util.SystemUtil;

public class PythonJob extends ExecJob {
    static final Logger logger = LogManager.getLogger(PythonJob.class);

    protected String filename;

    protected List<String> argList = new ArrayList<>();

    public PythonJob filename(final String filename) {

import org.apache.logging.log4j.Logger;

public class CorsHandlerFactory {
    private static final Logger logger = LogManager.getLogger(CorsHandlerFactory.class);

    protected Map<String, CorsHandler> handerMap = new HashMap<>();

    public void add(final String origin, final CorsHandler handler) {
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded {}", origin);
        }

import org.apache.logging.log4j.Logger;
import org.apache.lucene.search.MatchAllDocsQuery;
import org.apache.lucene.search.Query;
import org.codelibs.fess.entity.QueryContext;
import org.opensearch.index.query.QueryBuilder;
import org.opensearch.index.query.QueryBuilders;

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