Add HTTP logging config to HttpConfigOptions (#53)

* feat: Add logging level to HTTP config options

* refactor: Ensure input stream requests can always be sent properly regardless of logging

* refactor: Deprecate HttpLogging in favor of new config option

* chore: Remove old logging config file

* test: Test for setting HTTP logging level

Author: lpatino10

src/main/java/com/ibm/cloud/sdk/core/http/HttpClientSingleton.java

@@ -12,14 +12,15 @@
  */
 package com.ibm.cloud.sdk.core.http;
 
+import com.ibm.cloud.sdk.core.http.HttpConfigOptions.LoggingLevel;
 import com.ibm.cloud.sdk.core.service.BaseService;
 import com.ibm.cloud.sdk.core.service.security.DelegatingSSLSocketFactory;
-import com.ibm.cloud.sdk.core.util.HttpLogging;
 import okhttp3.Authenticator;
 import okhttp3.ConnectionSpec;
 import okhttp3.OkHttpClient;
 import okhttp3.OkHttpClient.Builder;
 import okhttp3.TlsVersion;
+import okhttp3.logging.HttpLoggingInterceptor;
 
 import javax.net.ssl.HostnameVerifier;
 import javax.net.ssl.SSLContext;
@@ -115,8 +116,6 @@ private OkHttpClient configureHttpClient() {
     builder.writeTimeout(60, TimeUnit.SECONDS);
     builder.readTimeout(90, TimeUnit.SECONDS);
 
-    builder.addNetworkInterceptor(HttpLogging.getLoggingInterceptor());
-
     ConnectionSpec spec = new ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS).allEnabledCipherSuites().build();
     builder.connectionSpecs(Arrays.asList(spec, ConnectionSpec.CLEARTEXT));
 
@@ -190,6 +189,35 @@ private OkHttpClient setProxyAuthenticator(OkHttpClient client, Authenticator pr
     return builder.build();
   }
 
+  /**
+   * Sets the logging level for the specified {@link OkHttpClient} instance and returns
+   * a new instance with the logging configured as requested.
+   *
+   * @param client the {@link OkHttpClient} instance to set the proxy authenticator on
+   * @param loggingLevel the {@link LoggingLevel}
+   * @return the new {@link OkHttpClient} instance with the logging configured
+   */
+  private OkHttpClient setLoggingLevel(OkHttpClient client, LoggingLevel loggingLevel) {
+    HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
+
+    switch (loggingLevel) {
+      case BODY:
+        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
+        break;
+      case HEADERS:
+        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.HEADERS);
+        break;
+      case BASIC:
+        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BASIC);
+        break;
+      default:
+        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.NONE);
+    }
+    OkHttpClient.Builder builder = client.newBuilder().addNetworkInterceptor(loggingInterceptor);
+
+    return builder.build();
+  }
+
   /**
    * Specifically enable all TLS protocols. See: https://github.com/watson-developer-cloud/java-sdk/issues/610
    *
@@ -276,6 +304,9 @@ public OkHttpClient configureClient(OkHttpClient client, HttpConfigOptions optio
       if (options.getProxyAuthenticator() != null) {
         client = setProxyAuthenticator(client, options.getProxyAuthenticator());
       }
+      if (options.getLoggingLevel() != null) {
+        client = setLoggingLevel(client, options.getLoggingLevel());
+      }
     }
     return client;
   }

src/main/java/com/ibm/cloud/sdk/core/http/HttpConfigOptions.java

@@ -8,9 +8,21 @@
  * Options class for configuring the HTTP client.
  */
 public class HttpConfigOptions {
+
+  /**
+   * Levels of information to log when making HTTP requests, from least (NONE) to most (BODY).
+   */
+  public enum LoggingLevel {
+    NONE,
+    BASIC,
+    HEADERS,
+    BODY,
+  }
+
   private boolean disableSslVerification;
   private Proxy proxy;
   private Authenticator proxyAuthenticator;
+  private LoggingLevel loggingLevel;
 
   public boolean shouldDisableSslVerification() {
     return this.disableSslVerification;
@@ -24,10 +36,15 @@ public Authenticator getProxyAuthenticator() {
     return this.proxyAuthenticator;
   }
 
+  public LoggingLevel getLoggingLevel() {
+    return this.loggingLevel;
+  }
+
   public static class Builder {
     private boolean disableSslVerification;
     private Proxy proxy;
     private Authenticator proxyAuthenticator;
+    private LoggingLevel loggingLevel;
 
     public HttpConfigOptions build() {
       return new HttpConfigOptions(this);
@@ -67,11 +84,22 @@ public Builder proxyAuthenticator(Authenticator proxyAuthenticator) {
       return this;
     }
 
+    /**
+     * Sets HTTP logging level to be used by the current client.
+     *
+     * @param loggingLevel the {@link LoggingLevel} specifying how much information should be logged
+     * @return the builder
+     */
+    public Builder loggingLevel(LoggingLevel loggingLevel) {
+      this.loggingLevel = loggingLevel;
+      return this;
+    }
   }
 
   private HttpConfigOptions(Builder builder) {
     this.disableSslVerification = builder.disableSslVerification;
     this.proxy = builder.proxy;
     this.proxyAuthenticator = builder.proxyAuthenticator;
+    this.loggingLevel = builder.loggingLevel;
   }
 }

src/main/java/com/ibm/cloud/sdk/core/http/InputStreamRequestBody.java

@@ -12,21 +12,18 @@
  */
 package com.ibm.cloud.sdk.core.http;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-
 import okhttp3.MediaType;
 import okhttp3.RequestBody;
 import okhttp3.internal.Util;
-import okhttp3.logging.HttpLoggingInterceptor;
 import okio.BufferedSink;
 import okio.Okio;
 import okio.Source;
 import org.apache.commons.io.IOUtils;
 
-import com.ibm.cloud.sdk.core.util.HttpLogging;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
 
 /**
  * RequestBody that takes an {@link InputStream}.
@@ -53,18 +50,15 @@ private InputStreamRequestBody(InputStream inputStream, MediaType mediaType) {
     this.inputStream = inputStream;
     this.mediaType = mediaType;
 
-    // if we're logging everything, we'll need to store the bytes to reuse later
-    if (HttpLogging.getLoggingInterceptor().getLevel().equals(HttpLoggingInterceptor.Level.BODY)) {
-      ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-
-      try {
-        IOUtils.copy(inputStream, outputStream);
-      } catch (IOException e) {
-        e.printStackTrace();
-      }
+    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
 
-      this.bytes = outputStream.toByteArray();
+    try {
+      IOUtils.copy(inputStream, outputStream);
+    } catch (IOException e) {
+      e.printStackTrace();
     }
+
+    this.bytes = outputStream.toByteArray();
   }
 
   /*

src/main/java/com/ibm/cloud/sdk/core/util/HttpLogging.java

@@ -23,6 +23,9 @@
  * Instantiates a new HTTP logging. The logging level will be determinate by the {@link Logger} used in this class.
  * Basic HTTP request response will be log if Level is INFO, HEADERS if level is FINE and all the bodies if Level is
  * ALL.
+ *
+ * @deprecated This class functionality is now handled by {@link com.ibm.cloud.sdk.core.http.HttpConfigOptions} and
+ * should no longer be needed.
  */
 public class HttpLogging {
   private static final Logger LOG = Logger.getLogger(HttpLogging.class.getName());

src/test/java/com/ibm/cloud/sdk/core/test/http/HttpConfigTest.java

@@ -35,10 +35,12 @@ public Request authenticate(@Nullable Route route, Response response) throws IOE
         .disableSslVerification(true)
         .proxy(proxy)
         .proxyAuthenticator(authenticator)
+        .loggingLevel(HttpConfigOptions.LoggingLevel.HEADERS)
         .build();
 
     assertEquals(true, configOptions.shouldDisableSslVerification());
     assertEquals(authenticator, configOptions.getProxyAuthenticator());
     assertEquals(proxy, configOptions.getProxy());
+    assertEquals(HttpConfigOptions.LoggingLevel.HEADERS, configOptions.getLoggingLevel());
   }
 }