if (!Constants.T.equals(scheduledJob.getAvailable())) {
            logger.info("Inactive Job {}:{}", id, scheduledJob.getName());
            try {
                unregister(scheduledJob);
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to delete Job {}", scheduledJob, e);
                }
            }
            return;

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

    @Override
    public void log(final LogType key, final Object... objs) {
        if (!ComponentUtil.available()) {
            if (logger.isDebugEnabled()) {
                logger.debug("container was destroyed.");
            }
            return;
        }

import org.apache.maven.project.ProjectBuildingResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Utility to select projects for a given set of pom.xml files.
 */
@Named
@Singleton
public class DefaultProjectsSelector implements ProjectsSelector {
    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultProjectsSelector.class);
    private final ProjectBuilder projectBuilder;

		ExplicitFTPS:   tls,
		Logger:         &minioLogger{},
		PassivePorts:   portRange,
		PublicIP:       publicIP,
	})
	if err != nil {
		logger.Fatal(err, "unable to initialize FTP server")
	}

	logger.Info(fmt.Sprintf("%s listening on %s", name, net.JoinHostPort(publicIP, strconv.Itoa(port))))

	if err = ftpServer.ListenAndServe(); err != nil {
		logger.Fatal(err, "unable to start FTP server")
	}

                : EnumSet.of(IssueLocality.EXTERNAL);

        if (hasAnythingToReport(issuesMap, issueLocalitiesToReport)) {
            logger.warn("");
            logger.warn("Plugin {} validation issues were detected in following plugin(s)", issueLocalitiesToReport);
            logger.warn("");
            for (Map.Entry<String, PluginValidationIssues> entry : issuesMap.entrySet()) {

import org.codelibs.fess.helper.SystemHelper;
import org.codelibs.fess.util.ComponentUtil;

public class PurgeLogJob {

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

    public String execute() {
        final CrawlingInfoService crawlingInfoService = ComponentUtil.getComponent(CrawlingInfoService.class);
        final SearchLogService searchLogService = ComponentUtil.getComponent(SearchLogService.class);

    protected final String sourceClass;

    protected final java.util.logging.Logger logger;

    public JulLoggerAdapter(final Class<?> clazz) {
        sourceClass = clazz.getName();
        logger = java.util.logging.Logger.getLogger(clazz.getName());
    }

    @Override
    public boolean isFatalEnabled() {
        return logger.isLoggable(Level.SEVERE);
    }

    @Override

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

    protected volatile Map<String, Map<String, List<Tuple3<String, QueryBuilder, ScoreFunctionBuilder<?>>>>> keyMatchQueryMap =
            Collections.emptyMap();

    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {
            logger.debug("Initialize {}", this.getClass().getSimpleName());

import org.eclipse.aether.util.graph.visitor.DependencyGraphDumper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 */
@Named
@Singleton
public class DefaultProjectDependenciesResolver implements ProjectDependenciesResolver {
    private final Logger logger = LoggerFactory.getLogger(getClass());
    private final RepositorySystem repoSystem;

func StreamItems[I any](store Store[I], target Target, doneCh <-chan struct{}, logger logger) {
	go func() {
		keyCh := replayItems(store, doneCh, logger, target.Name())
		sendItems(target, keyCh, doneCh, logger)
	}()