public void apply(Project project) {
    Task hello = project.getTasks().create("hello");
    hello.doLast(new Action<Task>() {
      @Override
      public void execute(Task task) {
        task.getLogger().lifecycle("Hello!");
      }
    });
  }

 * @since 2.0.9, renamed from <code>DefaultJavaToolchainFactory</code> in 3.2.4
 */
@Named("jdk")
@Singleton
public class JavaToolchainFactory implements ToolchainFactory {
    private final Logger logger = LoggerFactory.getLogger(getClass());

    public ToolchainPrivate createToolchain(ToolchainModel model) throws MisconfiguredToolchainException {
        if (model == null) {
            return null;
        }

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());
        }

            Task task = project.getTasks().create(RELEASE_TASK_NAME);

            task.doLast(new Action<Task>() {
                @Override
                public void execute(Task task) {
                    task.getLogger().quiet("Releasing to production...");

                    // release the artifact to production
                }
            });
        }
    }

 * available under <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache 2.0</a> license.
 */
final class RetryHttpInitializerWrapper implements HttpRequestInitializer {

    private static final Logger LOG = Logging.getLogger(RetryHttpInitializerWrapper.class);
    private static final long DEFAULT_READ_TIMEOUT_MILLIS = TimeUnit.MINUTES.toMillis(2);

    private final Supplier<Credential> credentialSupplier;
    private final Sleeper sleeper;

    private final StandardOutputRedirector.OutputListener stdErrListener = Mock()
    private final Logger logger1 = Logger.getLogger("")
    private final Logger logger2 = Logger.getLogger("hello")
    private final Logger logger3 = Logger.getLogger("hello.world")
    private static String savedJULConfigClassProperty = null;

    public static class DummyFormatter extends Formatter {
        @Override

    public void setUrl(String url) {
        this.url = url;
    }

    @Input
    public String getUrl() {
        return url;
    }

    @TaskAction
    public void verify() {
        getLogger().quiet("Verifying URL '{}'", url);

        // verify URL by making a HTTP call
    }
}

            Task task = project.getTasks().create(RELEASE_TASK_NAME);

            task.doLast(new Action<Task>() {
                @Override
                public void execute(Task task) {
                    task.getLogger().quiet("Releasing to production...");

                    // release the artifact to production
                }
            });
        }
    }

import org.gradle.process.ExecOperations
import org.slf4j.LoggerFactory
import java.util.concurrent.ConcurrentHashMap
import javax.inject.Inject


private
val logger = LoggerFactory.getLogger("daemonTracker")


abstract class DaemonTracker : BuildService<DaemonTracker.Params>, AutoCloseable {
    interface Params : BuildServiceParameters {
        val rootProjectDir: DirectoryProperty
    }

        toolExec.setStandardOutput(stdOutput.getOutputStream());

        try {
            toolExec.execute();
            invocation.getLogger().operationSuccess(description.getDisplayName(), combineOutput(stdOutput, errOutput));
        } catch (ExecException e) {
            invocation.getLogger().operationFailed(description.getDisplayName(), combineOutput(stdOutput, errOutput));