}

    public void test_rewrite_multiple_logger_names() {
        String[] loggerNames = { "test.logger", "another.logger", "third.logger" };
        ErrorToWarnRewritePolicy policy = new ErrorToWarnRewritePolicy(loggerNames);

        LogEvent event1 = Log4jLogEvent.newBuilder()
                .setLoggerName("test.logger.sub")
                .setLevel(Level.ERROR)
                .setMessage(new SimpleMessage("test message 1"))

                if (response.getHttpStatusCode() == 200) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Sent {} to {}.", body, url);
                    }
                } else {
                    logger.warn("Failed to send {} to {}. HTTP Status is {}. {}", body, url, response.getHttpStatusCode(),

            });
            if (logger.isDebugEnabled()) {
                cachedPathMappingList.forEach(e -> {
                    logger.debug("path mapping: {}: {} -> {}", e.getId(), e.getRegex(), e.getReplacement());
                });
            }
            return cachedPathMappingList.size();
        } catch (final ComponentNotFoundException e) {
            if (logger.isDebugEnabled()) {

          if (!buffer.isProbablyUtf8()) {
            logger.log("")
            logger.log("<-- END HTTP (${totalMs}ms, binary ${buffer.size}-byte body omitted)")
            return response
          }

          if (contentLength != 0L) {
            logger.log("")
            logger.log(buffer.clone().readString(charset))
          }

          logger.log(
            buildString {

    public void init() {
        if (logger.isDebugEnabled()) {
            logger.debug("Initialize {}", this.getClass().getSimpleName());
        }
        osddFile = getOsddFile();
    }

    /**
     * Gets the OSDD file.
     *
     * @return the OSDD file
     */
    protected File getOsddFile() {
        if (!isOsddLinkEnabled()) {
            logger.debug("OSDD is disabled.");
            return null;

                    crawler.addExcludeFilter(urlValue);
                    if (logger.isInfoEnabled()) {
                        logger.info("Excluded URL from failures: {}", urlValue);
                    }
                });
            }

            if (logger.isDebugEnabled()) {
                logger.debug("Crawling {}", urlsStr);
            }

            crawler.setBackground(true);

                            if (logger.isDebugEnabled()) {
                                logger.debug("generator path: {}", filePath);
                            }
                            return filePath;
                        }
                    }
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("generator path: {}", s);
                }

  static final Object NULL = new Object();

  /*
   * Despite declaring this field in AbstractFutureState, we still use the logger for
   * AbstractFuture: Users may have tests or log configuration that expects that to be the logger
   * used for exceptions from listeners, as it's been in the past.
   */
  static final LazyLogger log = new LazyLogger(AbstractFuture.class);

        logger = LogFactory.getLog(clazz);
    }

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

    @Override
    public void fatal(final String message) {
        logger.fatal(message);
    }

    @Override
    public void fatal(final String message, final Throwable t) {
        logger.fatal(message, t);
    }

    @Override

 */
package okhttp3.recipes;

import java.io.IOException;
import java.util.logging.Logger;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public final class LoggingInterceptors {
  private static final Logger logger = Logger.getLogger(LoggingInterceptors.class.getName());
  private final OkHttpClient client = new OkHttpClient.Builder()