import java.util.ArrayList;
import java.util.List;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

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

    private final List<ScoreBooster> scoreBoosterList = new ArrayList<>();

    public String execute() {
        final StringBuilder resultBuf = new StringBuilder();

import org.gradle.launcher.daemon.server.api.DaemonCommandExecution;

public class WatchForDisconnection implements DaemonCommandAction {
    private static final Logger LOGGER = Logging.getLogger(WatchForDisconnection.class);
    public static final String EXPIRATION_REASON = "client disconnected";

    @Override
    public void execute(final DaemonCommandExecution execution) {

import java.nio.file.attribute.FileTime;

@SuppressWarnings("Since15")
public class ModificationTimeFileAccessTimeJournal implements FileAccessTimeJournal {

    private static final Logger LOGGER = LoggerFactory.getLogger(ModificationTimeFileAccessTimeJournal.class);

    @Override
    public void setLastAccessTime(File file, long millis) {
        try {
            Files.setLastModifiedTime(file.toPath(), FileTime.fromMillis(millis));

    }

    @Input
    public OutputType getOutputType() {
        return outputType;
    }

    @TaskAction
    public void process() {
        getLogger().quiet("Writing out the URL response from '{}' to '{}'", url, outputType);

        // retrieve content from URL and write to output
    }

    private static enum OutputType {
        CONSOLE, FILE
    }
}

import org.gradle.util.internal.GFileUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class JavadocGenerator {

    private final static Logger LOG = LoggerFactory.getLogger(JavadocGenerator.class);

    private final ExecActionFactory execActionFactory;

    public JavadocGenerator(ExecActionFactory execActionFactory) {
        this.execActionFactory = execActionFactory;
    }

                    assertEquals(getClass().getClassLoader(), ClassLoader.getSystemClassLoader().getParent());

                    Logger logger = LoggerFactory.getLogger(TestUsingSlf4j.class);
                    logger.info("INFO via slf4j");
                    logger.warn("WARN via slf4j");
                    logger.error("ERROR via slf4j");
                }
            }

import org.gradle.api.logging.Logging;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class ShutdownHooks {
    private static final Logger LOGGER = Logging.getLogger(ShutdownHooks.class);
    private static final Map<Runnable, Thread> HOOKS = new ConcurrentHashMap<Runnable, Thread>();

    public static void addShutdownHook(Runnable shutdownHook) {

import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public final class LoggingInterceptors {
  private static final Logger logger = Logger.getLogger(LoggingInterceptors.class.getName());
  private final OkHttpClient client = new OkHttpClient.Builder()
      .addInterceptor(new LoggingInterceptor())
      .build();

  public void run() throws Exception {

import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.util.DfTypeUtil;

/**
 * @author FreeGen
 */
public class ClickLogBhv extends BsClickLogBhv {
    private static final Logger logger = LogManager.getLogger(ClickLogBhv.class);

    private String indexName = null;

    @Override
    protected String asEsIndex() {
        if (indexName == null) {

/**
 * Deletes any cache entries not accessed within the specified number of days.
 */
public class LeastRecentlyUsedCacheCleanup extends AbstractCacheCleanup {
    private static final Logger LOGGER = LoggerFactory.getLogger(LeastRecentlyUsedCacheCleanup.class);

    private final FileAccessTimeJournal journal;
    private final Supplier<Long> removeUnusedEntriesOlderThan;