okhttp3.logging.HttpLoggingInterceptor.Level Java Examples

@Override
public InfluxDB setLogLevel(final LogLevel logLevel) {
  switch (logLevel) {
  case NONE:
    this.loggingInterceptor.setLevel(Level.NONE);
    break;
  case BASIC:
    this.loggingInterceptor.setLevel(Level.BASIC);
    break;
  case HEADERS:
    this.loggingInterceptor.setLevel(Level.HEADERS);
    break;
  case FULL:
    this.loggingInterceptor.setLevel(Level.BODY);
    break;
  default:
    break;
  }
  this.logLevel = logLevel;
  return this;
}
 

private MarvelApi() {

        AuthenticatorInterceptor authenticator = new AuthenticatorInterceptor();

        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(BuildConfig.DEBUG ? Level.BODY : Level.BASIC);

        OkHttpClient client = new OkHttpClient.Builder()
                .addInterceptor(authenticator)
                .addInterceptor(logging)
                .build();

        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(BASE_URL)
                .client(client)
                .addConverterFactory(GsonConverterFactory.create())
                .build();

        mService = retrofit.create(MarvelService.class);
    }
 

/**
 * Create an instance with the given tenant's domain and API token.
 * In addition, accepts an {@link HttpOptions} that will be used to configure the networking client.
 * See the Management API section in the readme or visit https://auth0.com/docs/api/management/v2/tokens
 * to learn how to obtain a token.
 *
 * @param domain   the tenant's domain.
 * @param apiToken the token to authenticate the calls with.
 * @param options  configuration options for this client instance.
 * @see #ManagementAPI(String, String)
 */
public ManagementAPI(String domain, String apiToken, HttpOptions options) {
    Asserts.assertNotNull(domain, "domain");
    Asserts.assertNotNull(apiToken, "api token");

    this.baseUrl = createBaseUrl(domain);
    if (baseUrl == null) {
        throw new IllegalArgumentException("The domain had an invalid format and couldn't be parsed as an URL.");
    }
    this.apiToken = apiToken;

    telemetry = new TelemetryInterceptor();
    logging = new HttpLoggingInterceptor();
    logging.setLevel(Level.NONE);
    client = buildNetworkingClient(options);
}
 

/**
 * Create a new instance with the given tenant's domain, application's client id and client secret.
 * These values can be obtained at https://manage.auth0.com/#/applications/{YOUR_CLIENT_ID}/settings.
 * In addition, accepts an {@link HttpOptions} that will be used to configure the networking client.
 *
 * @param domain       tenant's domain.
 * @param clientId     the application's client id.
 * @param clientSecret the application's client secret.
 * @param options      configuration options for this client instance.
 * @see #AuthAPI(String, String, String)
 */
public AuthAPI(String domain, String clientId, String clientSecret, HttpOptions options) {
    Asserts.assertNotNull(domain, "domain");
    Asserts.assertNotNull(clientId, "client id");
    Asserts.assertNotNull(clientSecret, "client secret");
    Asserts.assertNotNull(options, "client options");

    this.baseUrl = createBaseUrl(domain);
    if (baseUrl == null) {
        throw new IllegalArgumentException("The domain had an invalid format and couldn't be parsed as an URL.");
    }
    this.clientId = clientId;
    this.clientSecret = clientSecret;

    telemetry = new TelemetryInterceptor();
    logging = new HttpLoggingInterceptor();
    logging.setLevel(Level.NONE);
    client = buildNetworkingClient(options);
}
 

@Test
public void shouldAddAndDisableLoggingInterceptor() throws Exception {
    AuthAPI api = new AuthAPI(DOMAIN, CLIENT_ID, CLIENT_SECRET);
    assertThat(api.getClient().interceptors(), hasItem(isA(HttpLoggingInterceptor.class)));

    for (Interceptor i : api.getClient().interceptors()) {
        if (i instanceof HttpLoggingInterceptor) {
            HttpLoggingInterceptor logging = (HttpLoggingInterceptor) i;
            assertThat(logging.getLevel(), is(Level.NONE));
        }
    }
}
 

/**
 * Enable/disable debugging for this API client.
 *
 * @param debugging
 *            To enable (true) or disable (false) debugging
 * @return ApiClient
 */
public ApiClient setDebugging(boolean debugging) {
    if (debugging != this.debugging) {
        if (debugging) {
            loggingInterceptor = new HttpLoggingInterceptor();
            loggingInterceptor.setLevel(Level.BODY);
            httpClient = httpClient.newBuilder().addInterceptor(loggingInterceptor).build();
        } else {
            httpClient.interceptors().remove(loggingInterceptor);
            loggingInterceptor = null;
        }
    }
    this.debugging = debugging;
    return this;
}
 

private static final HttpLoggingInterceptor getLogger(Level level) {
    HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor((msg) -> {
        log.debug(msg);
    });
    loggingInterceptor.setLevel(level);
    return loggingInterceptor;
}
 

@Test
public void shouldDisableLoggingInterceptor() throws Exception {
    AuthAPI api = new AuthAPI(DOMAIN, CLIENT_ID, CLIENT_SECRET);
    assertThat(api.getClient().interceptors(), hasItem(isA(HttpLoggingInterceptor.class)));
    api.setLoggingEnabled(false);

    for (Interceptor i : api.getClient().interceptors()) {
        if (i instanceof HttpLoggingInterceptor) {
            HttpLoggingInterceptor logging = (HttpLoggingInterceptor) i;
            assertThat(logging.getLevel(), is(Level.NONE));
        }
    }
}
 

@Test
public void shouldEnableLoggingInterceptor() throws Exception {
    AuthAPI api = new AuthAPI(DOMAIN, CLIENT_ID, CLIENT_SECRET);
    assertThat(api.getClient().interceptors(), hasItem(isA(HttpLoggingInterceptor.class)));
    api.setLoggingEnabled(true);

    for (Interceptor i : api.getClient().interceptors()) {
        if (i instanceof HttpLoggingInterceptor) {
            HttpLoggingInterceptor logging = (HttpLoggingInterceptor) i;
            assertThat(logging.getLevel(), is(Level.BODY));
        }
    }
}
 

@Override
public void applyOptions(Context context, Builder builder) {
  builder.statusBarColor(R.color.colorPrimary)
      .statusBarAlpha(0);
  if (BuildConfig.APP_DEBUG) {
    builder.addInterceptor(new HttpLoggingInterceptor().setLevel(Level.BASIC));
  }
}
 

private static final HttpLoggingInterceptor getLogger(Level level) {
    HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor((msg) -> {
        log.debug(msg);
    });
    loggingInterceptor.setLevel(level);
    return loggingInterceptor;
}
 

/**
 * Enable/disable debugging for this API client.
 *
 * @param debugging To enable (true) or disable (false) debugging
 * @return ApiClient
 */
public ApiClient setDebugging(boolean debugging) {
    if (debugging != this.debugging) {
        if (debugging) {
            loggingInterceptor = new HttpLoggingInterceptor();
            loggingInterceptor.setLevel(Level.BODY);
            httpClient = httpClient.newBuilder().addInterceptor(loggingInterceptor).build();
        } else {
            httpClient.interceptors().remove(loggingInterceptor);
            loggingInterceptor = null;
        }
    }
    this.debugging = debugging;
    return this;
}
 

private OkHttpClient getClient() {
  HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
  loggingInterceptor.setLevel(BuildConfig.DEBUG ? Level.BODY : Level.NONE);

  OkHttpClient.Builder clientBuilder = new OkHttpClient.Builder()
      .connectTimeout(30, TimeUnit.SECONDS)
      .readTimeout(30, TimeUnit.SECONDS)
      .writeTimeout(30, TimeUnit.SECONDS)
      .addInterceptor(loggingInterceptor)
      .retryOnConnectionFailure(false);

  return clientBuilder.build();
}
 

/**
 * Enable/disable debugging for this API client.
 *
 * @param debugging To enable (true) or disable (false) debugging
 * @return ApiClient
 */
public ApiClient setDebugging(boolean debugging) {
    if (debugging != this.debugging) {
        if (debugging) {
            loggingInterceptor = new HttpLoggingInterceptor();
            loggingInterceptor.setLevel(Level.BODY);
            httpClient = httpClient.newBuilder().addInterceptor(loggingInterceptor).build();
        } else {
            httpClient.interceptors().remove(loggingInterceptor);
            loggingInterceptor = null;
        }
    }
    this.debugging = debugging;
    return this;
}
 

/**
 * Enable/disable debugging for this API client.
 *
 * @param debugging To enable (true) or disable (false) debugging
 * @return ApiClient
 */
public ApiClient setDebugging(boolean debugging) {
    if (debugging != this.debugging) {
        if (debugging) {
            loggingInterceptor = new HttpLoggingInterceptor();
            loggingInterceptor.setLevel(Level.BODY);
            httpClient = httpClient.newBuilder().addInterceptor(loggingInterceptor).build();
        } else {
            httpClient.interceptors().remove(loggingInterceptor);
            loggingInterceptor = null;
        }
    }
    this.debugging = debugging;
    return this;
}
 

/**
 * Creates a {@link OkHttpClient} to start a TLS connection. The OKHttp logging is enabled if the
 * debug log is enabled for {@link HttpClient}.
 */
protected OkHttpClient createHttpsClient() throws GeneralSecurityException {
  TrustManager[] trustManagers = keywhizKeyStore.getTrustManagers();
  KeyManager[] keyManagers = loadKeyMaterial();
  SSLContext sslContext = SSLContext.getInstance("TLSv1.2");
  sslContext.init(keyManagers, trustManagers, new SecureRandom());
  SSLSocketFactory socketFactory = sslContext.getSocketFactory();
  log.info("Keywhiz connect timeout " + keywhiz.getClientTimeout());

  HttpLoggingInterceptor loggingInterceptor =
      new HttpLoggingInterceptor(
          msg -> {
            if (log.isDebugEnabled()) {
              log.debug(msg);
            }
          });
  loggingInterceptor.setLevel(Level.BASIC);

  OkHttpClient.Builder client =
      new OkHttpClient()
          .newBuilder()
          .sslSocketFactory(socketFactory, (X509TrustManager) trustManagers[0])
          .connectionSpecs(singletonList(ConnectionSpec.MODERN_TLS))
          .followSslRedirects(false)
          .retryOnConnectionFailure(true)
          .connectTimeout(keywhiz.getClientTimeout(), SECONDS)
          .readTimeout(keywhiz.getClientTimeout(), SECONDS)
          .writeTimeout(keywhiz.getClientTimeout(), SECONDS)
          .addInterceptor(
              chain -> {
                Request req =
                    chain
                        .request()
                        .newBuilder()
                        .addHeader(CONTENT_TYPE, JSON.toString())
                        .addHeader(USER_AGENT, "OneOps-Secrets-Proxy")
                        .build();
                return chain.proceed(req);
              })
          .addInterceptor(loggingInterceptor);

  if (!isClientAuthEnabled()) {
    log.info("Client auth is disabled. Configuring the cookie manager and XSRF interceptor.");
    cookieMgr = new CookieManager();
    cookieMgr.setCookiePolicy(ACCEPT_ALL);
    client
        .cookieJar(new JavaNetCookieJar(cookieMgr))
        .addNetworkInterceptor(new XsrfTokenInterceptor());
  }
  return client.build();
}
 

static Interceptor buildLoggingInterceptor() {
    final Logger slf4jLogger = LoggerFactory.getLogger("com.linecorp.bot.client.wire");

    return new HttpLoggingInterceptor(slf4jLogger::info)
            .setLevel(Level.BODY);
}
 

private static Interceptor buildLoggingInterceptor() {
    final Logger slf4jLogger = LoggerFactory.getLogger("com.linecorp.bot.client.wire");

    return new HttpLoggingInterceptor(slf4jLogger::info)
            .setLevel(Level.BODY);
}
 

static Interceptor buildLoggingInterceptor() {
    final Logger slf4jLogger = LoggerFactory.getLogger("com.linecorp.bot.client.wire");

    return new HttpLoggingInterceptor(slf4jLogger::info)
            .setLevel(Level.BODY);
}
 

static Interceptor buildLoggingInterceptor() {
    final Logger slf4jLogger = LoggerFactory.getLogger("com.linecorp.bot.client.wire");

    return new HttpLoggingInterceptor(slf4jLogger::info)
            .setLevel(Level.BODY);
}
 

@Provides
@SuppressWarnings("unused") // not actually unused -- used by Dagger
public Level providesLogLevel() {
    return Level.BODY;
}
 

/**
 * Whether to enable or not the current HTTP Logger for every Request, Response and other sensitive information.
 *
 * @param enabled whether to enable the HTTP logger or not.
 */
public void setLoggingEnabled(boolean enabled) {
    logging.setLevel(enabled ? Level.BODY : Level.NONE);
}
 

/**
 * Whether to enable or not the current HTTP Logger for every Request, Response and other sensitive information.
 *
 * @param enabled whether to enable the HTTP logger or not.
 */
public void setLoggingEnabled(boolean enabled) {
    logging.setLevel(enabled ? Level.BODY : Level.NONE);
}