*/
public class BoostQueryCommand extends QueryCommand {
    /**
     * Default constructor for BoostQueryCommand.
     */
    public BoostQueryCommand() {
        super();
    }

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

    @Override
    protected String getQueryClassName() {
        return BoostQuery.class.getSimpleName();
    }

    @Override

import org.apache.maven.api.cli.Logger;

import static java.util.Objects.requireNonNull;

/**
 * Early CLI {@link Logger} that simply accumulates log entries until some point a real logger can emit them. This
 * logger is created at start, and it exists while no logging is available yet.
 */
public class AccumulatingLogger implements Logger {

            mimeType = "application/octet-stream";
        } else {
            logger.debug("Unknown response: response={}", response);
            return;
        }
        adjustActionResponseHeaders(mimeType, (k, v) -> {
            if (logger.isDebugEnabled()) {
                logger.debug("Apply header: key={}, value={}, mimeType={}", k, v, mimeType);
            }
            response.header(k, v);

 * based on configured retention periods. It helps maintain system performance by
 * preventing log tables from growing too large.
 */
public class PurgeLogJob {

    /** Logger instance for this class */
    private static final Logger logger = LogManager.getLogger(PurgeLogJob.class);

    /**
     * Default constructor for PurgeLogJob.
     * Creates a new instance of the log purging job with default settings.
     */

        if (logger.isDebugEnabled()) {
            logger.debug("loading {}", componentName);
        }
        try (CrawlerClient client = crawlerContainer.getComponent(componentName)) {
            crawlerClientFactory.addClient(regex, client);
        } catch (final Exception e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to create {}.", componentName, e);

    }

    public static void showError(Logger logger, String message, Throwable e, boolean showStackTrace) {
        if (logger == null) {
            System.err.println(message);
            if (showStackTrace && e != null) {
                e.printStackTrace(System.err);
            }
            return;
        }
        if (showStackTrace) {
            logger.error(message, e);
        } else {

 * It maintains a list of DuplicateHost rules and applies them to URLs.
 *
 */
public class DuplicateHostHelper {
    private static final Logger logger = LogManager.getLogger(DuplicateHostHelper.class);

    /** List of duplicate host rules for URL conversion */
    protected List<DuplicateHost> duplicateHostList;

    /**

          return 0;
        }
      };

  // We use a holder class to delay initialization: https://github.com/google/guava/issues/6566
  private static final class LoggerHolder {
    static final Logger logger = Logger.getLogger(CacheBuilder.class.getName());
  }

  static final int UNSET_INT = -1;

  boolean strictParsing = true;

  int initialCapacity = UNSET_INT;
  int concurrencyLevel = UNSET_INT;

 * future.addListener(new Runnable() {
 *   public void run() {
 *     processedCount.incrementAndGet();
 *     inFlight.remove(name);
 *     lastProcessed.set(name);
 *     logger.info("Done with {0}", name);
 *   }
 * }, executor);
 * }
 *
 * <h3>How to get an instance</h3>
 *
 * <p>We encourage you to return {@code ListenableFuture} from your methods so that your users can

    logger.log("[$timeMs ms] $message")
  }

  open class Factory
    @JvmOverloads
    constructor(
      private val logger: HttpLoggingInterceptor.Logger = HttpLoggingInterceptor.Logger.DEFAULT,
    ) : EventListener.Factory {
      override fun create(call: Call): EventListener = LoggingEventListener(logger)
    }

  companion object