feat: add client side logging with slf4j

gax-java/gax-grpc/src/main/java/com/google/api/gax/grpc/GrpcLoggingInterceptor.java

@@ -0,0 +1,118 @@
+package com.google.api.gax.grpc;
+
+import com.google.api.gax.logging.LoggingUtils;
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import io.grpc.*;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import org.slf4j.Logger;
+import org.slf4j.event.Level;
+
+public class GrpcLoggingInterceptor implements ClientInterceptor {
+
+  private static final Logger logger = LoggingUtils.getLogger(GrpcLoggingInterceptor.class);
+  private static final Gson gson = new Gson();
+
+  @Override
+  public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+      MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+
+    Map<String, String> serviceAndRpc = new HashMap<>();
+    Map<String, String> requestLogData = new HashMap<>();
+    Map<String, String> responseLogData = new HashMap<>();
+
+    // Initialize a JsonArray to hold all responses
+    JsonArray responsePayloads = new JsonArray();
+    return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(
+        next.newCall(method, callOptions)) {
+
+      @Override
+      public void start(Listener<RespT> responseListener, Metadata headers) {
+        if (logger.isInfoEnabled()) {
+          String requestId = UUID.randomUUID().toString();
+          String serviceName = method.getServiceName();
+          String methodName = method.getFullMethodName();
+
+          serviceAndRpc.put("serviceName", serviceName);
+          serviceAndRpc.put("rpcName", methodName);
+          serviceAndRpc.put("requestId", requestId);
+        }
+        if (logger.isInfoEnabled() && !logger.isDebugEnabled()) {
+          LoggingUtils.logWithMDC(logger, Level.INFO, serviceAndRpc, "Sending gRPC request");
+        }
+
+        if (logger.isDebugEnabled()) {
+          requestLogData.putAll(serviceAndRpc);
+
+          JsonObject requestHeaders = mapHeadersToJsonObject(headers);
+          requestLogData.put("request.headers", gson.toJson(requestHeaders));
+        }
+
+        super.start(
+            new ForwardingClientCallListener.SimpleForwardingClientCallListener<RespT>(
+                responseListener) {
+              @Override
+              public void onMessage(RespT message) {
+                if (logger.isDebugEnabled()) {
+                  // Add each message to the array
+                  responsePayloads.add(gson.toJsonTree(message));
+                }
+                super.onMessage(message);
+              }
+
+              @Override
+              public void onClose(Status status, Metadata trailers) {
+                if (logger.isInfoEnabled()) {
+                  serviceAndRpc.put("response.status", status.getCode().name());
+                  responseLogData.putAll(serviceAndRpc);
+                }
+                if (logger.isInfoEnabled() && !logger.isDebugEnabled()) {
+                  LoggingUtils.logWithMDC(logger, Level.INFO, serviceAndRpc, "Received response.");
+                }
+                if (logger.isDebugEnabled()) {
+                  // Access and add response headers
+                  JsonObject responseHeaders = mapHeadersToJsonObject(trailers);
+                  responseLogData.put("response.headers", gson.toJson(responseHeaders));
+                  // Add the array of payloads to the responseLogData
+                  responseLogData.put("response.payload", gson.toJson(responsePayloads));
+
+                  LoggingUtils.logWithMDC(
+                      logger, Level.DEBUG, responseLogData, "Received response.");
+                }
+
+                super.onClose(status, trailers);
+              }
+            },
+            headers);
+      }
+
+      @Override
+      public void sendMessage(ReqT message) {
+
+        if (logger.isDebugEnabled()) {
+          requestLogData.put("request.payload", gson.toJson(message));
+          LoggingUtils.logWithMDC(logger, Level.DEBUG, requestLogData, "Sending gRPC request.");
+        }
+
+        super.sendMessage(message);
+      }
+    };
+  }
+
+  private static JsonObject mapHeadersToJsonObject(Metadata headers) {
+    JsonObject jsonHeaders = new JsonObject();
+    headers
+        .keys()
+        .forEach(
+            key -> {
+              Metadata.Key<String> metadataKey =
+                  Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER);
+              String headerValue = headers.get(metadataKey);
+              jsonHeaders.addProperty(key, headerValue);
+            });
+    return jsonHeaders;
+  }
+}

gax-java/gax-grpc/src/main/java/com/google/api/gax/grpc/InstantiatingGrpcChannelProvider.java

@@ -467,6 +467,7 @@ private ManagedChannel createSingleChannel() throws IOException {
     builder =
         builder
             .intercept(new GrpcChannelUUIDInterceptor())
+            .intercept(new GrpcLoggingInterceptor())
             .intercept(headerInterceptor)
             .intercept(metadataHandlerInterceptor)
             .userAgent(headerInterceptor.getUserAgentHeader())

gax-java/gax-httpjson/src/main/java/com/google/api/gax/httpjson/HttpJsonLoggingInterceptor.java

@@ -0,0 +1,116 @@
+package com.google.api.gax.httpjson;
+
+import com.google.api.gax.httpjson.ForwardingHttpJsonClientCall.SimpleForwardingHttpJsonClientCall;
+import com.google.api.gax.logging.LoggingUtils;
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import org.slf4j.Logger;
+import org.slf4j.event.Level;
+
+public class HttpJsonLoggingInterceptor implements HttpJsonClientInterceptor {
+
+  private static final Logger logger = LoggingUtils.getLogger(HttpJsonLoggingInterceptor.class);
+  private static final Gson gson = new Gson();
+
+  @Override
+  public <ReqT, RespT> HttpJsonClientCall<ReqT, RespT> interceptCall(
+      ApiMethodDescriptor<ReqT, RespT> method,
+      HttpJsonCallOptions callOptions,
+      HttpJsonChannel next) {
+    Map<String, String> requestLogData = new HashMap<>();
+
+    // Initialize a JsonArray to hold all responses
+    JsonArray responsePayloads = new JsonArray();
+    String endpoint = ((ManagedHttpJsonChannel) next).getEndpoint();
+    return new SimpleForwardingHttpJsonClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {
+      @Override
+      public void start(
+          HttpJsonClientCall.Listener<RespT> responseListener, HttpJsonMetadata headers) {
+
+        Map<String, String> serviceAndRpc = new HashMap<>();
+        if (logger.isInfoEnabled()) {
+          String requestId = UUID.randomUUID().toString();
+          // Capture request details
+          String methodName = method.getFullMethodName();
+          String httpMethod = method.getHttpMethod();
+          serviceAndRpc.put("rpcName", methodName);
+          serviceAndRpc.put("requestId", requestId);
+          requestLogData.putAll(serviceAndRpc);
+          requestLogData.put("request.url", endpoint);
+          requestLogData.put("request.method", httpMethod);
+        }
+        if (logger.isDebugEnabled()) {
+          // Capture and log headers
+          JsonObject jsonHeaders = new JsonObject();
+          headers
+              .getHeaders()
+              .forEach((key, value) -> jsonHeaders.addProperty(key, value.toString()));
+          requestLogData.put("request.headers", gson.toJson(jsonHeaders));
+        }
+
+        if (logger.isInfoEnabled() && !logger.isDebugEnabled()) {
+          LoggingUtils.logWithMDC(logger, Level.INFO, serviceAndRpc, "Sending HTTP request");
+        }
+        Map<String, String> responseLogData = new HashMap<>();
+        super.start(
+            new HttpJsonClientCall.Listener<RespT>() {
+              @Override
+              public void onMessage(RespT message) {
+                if (logger.isDebugEnabled()) {
+                  // Add each message to the array
+                  responsePayloads.add(gson.toJsonTree(message));
+                }
+                responseListener.onMessage(message);
+              }
+
+              @Override
+              public void onClose(int status, HttpJsonMetadata trailers) {
+                if (logger.isInfoEnabled()) {
+
+                  serviceAndRpc.put("response.status", String.valueOf(status));
+                  responseLogData.putAll(serviceAndRpc);
+                }
+                if (logger.isInfoEnabled() && !logger.isDebugEnabled()) {
+                  LoggingUtils.logWithMDC(
+                      logger, Level.INFO, serviceAndRpc, "HTTP request finished.");
+                }
+                if (logger.isDebugEnabled()) {
+
+                  JsonObject jsonHeaders = new JsonObject();
+                  headers
+                      .getHeaders()
+                      .forEach((key, value) -> jsonHeaders.addProperty(key, value.toString()));
+                  responseLogData.put("response.headers", gson.toJson(jsonHeaders));
+
+                  // Add the array of payloads to the responseLogData
+                  responseLogData.put("response.payload", gson.toJson(responsePayloads));
+                  LoggingUtils.logWithMDC(
+                      logger,
+                      Level.DEBUG,
+                      responseLogData,
+                      "Received response header and payload.");
+                }
+
+                responseListener.onClose(status, trailers);
+              }
+            },
+            headers);
+      }
+
+      @Override
+      public void sendMessage(ReqT message) {
+        if (logger.isDebugEnabled()) {
+          requestLogData.put("request.payload", gson.toJson(message));
+          LoggingUtils.logWithMDC(
+              logger, Level.DEBUG, requestLogData, "HTTP request header and payload.");
+        }
+
+        super.sendMessage(message);
+      }
+    };
+  }
+}

gax-java/gax-httpjson/src/main/java/com/google/api/gax/httpjson/InstantiatingHttpJsonChannelProvider.java

@@ -196,6 +196,7 @@ private HttpJsonTransportChannel createChannel() throws IOException, GeneralSecu
     HttpJsonClientInterceptor headerInterceptor =
         new HttpJsonHeaderInterceptor(headerProvider.getHeaders());
 
+    channel = new ManagedHttpJsonInterceptorChannel(channel, new HttpJsonLoggingInterceptor());
     channel = new ManagedHttpJsonInterceptorChannel(channel, headerInterceptor);
     if (interceptorProvider != null && interceptorProvider.getInterceptors() != null) {
       for (HttpJsonClientInterceptor interceptor : interceptorProvider.getInterceptors()) {

gax-java/gax-httpjson/src/main/java/com/google/api/gax/httpjson/ManagedHttpJsonChannel.java

@@ -57,6 +57,10 @@ protected ManagedHttpJsonChannel() {
     this(null, true, null, null);
   }
 
+  String getEndpoint() {
+    return endpoint;
+  }
+
   private ManagedHttpJsonChannel(
       Executor executor,
       boolean usingDefaultExecutor,

gax-java/gax/pom.xml

@@ -69,6 +69,12 @@
       <artifactId>opentelemetry-api</artifactId>
       <optional>true</optional>
     </dependency>
+    <!--    Logging dependency    -->
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-api</artifactId>
+      <version>2.0.16</version>
+    </dependency>
   </dependencies>
 
   <build>

gax-java/gax/src/main/java/com/google/api/gax/logging/JsonContextMapHandler.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google LLC nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.google.api.gax.logging;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.ConsoleHandler;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+
+public class JsonContextMapHandler extends Handler {
+
+  private final Gson gson = new GsonBuilder().setPrettyPrinting().create();
+
+  @Override
+  public void publish(LogRecord record) {
+    Object[] params = record.getParameters();
+
+    ConsoleHandler consoleHandler = new ConsoleHandler();
+    if (params != null && params.length > 0 && params[0] instanceof Map) {
+      @SuppressWarnings("unchecked")
+      Map<String, String> contextMap = (Map<String, String>) params[0];
+
+      // Create a map to hold all log data
+      Map<String, Object> logData = new HashMap<>();
+      logData.put("message", record.getMessage());
+      logData.put("severity", record.getLevel().getName());
+      logData.put("timestamp", record.getMillis());
+      logData.put("logger", record.getLoggerName());
+
+      // Add all context data to the top level
+      logData.putAll(contextMap);
+
+      // Convert to JSON
+      String jsonLog = gson.toJson(logData);
+
+      LogRecord jsonRecord = new LogRecord(record.getLevel(), jsonLog);
+      consoleHandler.publish(jsonRecord);
+    } else {
+      // Handle cases where the context map is not present
+      LogRecord messageRecord =
+          new LogRecord(record.getLevel(), "Log message without context: " + record.getMessage());
+      consoleHandler.publish(messageRecord);
+    }
+  }
+
+  @Override
+  public void flush() {}
+
+  @Override
+  public void close() throws SecurityException {}
+}