private val applicationInterceptor = HttpLoggingInterceptor(applicationLogs)
  private var extraNetworkInterceptor: Interceptor? = null

  private fun setLevel(level: Level) {
    networkInterceptor.setLevel(level)
    applicationInterceptor.setLevel(level)
  }

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server
    client =
      OkHttpClient.Builder()
        .addNetworkInterceptor(

                LogStream.setLevel(4);
            } else if (logger.isDebugEnabled()) {
                LogStream.setLevel(3);
            } else if (logger.isWarnEnabled()) {
                LogStream.setLevel(2);
            } else if (logger.isErrorEnabled()) {
                LogStream.setLevel(1);
            } else {
                LogStream.setLevel(0);
            }
        }

        Logger rootLogger = Logger.getLogger("");
        rootLogger.setLevel(Level.ALL);
        ConsoleHandler handler = new ConsoleHandler();
        handler.setFormatter(new SimpleFormatter());
        handler.setLevel(Level.ALL);
        rootLogger.addHandler(handler);
    }

    @Override
    public void tearDown() throws Exception {

                final Level sourceLevel = event.getLevel();
                if (sourceLevel != Level.ERROR) {
                    return event;
                }
                return new Log4jLogEvent.Builder(event).setLevel(Level.WARN).build();
            }
        }
        return event;
    }

    @PluginFactory
    public static ErrorToWarnRewritePolicy createPolicy(@PluginAttribute("loggers") final String loggerNamePrefix) {

        LoggingSourceSystem stdout = new DefaultStdOutLoggingSystem(getStdoutListener(), get(Clock.class));
        stdout.setLevel(LogLevel.QUIET);
        LoggingSourceSystem stderr = new DefaultStdErrLoggingSystem(new TextStreamOutputEventListener(outputEventBroadcaster), get(Clock.class));
        stderr.setLevel(LogLevel.ERROR);
        return new DefaultLoggingManagerFactory(
            renderer,

        }

        logger = loggers.putIfAbsent(name, new OutputEventListenerBackedLogger(name, this, clock));
        return logger != null ? logger : loggers.get(name);
    }

    public void reset() {
        setLevel(DEFAULT_LOG_LEVEL);
        DefaultUserInputReceiver userInputReceiver = new DefaultUserInputReceiver();
        OutputEventRenderer renderer = new OutputEventRenderer(clock, userInputReceiver);

	public final fun level (Lokhttp3/logging/HttpLoggingInterceptor$Level;)V
	public final fun redactHeader (Ljava/lang/String;)V
	public final fun redactQueryParams ([Ljava/lang/String;)V
	public final fun setLevel (Lokhttp3/logging/HttpLoggingInterceptor$Level;)Lokhttp3/logging/HttpLoggingInterceptor;
}

public final class okhttp3/logging/HttpLoggingInterceptor$Companion {
}

FlaskInstrumentor().instrument_app(app)
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
requests_log = logging.getLogger("requests.packages.urllib3")
requests_log.setLevel(logging.INFO)
requests_log.propagate = True
app.logger.addHandler(logging.StreamHandler(sys.stdout))
app.logger.setLevel(logging.INFO)

# Set the secret key to some random bytes. Keep this really secret!
app.secret_key = b'_5#y2L"F4Q8z\n\xec]/'

     */
    public static void enableServerLogging() {
        final ConsoleHandler handler = new ConsoleHandler();
        handler.setLevel(Level.ALL);
        final Logger logger = Logger.getLogger("com.sun.net.httpserver");
        logger.setLevel(Level.ALL);
        logger.addHandler(handler);
    }

    static String normalizePath(String path) {
        if (path.startsWith("/")) {

     * un-deprecated because Java callers can't chain when assigning Kotlin vals. (The getter remains
     * deprecated).
     */
    fun setLevel(level: Level) =
      apply {
        this.level = level
      }

    @JvmName("-deprecated_level")
    @Deprecated(
      message = "moved to var",
      replaceWith = ReplaceWith(expression = "level"),