.setLoggerName("test.logger.sub")
                .setLevel(Level.ERROR)
                .setMessage(new SimpleMessage("test message 1"))
                .build();

        LogEvent event2 = Log4jLogEvent.newBuilder()
                .setLoggerName("another.logger.sub")
                .setLevel(Level.ERROR)
                .setMessage(new SimpleMessage("test message 2"))

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

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

  @BeforeEach
  fun setUp() {
    client =
      OkHttpClient
        .Builder()
        .addNetworkInterceptor(
          Interceptor { chain ->

                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);
            }
        }

   */
  public void testEmptyServiceManager() {
    Logger logger = Logger.getLogger(ServiceManager.class.getName());
    logger.setLevel(Level.FINEST);
    TestLogHandler logHandler = new TestLogHandler();
    logger.addHandler(logHandler);
    ServiceManager manager = new ServiceManager(Arrays.<Service>asList());

     * deprecated).
     */
    fun setLevel(level: Level) =
      apply {
        this.level = level
      }

    @JvmName("-deprecated_level")
    @Deprecated(
      message = "moved to var",
      replaceWith = ReplaceWith(expression = "level"),
      level = DeprecationLevel.ERROR,
    )
    fun getLevel(): Level = level

    @Throws(IOException::class)

        if (realm == null) {
            realm = "jCIFS";
        }

        level = Config.getInt("jcifs.smb1.util.loglevel", -1);
        if (level != -1) {
            LogStream.setLevel(level);
        }
        if (LogStream.level > 2) {
            try {
                Config.store(log, "JCIFS PROPERTIES");
            } catch (final IOException ioe) {}
        }
    }

            if (LogStream.level > 0) {
                ioe.printStackTrace(log);
            }
        }

        level = Config.getInt("jcifs.smb1.util.loglevel", -1);
        if (level != -1) {
            LogStream.setLevel(level);
        }

        try {
            "".getBytes(DEFAULT_OEM_ENCODING);
        } catch (final UnsupportedEncodingException uee) {
            if (LogStream.level >= 2) {

        }
        defaultDomain = Config.getProperty("jcifs.smb1.smb.client.domain");

        level = Config.getInt("jcifs.smb1.util.loglevel", -1);
        if (level != -1) {
            LogStream.setLevel(level);
        }
        if (LogStream.level > 2) {
            try {
                Config.store(log, "JCIFS PROPERTIES");
            } catch (final IOException ioe) {}
        }
    }

    /**

        split(ComponentUtil.getFessConfig().getLoggingAppPackages(), ",")
                .of(stream -> stream.map(String::trim).filter(StringUtil::isNotEmpty).forEach(s -> Configurator.setLevel(s, logLevel)));
    }

    /**
     * Gets the current log level.
     *
     * @return The current log level.
     */
    public String getLogLevel() {

       <version>2.6.0</version>
     </dependency>
     ```

    Configure basic logging like this:

    ```java
    HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
    loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BASIC);
    client.networkInterceptors().add(loggingInterceptor);
    ```

    **Warning:** Avoid `Level.HEADERS` and `Level.BODY` in production because