Can define a limit to the amount of content to log

Author: rmistry

google-http-client/src/main/java/com/google/api/client/http/HttpRequest.java

@@ -96,8 +96,27 @@ static String executeAndGetValueOfSomeCustomHeader(HttpRequest request) {
    * Defaults to {@code false}.
    * </p>
    */
+  @Deprecated
   private boolean disableContentLogging;
 
+  /**
+   * Determines the limit to the content size that will be logged during {@link #execute()}.
+   *
+   * <p>
+   * If the content size is greater than this limit then it will not be logged.
+   * </p>
+   *
+   * <p>
+   * Can be set to {@code 0} to disable content logging. This is useful for example if content has
+   * sensitive data such as authentication information.
+   * </p>
+   *
+   * <p>
+   * Defaults to {@code 100000 (100KB)}.
+   * </p>
+   */
+  private int contentLoggingLimit = 100000;
+
   /** HTTP request content or {@code null} for none. */
   private HttpContent content;
 
@@ -278,11 +297,35 @@ public HttpRequest setBackOffPolicy(BackOffPolicy backOffPolicy) {
    * {@link Level#ALL} is loggable which forces all logging).
    *
    * @since 1.5
+   * @deprecated (scheduled to be removed in 1.8) Use {@link #getContentLoggingLimit}
    */
+  @Deprecated
   public boolean getDisableContentLogging() {
     return disableContentLogging;
   }
 
+  /**
+   * Returns the limit to the content size that will be logged during {@link #execute()}.
+   *
+   * <p>
+   * If the content size is greater than this limit then it will not be logged.
+   * </p>
+   *
+   * <p>
+   * Can be set to {@code 0} to disable content logging. This is useful for example if content has
+   * sensitive data such as authentication information.
+   * </p>
+   *
+   * <p>
+   * Defaults to {@code 100000 (100KB)}.
+   * </p>
+   *
+   * @since 1.7
+   */
+  public int getContentLoggingLimit() {
+    return contentLoggingLimit;
+  }
+
   /**
    * Returns whether to disable request content logging during {@link #execute()} (unless
    * {@link Level#ALL} is loggable which forces all logging).
@@ -293,12 +336,39 @@ public boolean getDisableContentLogging() {
    * </p>
    *
    * @since 1.5
+   * @deprecated (scheduled to be removed in 1.8) Use {@link #setContentLoggingLimit}
    */
+  @Deprecated
   public HttpRequest setDisableContentLogging(boolean disableContentLogging) {
     this.disableContentLogging = disableContentLogging;
     return this;
   }
 
+  /**
+   * Set the limit to the content size that will be logged during {@link #execute()}.
+   *
+   * <p>
+   * If the content size is greater than this limit then it will not be logged.
+   * </p>
+   *
+   * <p>
+   * Can be set to {@code 0} to disable content logging. This is useful for example if content has
+   * sensitive data such as authentication information.
+   * </p>
+   *
+   * <p>
+   * Defaults to {@code 100000 (100KB)}.
+   * </p>
+   *
+   * @since 1.7
+   */
+  public HttpRequest setContentLoggingLimit(int contentLoggingLimit) {
+    Preconditions.checkArgument(contentLoggingLimit >= 0,
+        "The content logging limit must be non-negative.");
+    this.contentLoggingLimit = contentLoggingLimit;
+    return this;
+  }
+
   /**
    * Returns the timeout in milliseconds to establish a connection or {@code 0} for an infinite
    * timeout.
@@ -640,7 +710,10 @@ public HttpResponse execute() throws IOException {
         if (contentLength != 0 && contentEncoding == null
             && LogContent.isTextBasedContentType(contentType)
             && (loggable && !disableContentLogging || logger.isLoggable(Level.ALL))) {
-          content = new LogContent(content, contentType, contentEncoding, contentLength);
+          if (contentLength <= contentLoggingLimit && contentLoggingLimit != 0) {
+            content = new LogContent(content, contentType, contentEncoding, contentLength,
+                contentLoggingLimit);
+          }
         }
         // gzip
         if (enableGZipContent) {

google-http-client/src/main/java/com/google/api/client/http/HttpResponse.java

@@ -93,8 +93,27 @@ public final class HttpResponse {
    * {@code false}.
    * </p>
    */
+  @Deprecated
   private boolean disableContentLogging;
 
+  /**
+   * Determines the limit to the content size that will be logged during {@link #getContent()}.
+   *
+   * <p>
+   * If the content size is greater than this limit then it will not be logged.
+   * </p>
+   *
+   * <p>
+   * Can be set to {@code 0} to disable content logging. This is useful for example if content has
+   * sensitive data such as authentication information.
+   * </p>
+   *
+   * <p>
+   * Defaults to {@code 100000 (100KB)}.
+   * </p>
+   */
+  private int contentLoggingLimit = 100000;
+
   HttpResponse(HttpRequest request, LowLevelHttpResponse response) {
     this.request = request;
     transport = request.getTransport();
@@ -191,11 +210,35 @@ public final class HttpResponse {
    * {@link Level#ALL} is loggable which forces all logging).
    *
    * @since 1.5
+   * @deprecated (scheduled to be removed in 1.8) Use {@link #getContentLoggingLimit}
    */
+  @Deprecated
   public boolean getDisableContentLogging() {
     return disableContentLogging;
   }
 
+  /**
+   * Returns the limit to the content size that will be logged during {@link #getContent()}.
+   *
+   * <p>
+   * If the content size is greater than this limit then it will not be logged.
+   * </p>
+   *
+   * <p>
+   * Can be set to {@code 0} to disable content logging. This is useful for example if content has
+   * sensitive data such as authentication information.
+   * </p>
+   *
+   * <p>
+   * Defaults to {@code 100000 (100KB)}.
+   * </p>
+   *
+   * @since 1.7
+   */
+  public int getContentLoggingLimit() {
+    return contentLoggingLimit;
+  }
+
   /**
    * Sets whether to disable response content logging during {@link #getContent()} (unless
    * {@link Level#ALL} is loggable which forces all logging).
@@ -206,12 +249,39 @@ public boolean getDisableContentLogging() {
    * </p>
    *
    * @since 1.5
+   * @deprecated (scheduled to be removed in 1.8) Use {@link #setContentLoggingLimit}
    */
+  @Deprecated
   public HttpResponse setDisableContentLogging(boolean disableContentLogging) {
     this.disableContentLogging = disableContentLogging;
     return this;
   }
 
+  /**
+   * Set the limit to the content size that will be logged during {@link #getContent()}.
+   *
+   * <p>
+   * If the content size is greater than this limit then it will not be logged.
+   * </p>
+   *
+   * <p>
+   * Can be set to {@code 0} to disable content logging. This is useful for example if content has
+   * sensitive data such as authentication information.
+   * </p>
+   *
+   * <p>
+   * Defaults to {@code 100000 (100KB)}.
+   * </p>
+   *
+   * @since 1.7
+   */
+  public HttpResponse setContentLoggingLimit(int contentLoggingLimit) {
+    Preconditions.checkArgument(contentLoggingLimit >= 0,
+        "The content logging limit must be non-negative.");
+    this.contentLoggingLimit = contentLoggingLimit;
+    return this;
+  }
+
   /**
    * Returns the content encoding or {@code null} for none.
    *
@@ -333,7 +403,12 @@ public InputStream getContent() throws IOException {
         // print content using a buffered input stream that can be re-read
         String contentType = this.contentType;
         if (debugContentByteArray.length != 0 && LogContent.isTextBasedContentType(contentType)) {
-          logger.config(Strings.fromBytesUtf8(debugContentByteArray));
+          if (debugContentByteArray.length <= contentLoggingLimit) {
+            logger.config(Strings.fromBytesUtf8(debugContentByteArray));
+          } else {
+            logger.config("Content will not be logged because the content length " + contentLength
+                + " is greater than the content logging limit " + contentLoggingLimit);
+          }
         }
       }
       this.content = content;

google-http-client/src/main/java/com/google/api/client/http/LogContent.java

@@ -15,6 +15,7 @@
 package com.google.api.client.http;
 
 import com.google.api.client.util.Strings;
+import com.google.common.base.Preconditions;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -41,23 +42,29 @@ final class LogContent implements HttpContent {
   private final String contentType;
   private final String contentEncoding;
   private final long contentLength;
+  private final int contentLoggingLimit;
 
   /**
    * @param httpContent another source of HTTP content
    */
-  LogContent(
-      HttpContent httpContent, String contentType, String contentEncoding, long contentLength) {
+  LogContent(HttpContent httpContent, String contentType, String contentEncoding,
+      long contentLength, int contentLoggingLimit) {
     this.httpContent = httpContent;
     this.contentType = contentType;
     this.contentLength = contentLength;
     this.contentEncoding = contentEncoding;
+    Preconditions.checkArgument(contentLoggingLimit >= 0,
+        "The content logging limit must be non-negative.");
+    this.contentLoggingLimit = contentLoggingLimit;
   }
 
   public void writeTo(OutputStream out) throws IOException {
     ByteArrayOutputStream debugStream = new ByteArrayOutputStream();
     httpContent.writeTo(debugStream);
     byte[] debugContent = debugStream.toByteArray();
-    HttpTransport.LOGGER.config(Strings.fromBytesUtf8(debugContent));
+    if (debugContent.length <= contentLoggingLimit) {
+      HttpTransport.LOGGER.config(Strings.fromBytesUtf8(debugContent));
+    }
     out.write(debugContent);
   }
 
@@ -73,6 +80,10 @@ public String getType() {
     return contentType;
   }
 
+  int getContentLoggingLimit() {
+    return contentLoggingLimit;
+  }
+
   /**
    * Returns whether the given content type is text rather than binary data.
    *

google-http-client/src/test/java/com/google/api/client/http/HttpRequestTest.java

@@ -563,6 +563,61 @@ public void setContent(HttpContent content) throws IOException {
     request.execute();
   }
 
+  public void testContentLoggingLimit() throws IOException {
+
+    class MyTransport extends MockHttpTransport {
+
+      boolean expectLogContent;
+
+      @Override
+      public LowLevelHttpRequest buildPostRequest(String url) throws IOException {
+        return new MockLowLevelHttpRequest() {
+          @Override
+          public void setContent(HttpContent content) throws IOException {
+            if (expectLogContent) {
+              assertEquals(LogContent.class, content.getClass());
+            } else {
+              assertEquals(ByteArrayContent.class, content.getClass());
+            }
+            super.setContent(content);
+          }
+        };
+      }
+    }
+    MyTransport transport = new MyTransport();
+    // Set the logging level.
+    HttpTransport.LOGGER.setLevel(java.util.logging.Level.CONFIG);
+    // Create content of length 300.
+    byte[] content = new byte[300];
+    Arrays.fill(content, (byte) ' ');
+    HttpRequest request =
+        transport.createRequestFactory().buildPostRequest(HttpTesting.SIMPLE_GENERIC_URL,
+            new ByteArrayContent("text/html", content));
+
+    // Set the content logging limit to be equal to the length of the content.
+    transport.expectLogContent = true;
+    request.setContentLoggingLimit(300);
+    request.execute();
+
+    // Set the content logging limit to be less than the length of the content.
+    transport.expectLogContent = false;
+    request.setContentLoggingLimit(299);
+    request.execute();
+
+    // Set the content logging limit to 0 to disable content logging.
+    transport.expectLogContent = false;
+    request.setContentLoggingLimit(0);
+    request.execute();
+
+    // Assert that an exception is thrown if content logging limit < 0.
+    try {
+      request.setContentLoggingLimit(-1);
+      fail("Expected: " + IllegalArgumentException.class);
+    } catch (IllegalArgumentException e) {
+      // Expected
+    }
+  }
+
   public void testUserAgent() {
     assertTrue(HttpRequest.USER_AGENT_SUFFIX.contains("Google-HTTP-Java-Client"));
     assertTrue(HttpRequest.USER_AGENT_SUFFIX.contains("gzip"));