* @author shinsuke
 *
 */
public class SitemapsRule extends RegexRule {
    /**
     *
     */
    private static final long serialVersionUID = 1L;

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

    @Override
    public boolean match(final ResponseData responseData) {
        if (super.match(responseData)) {
            try (final InputStream is = responseData.getResponseBody()) {

 *
 * @author Luiz-Otavio Zorzella
 * @since 10.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public abstract class SloppyTearDown implements TearDown {
  private static final Logger logger = Logger.getLogger(SloppyTearDown.class.getName());

  @Override
  public final void tearDown() {
    try {
      sloppyTearDown();
    } catch (Throwable t) {

        }
    }

    override suspend fun ReadContext.decode(): DefaultContextAwareTaskLogger =
        decodePreservingIdentity { id ->
            DefaultContextAwareTaskLogger(Logging.getLogger(Task::class.java)).also { logger ->
                read()?.let { rewriter ->
                    logger.messageRewriter = rewriter as MessageRewriter
                }
                isolate.identities.putInstance(id, logger)

public class InvalidInstallationWarningReporter implements BiConsumer<InstallationLocation, JvmInstallationMetadata> {

    private final Logger logger;

    public InvalidInstallationWarningReporter() {
        this(Logging.getLogger(InvalidInstallationWarningReporter.class));
    }

    @VisibleForTesting
    public InvalidInstallationWarningReporter(Logger logger) {
        this.logger = logger;
    }

    @Override

import org.slf4j.LoggerFactory;

import javax.inject.Inject;

public abstract class AntWorkAction<T extends AntWorkParameters> implements WorkAction<T> {
    private static final Logger LOGGER = LoggerFactory.getLogger(AntWorkAction.class);

    @Override
    public void execute() {
        LOGGER.info("Running {} with toolchain '{}'.", getActionName(), Jvm.current().getJavaHome().getAbsolutePath());

        getIsolatedAntBuilder()

        if (!reset) {
            LogManager.getLogManager().reset();
            try {
                LogManager.getLogManager().readConfiguration();
            } catch (IOException error) {
                Logger.getLogger("").addHandler(new ConsoleHandler());
            }
            reset = true;
        }
    }

 */
package org.codelibs.core.concurrent;

import java.util.concurrent.ForkJoinPool;

import org.codelibs.core.log.Logger;

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

    private CommonPoolUtil() {
        // nothing
    }

    public static void execute(final Runnable task) {
        ForkJoinPool.commonPool().execute(() -> {

// tag::use-slf4j[]
import org.slf4j.LoggerFactory

val slf4jLogger = LoggerFactory.getLogger("some-logger")
slf4jLogger.info("An info log message logged using SLF4j")
// end::use-slf4j[]

// tag::use-logger[]
logger.quiet("An info log message which is always logged.")
logger.error("An error log message.")
logger.warn("A warning log message.")
logger.lifecycle("A lifecycle info log message.")
logger.info("An info log message.")

 */

package org.gradle.internal.cc.base

import org.gradle.api.logging.Logger
import org.gradle.api.logging.Logging


/**
 * Configuration Cache logger.
 */

import org.gradle.internal.time.Timer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class BuildScriptProcessor implements ProjectConfigureAction {
    private static final Logger LOGGER = LoggerFactory.getLogger(BuildScriptProcessor.class);
    private final ScriptPluginFactory configurerFactory;

    public BuildScriptProcessor(ScriptPluginFactory configurerFactory) {
        this.configurerFactory = configurerFactory;
    }