import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SingleFirePendingChangesListener implements PendingChangesListener {
    private static final Logger LOGGER = LoggerFactory.getLogger(SingleFirePendingChangesListener.class);

    private final PendingChangesListener delegate;
    private boolean seenChanges;

    public SingleFirePendingChangesListener(PendingChangesListener delegate) {

        if (problems.isEmpty()) {
            getLogger().info("Plugin validation finished without warnings.");
        } else {
            if (getFailOnWarning().get() || problems.stream().anyMatch(problem -> problem.getDefinition().getSeverity() == ERROR)) {
                if (getIgnoreFailures().get()) {
                    getLogger().warn("Plugin validation finished with errors. {} {}",

object LoggerCodec : Codec<Logger> {

    override suspend fun WriteContext.encode(value: Logger) {
        writeString(value.name)
    }

    override suspend fun ReadContext.decode(): Logger? =
        LoggerFactory.getLogger(readString())

if (gradle.parent == null) {
    useLogger(new CustomLogger())
}

class CustomLogger extends BuildAdapter implements BuildListener, ProjectEvaluationListener, TaskExecutionListener, TaskActionListener {
    def logger = Logging.getLogger('init-script')

    public void buildFinished(BuildResult result) {
        logger.info("LOGGER: build finished")
        println 'init callback quiet out'
    }

    public void beforeEvaluate(Project project) {

import java.util.HashSet;
import java.util.Set;

public class LoggingIncubatingFeatureHandler implements FeatureHandler<IncubatingFeatureUsage> {
    private static final Logger LOGGER = LoggerFactory.getLogger(LoggingIncubatingFeatureHandler.class);

    private final Set<String> features = new HashSet<String>();

    @Override
    public void featureUsed(IncubatingFeatureUsage usage) {

    doFirst {
        println 'A task message which is logged at INFO level'
    }
}
// end::task-capture-stdout[]

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

def slf4jLogger = LoggerFactory.getLogger('some-logger')
slf4jLogger.info('An info log message logged using SLF4j')

import org.slf4j.LoggerFactory;

/**
 * Abstract implementation.
 *
 * @since 3.1.0
 */
public class BaseSlf4jConfiguration implements Slf4jConfiguration {
    private static final Logger LOGGER = LoggerFactory.getLogger(BaseSlf4jConfiguration.class);

    public void setRootLoggerLevel(Level level) {
        LOGGER.warn("setRootLoggerLevel: operation not supported");
    }

    public void activate() {

import java.util.HashMap;
import java.util.Map;

import org.apache.logging.log4j.LogManager;
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()) {

import org.apache.logging.log4j.Logger;
import org.codelibs.fess.helper.SearchLogHelper;
import org.codelibs.fess.util.ComponentUtil;

public class AggregateLogJob {

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

    public String execute() {
        final SearchLogHelper searchLogHelper = ComponentUtil.getSearchLogHelper();

        final StringBuilder resultBuf = new StringBuilder();

        try {

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

public class RequestStopIfSingleUsedDaemon implements DaemonCommandAction {

    private static final Logger LOGGER = Logging.getLogger(RequestStopIfSingleUsedDaemon.class);

    @Override
    public void execute(DaemonCommandExecution execution) {
        if (execution.isSingleUseDaemon()) {