grpc 1.64.0.pre1 → 1.65.0.pre1

data/src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_privacy_integrity_record_protocol.cc

@@ -18,6 +18,8 @@
 
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_privacy_integrity_record_protocol.h"
 
+#include "absl/log/log.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
@@ -60,7 +62,7 @@ static tsi_result alts_grpc_privacy_integrity_protect(
           rp->iovec_rp, rp->iovec_buf, unprotected_slices->count,
           protected_iovec, &error_details);
   if (status != GRPC_STATUS_OK) {
-    gpr_log(GPR_ERROR, "Failed to protect, %s", error_details);
+    LOG(ERROR) << "Failed to protect, " << error_details;
     gpr_free(error_details);
     grpc_core::CSliceUnref(protected_slice);
     return TSI_INTERNAL_ERROR;
@@ -84,7 +86,7 @@ static tsi_result alts_grpc_privacy_integrity_unprotect(
   // Allocates memory for output frame. In privacy-integrity unprotect, the
   // unprotected data are stored in a newly allocated buffer.
   if (protected_slices->length < rp->header_length + rp->tag_length) {
-    gpr_log(GPR_ERROR, "Protected slices do not have sufficient data.");
+    LOG(ERROR) << "Protected slices do not have sufficient data.";
     return TSI_INVALID_ARGUMENT;
   }
   size_t unprotected_frame_size =
@@ -105,7 +107,7 @@ static tsi_result alts_grpc_privacy_integrity_unprotect(
           rp->iovec_rp, header_iovec, rp->iovec_buf, protected_slices->count,
           unprotected_iovec, &error_details);
   if (status != GRPC_STATUS_OK) {
-    gpr_log(GPR_ERROR, "Failed to unprotect, %s", error_details);
+    LOG(ERROR) << "Failed to unprotect, " << error_details;
     gpr_free(error_details);
     grpc_core::CSliceUnref(unprotected_slice);
     return TSI_INTERNAL_ERROR;

data/src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol_common.cc

@@ -26,10 +26,10 @@
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/util/useful.h"
 
 const size_t kInitialIovecBufferSize = 8;
 

data/src/core/tsi/alts/zero_copy_frame_protector/alts_zero_copy_grpc_protector.cc

@@ -24,6 +24,7 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -93,7 +94,7 @@ static bool read_frame_size(const grpc_slice_buffer* sb,
                         (static_cast<uint32_t>(frame_size_buffer[1]) << 8) |
                         static_cast<uint32_t>(frame_size_buffer[0]);
   if (frame_size > kMaxFrameLength) {
-    gpr_log(GPR_ERROR, "Frame size is larger than maximum frame size");
+    LOG(ERROR) << "Frame size is larger than maximum frame size";
     return false;
   }
   // Returns frame size including frame length field.
@@ -124,7 +125,7 @@ static tsi_result create_alts_grpc_record_protocol(
                                             kAesGcmTagLength, &crypter,
                                             &error_details);
   if (status != GRPC_STATUS_OK) {
-    gpr_log(GPR_ERROR, "Failed to create AEAD crypter, %s", error_details);
+    LOG(ERROR) << "Failed to create AEAD crypter, " << error_details;
     gpr_free(error_details);
     return TSI_INTERNAL_ERROR;
   }
@@ -153,7 +154,7 @@ static tsi_result alts_zero_copy_grpc_protector_protect(
     grpc_slice_buffer* protected_slices) {
   if (self == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
-    gpr_log(GPR_ERROR, "Invalid nullptr arguments to zero-copy grpc protect.");
+    LOG(ERROR) << "Invalid nullptr arguments to zero-copy grpc protect.";
     return TSI_INVALID_ARGUMENT;
   }
   alts_zero_copy_grpc_protector* protector =

data/src/core/tsi/fake_transport_security.cc

@@ -22,16 +22,17 @@
 #include <string.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/tsi/transport_security_grpc.h"
+#include "src/core/tsi/transport_security_interface.h"
 
 // --- Constants. ---
 #define TSI_FAKE_FRAME_HEADER_SIZE 4
@@ -91,7 +92,7 @@ static const char* tsi_fake_handshake_message_strings[] = {
 
 static const char* tsi_fake_handshake_message_to_string(int msg) {
   if (msg < 0 || msg >= TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
-    gpr_log(GPR_ERROR, "Invalid message %d", msg);
+    LOG(ERROR) << "Invalid message " << msg;
     return "UNKNOWN";
   }
   return tsi_fake_handshake_message_strings[msg];
@@ -107,7 +108,7 @@ static tsi_result tsi_fake_handshake_message_from_string(
       return TSI_OK;
     }
   }
-  gpr_log(GPR_ERROR, "Invalid handshake message.");
+  LOG(ERROR) << "Invalid handshake message.";
   if (error != nullptr) *error = "invalid handshake message";
   return TSI_DATA_CORRUPTED;
 }
@@ -312,8 +313,8 @@ static tsi_result fake_protector_protect(tsi_frame_protector* self,
     result = tsi_fake_frame_decode(frame_header, &written_in_frame_size, frame,
                                    /*error=*/nullptr);
     if (result != TSI_INCOMPLETE_DATA) {
-      gpr_log(GPR_ERROR, "tsi_fake_frame_decode returned %s",
-              tsi_result_to_string(result));
+      LOG(ERROR) << "tsi_fake_frame_decode returned "
+                 << tsi_result_to_string(result);
       return result;
     }
   }
@@ -469,7 +470,7 @@ static tsi_result fake_zero_copy_grpc_protector_unprotect(
     if (impl->parsed_frame_size == 0) {
       impl->parsed_frame_size = read_frame_size(&impl->protected_sb);
       if (impl->parsed_frame_size <= 4) {
-        gpr_log(GPR_ERROR, "Invalid frame size.");
+        LOG(ERROR) << "Invalid frame size.";
         return TSI_DATA_CORRUPTED;
       }
     }
@@ -639,7 +640,7 @@ static tsi_result fake_handshaker_get_bytes_to_send_to_peer(
     if (next_message_to_send > TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
       next_message_to_send = TSI_FAKE_HANDSHAKE_MESSAGE_MAX;
     }
-    if (GRPC_TRACE_FLAG_ENABLED(tsi_tracing_enabled)) {
+    if (GRPC_TRACE_FLAG_ENABLED(tsi)) {
       gpr_log(GPR_INFO, "%s prepared %s.",
               impl->is_client ? "Client" : "Server",
               tsi_fake_handshake_message_to_string(impl->next_message_to_send));
@@ -652,9 +653,7 @@ static tsi_result fake_handshaker_get_bytes_to_send_to_peer(
   if (!impl->is_client &&
       impl->next_message_to_send == TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
     // We're done.
-    if (GRPC_TRACE_FLAG_ENABLED(tsi_tracing_enabled)) {
-      gpr_log(GPR_INFO, "Server is done.");
-    }
+    GRPC_TRACE_LOG(tsi, INFO) << "Server is done.";
     impl->result = TSI_OK;
   } else {
     impl->needs_incoming_message = 1;
@@ -693,17 +692,15 @@ static tsi_result fake_handshaker_process_bytes_from_peer(
             tsi_fake_handshake_message_to_string(received_msg),
             tsi_fake_handshake_message_to_string(expected_msg));
   }
-  if (GRPC_TRACE_FLAG_ENABLED(tsi_tracing_enabled)) {
-    gpr_log(GPR_INFO, "%s received %s.", impl->is_client ? "Client" : "Server",
-            tsi_fake_handshake_message_to_string(received_msg));
-  }
+  GRPC_TRACE_LOG(tsi, INFO)
+      << (impl->is_client ? "Client" : "Server") << " received "
+      << tsi_fake_handshake_message_to_string(received_msg);
   tsi_fake_frame_reset(&impl->incoming_frame, 0 /* needs_draining */);
   impl->needs_incoming_message = 0;
   if (impl->next_message_to_send == TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
     // We're done.
-    if (GRPC_TRACE_FLAG_ENABLED(tsi_tracing_enabled)) {
-      gpr_log(GPR_INFO, "%s is done.", impl->is_client ? "Client" : "Server");
-    }
+    GRPC_TRACE_LOG(tsi, INFO)
+        << (impl->is_client ? "Client" : "Server") << " is done.";
     impl->result = TSI_OK;
   }
   return TSI_OK;

data/src/core/tsi/local_transport_security.cc

@@ -22,8 +22,9 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "absl/log/log.h"
+
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
@@ -68,7 +69,7 @@ tsi_result handshaker_result_get_unused_bytes(const tsi_handshaker_result* self,
                                               const unsigned char** bytes,
                                               size_t* bytes_size) {
   if (self == nullptr || bytes == nullptr || bytes_size == nullptr) {
-    gpr_log(GPR_ERROR, "Invalid arguments to get_unused_bytes()");
+    LOG(ERROR) << "Invalid arguments to get_unused_bytes()";
     return TSI_INVALID_ARGUMENT;
   }
   auto* result = reinterpret_cast<local_tsi_handshaker_result*>(
@@ -101,7 +102,7 @@ tsi_result create_handshaker_result(const unsigned char* received_bytes,
                                     size_t received_bytes_size,
                                     tsi_handshaker_result** self) {
   if (self == nullptr) {
-    gpr_log(GPR_ERROR, "Invalid arguments to create_handshaker_result()");
+    LOG(ERROR) << "Invalid arguments to create_handshaker_result()";
     return TSI_INVALID_ARGUMENT;
   }
   local_tsi_handshaker_result* result =
@@ -128,7 +129,7 @@ tsi_result handshaker_next(tsi_handshaker* self,
                            tsi_handshaker_on_next_done_cb /*cb*/,
                            void* /*user_data*/, std::string* error) {
   if (self == nullptr) {
-    gpr_log(GPR_ERROR, "Invalid arguments to handshaker_next()");
+    LOG(ERROR) << "Invalid arguments to handshaker_next()";
     if (error != nullptr) *error = "invalid argument";
     return TSI_INVALID_ARGUMENT;
   }
@@ -164,7 +165,7 @@ const tsi_handshaker_vtable handshaker_vtable = {
 
 tsi_result tsi_local_handshaker_create(tsi_handshaker** self) {
   if (self == nullptr) {
-    gpr_log(GPR_ERROR, "Invalid arguments to local_tsi_handshaker_create()");
+    LOG(ERROR) << "Invalid arguments to local_tsi_handshaker_create()";
     return TSI_INVALID_ARGUMENT;
   }
   local_tsi_handshaker* handshaker = grpc_core::Zalloc<local_tsi_handshaker>();

data/src/core/tsi/ssl/session_cache/ssl_session_cache.cc

@@ -19,6 +19,7 @@
 #include "src/core/tsi/ssl/session_cache/ssl_session_cache.h"
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
@@ -64,9 +65,8 @@ class SslSessionLRUCache::Node {
 
 SslSessionLRUCache::SslSessionLRUCache(size_t capacity) : capacity_(capacity) {
   if (capacity == 0) {
-    gpr_log(
-        GPR_ERROR,
-        "SslSessionLRUCache capacity is zero. SSL sessions cannot be resumed.");
+    LOG(ERROR) << "SslSessionLRUCache capacity is zero. SSL sessions cannot be "
+                  "resumed.";
   }
 }
 
@@ -100,7 +100,7 @@ SslSessionLRUCache::Node* SslSessionLRUCache::FindLocked(
 
 void SslSessionLRUCache::Put(const char* key, SslSessionPtr session) {
   if (session == nullptr) {
-    gpr_log(GPR_ERROR, "Attempted to put null SSL session in session cache.");
+    LOG(ERROR) << "Attempted to put null SSL session in session cache.";
     return;
   }
   grpc_core::MutexLock lock(&lock_);