grpc 1.65.1 → 1.66.0.pre3

data/src/core/telemetry/call_tracer.h

@@ -110,6 +110,19 @@ class CallTracerInterface : public CallTracerAnnotationInterface {
   virtual void RecordReceivedDecompressedMessage(
       const SliceBuffer& recv_decompressed_message) = 0;
   virtual void RecordCancel(grpc_error_handle cancel_error) = 0;
+
+  struct TransportByteSize {
+    uint64_t framing_bytes = 0;
+    uint64_t data_bytes = 0;
+    uint64_t header_bytes = 0;
+
+    TransportByteSize& operator+=(const TransportByteSize& other);
+  };
+  virtual void RecordIncomingBytes(
+      const TransportByteSize& transport_byte_size) = 0;
+  virtual void RecordOutgoingBytes(
+      const TransportByteSize& transport_byte_size) = 0;
+
   // Traces a new TCP transport attempt for this call attempt. Note the TCP
   // transport may finish tracing and unref the TCP tracer before or after the
   // call completion in gRPC core. No TCP tracing when null is returned.
@@ -144,6 +157,8 @@ class ClientCallTracer : public CallTracerAnnotationInterface {
     // will be null.
     virtual void RecordReceivedTrailingMetadata(
         absl::Status status, grpc_metadata_batch* recv_trailing_metadata,
+        // TODO(roth): Remove this argument when the
+        // call_tracer_in_transport experiment finishes rolling out.
         const grpc_transport_stream_stats* transport_stream_stats) = 0;
     // Should be the last API call to the object. Once invoked, the tracer
     // library is free to destroy the object.

data/src/core/telemetry/metrics.h

@@ -461,14 +461,7 @@ class GlobalStatsPluginRegistry {
     template <typename... Args>
     GRPC_MUST_USE_RESULT std::unique_ptr<RegisteredMetricCallback>
     RegisterCallback(absl::AnyInvocable<void(CallbackMetricReporter&)> callback,
-                     Duration min_interval, Args... args) {
-      AssertIsCallbackGaugeHandle(args...);
-      return std::make_unique<RegisteredMetricCallback>(
-          *this, std::move(callback),
-          std::vector<GlobalInstrumentsRegistry::GlobalInstrumentHandle>{
-              args...},
-          min_interval);
-    }
+                     Duration min_interval, Args... args);
 
     // Adds all available client call tracers associated with the stats plugins
     // within the group to \a call_context.
@@ -557,6 +550,18 @@ class RegisteredMetricCallback {
   Duration min_interval_;
 };
 
+template <typename... Args>
+inline std::unique_ptr<RegisteredMetricCallback>
+GlobalStatsPluginRegistry::StatsPluginGroup::RegisterCallback(
+    absl::AnyInvocable<void(CallbackMetricReporter&)> callback,
+    Duration min_interval, Args... args) {
+  AssertIsCallbackGaugeHandle(args...);
+  return std::make_unique<RegisteredMetricCallback>(
+      *this, std::move(callback),
+      std::vector<GlobalInstrumentsRegistry::GlobalInstrumentHandle>{args...},
+      min_interval);
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_TELEMETRY_METRICS_H

data/src/core/tsi/alts/frame_protector/frame_handler.cc

@@ -24,8 +24,9 @@
 
 #include <algorithm>
 
+#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/gprpp/crash.h"
@@ -57,7 +58,7 @@ bool alts_reset_frame_writer(alts_frame_writer* writer,
   if (buffer == nullptr) return false;
   size_t max_input_size = SIZE_MAX - kFrameLengthFieldSize;
   if (length > max_input_size) {
-    gpr_log(GPR_ERROR, "length must be at most %zu", max_input_size);
+    LOG(ERROR) << "length must be at most " << max_input_size;
     return false;
   }
   writer->input_buffer = buffer;
@@ -181,17 +182,17 @@ bool alts_read_frame_bytes(alts_frame_reader* reader,
     size_t frame_length = load_32_le(reader->header_buffer);
     if (frame_length < kFrameMessageTypeFieldSize ||
         frame_length > kFrameMaxSize) {
-      gpr_log(GPR_ERROR,
-              "Bad frame length (should be at least %zu, and at most %zu)",
-              kFrameMessageTypeFieldSize, kFrameMaxSize);
+      LOG(ERROR) << "Bad frame length (should be at least "
+                 << kFrameMessageTypeFieldSize << ", and at most "
+                 << kFrameMaxSize << ")";
       *bytes_size = 0;
       return false;
     }
     size_t message_type =
         load_32_le(reader->header_buffer + kFrameLengthFieldSize);
     if (message_type != kFrameMessageType) {
-      gpr_log(GPR_ERROR, "Unsupported message type %zu (should be %zu)",
-              message_type, kFrameMessageType);
+      LOG(ERROR) << "Unsupported message type " << message_type
+                 << " (should be " << kFrameMessageType << ")";
       *bytes_size = 0;
       return false;
     }

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -27,7 +27,6 @@
 
 #include <grpc/byte_buffer.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -221,22 +220,22 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
   }
   // TSI handshake has been shutdown.
   if (alts_tsi_handshaker_has_shutdown(handshaker)) {
-    LOG(INFO) << "TSI handshake shutdown";
+    VLOG(2) << "TSI handshake shutdown";
     handle_response_done(client, TSI_HANDSHAKE_SHUTDOWN,
                          "TSI handshake shutdown", nullptr, 0, nullptr);
     return;
   }
   // Check for failed grpc read.
   if (!is_ok || client->inject_read_failure) {
-    LOG(INFO) << "read failed on grpc call to handshaker service";
+    VLOG(2) << "read failed on grpc call to handshaker service";
     handle_response_done(client, TSI_INTERNAL_ERROR,
                          "read failed on grpc call to handshaker service",
                          nullptr, 0, nullptr);
     return;
   }
   if (recv_buffer == nullptr) {
-    gpr_log(GPR_ERROR,
-            "recv_buffer is nullptr in alts_tsi_handshaker_handle_response()");
+    LOG(ERROR)
+        << "recv_buffer is nullptr in alts_tsi_handshaker_handle_response()";
     handle_response_done(
         client, TSI_INTERNAL_ERROR,
         "recv_buffer is nullptr in alts_tsi_handshaker_handle_response()",
@@ -471,11 +470,10 @@ static void on_status_received(void* arg, grpc_error_handle error) {
     // status from the final ALTS message with the status here.
     char* status_details =
         grpc_slice_to_c_string(client->handshake_status_details);
-    gpr_log(GPR_INFO,
-            "alts_grpc_handshaker_client:%p on_status_received "
-            "status:%d details:|%s| error:|%s|",
-            client, client->handshake_status_code, status_details,
-            grpc_core::StatusToString(error).c_str());
+    VLOG(2) << "alts_grpc_handshaker_client:" << client
+            << " on_status_received status:" << client->handshake_status_code
+            << " details:|" << status_details << "| error:|"
+            << grpc_core::StatusToString(error) << "|";
     gpr_free(status_details);
   }
   maybe_complete_tsi_next(client, true /* receive_status_finished */,

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.cc

@@ -29,7 +29,6 @@
 #include <grpc/credentials.h>
 #include <grpc/grpc_security.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
@@ -186,10 +185,9 @@ static tsi_result handshaker_result_create_zero_copy_grpc_protector(
     max_frame_size = std::max<size_t>(max_frame_size, kTsiAltsMinFrameSize);
   }
   max_output_protected_frame_size = &max_frame_size;
-  gpr_log(GPR_DEBUG,
-          "After Frame Size Negotiation, maximum frame size used by frame "
-          "protector equals %zu",
-          *max_output_protected_frame_size);
+  VLOG(2) << "After Frame Size Negotiation, maximum frame size used by frame "
+             "protector equals "
+          << *max_output_protected_frame_size;
   tsi_result ok = alts_zero_copy_grpc_protector_create(
       grpc_core::GsecKeyFactory({reinterpret_cast<uint8_t*>(result->key_data),
                                  kAltsAes128GcmRekeyKeyLength},
@@ -392,9 +390,8 @@ static void on_handshaker_service_resp_recv(void* arg,
   }
   bool success = true;
   if (!error.ok()) {
-    gpr_log(GPR_INFO,
-            "ALTS handshaker on_handshaker_service_resp_recv error: %s",
-            grpc_core::StatusToString(error).c_str());
+    VLOG(2) << "ALTS handshaker on_handshaker_service_resp_recv error: "
+            << grpc_core::StatusToString(error);
     success = false;
   }
   alts_handshaker_client_handle_response(client, success);
@@ -448,7 +445,7 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
       CHECK_EQ(handshaker->client, nullptr);
       handshaker->client = client;
       if (handshaker->shutdown) {
-        LOG(INFO) << "TSI handshake shutdown";
+        VLOG(2) << "TSI handshake shutdown";
         if (error != nullptr) *error = "TSI handshaker shutdown";
         return TSI_HANDSHAKE_SHUTDOWN;
       }

data/src/core/tsi/alts/handshaker/transport_security_common_api.cc

@@ -27,9 +27,8 @@ bool grpc_gcp_rpc_protocol_versions_set_max(
     grpc_gcp_rpc_protocol_versions* versions, uint32_t max_major,
     uint32_t max_minor) {
   if (versions == nullptr) {
-    gpr_log(GPR_ERROR,
-            "versions is nullptr in "
-            "grpc_gcp_rpc_protocol_versions_set_max().");
+    LOG(ERROR)
+        << "versions is nullptr in grpc_gcp_rpc_protocol_versions_set_max().";
     return false;
   }
   versions->max_rpc_version.major = max_major;
@@ -41,9 +40,8 @@ bool grpc_gcp_rpc_protocol_versions_set_min(
     grpc_gcp_rpc_protocol_versions* versions, uint32_t min_major,
     uint32_t min_minor) {
   if (versions == nullptr) {
-    gpr_log(GPR_ERROR,
-            "versions is nullptr in "
-            "grpc_gcp_rpc_protocol_versions_set_min().");
+    LOG(ERROR)
+        << "versions is nullptr in grpc_gcp_rpc_protocol_versions_set_min().";
     return false;
   }
   versions->min_rpc_version.major = min_major;
@@ -54,9 +52,8 @@ bool grpc_gcp_rpc_protocol_versions_set_min(
 bool grpc_gcp_rpc_protocol_versions_encode(
     const grpc_gcp_rpc_protocol_versions* versions, grpc_slice* slice) {
   if (versions == nullptr || slice == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Invalid nullptr arguments to "
-            "grpc_gcp_rpc_protocol_versions_encode().");
+    LOG(ERROR) << "Invalid nullptr arguments to "
+                  "grpc_gcp_rpc_protocol_versions_encode().";
     return false;
   }
   upb::Arena arena;
@@ -72,9 +69,8 @@ bool grpc_gcp_rpc_protocol_versions_encode(
     const grpc_gcp_RpcProtocolVersions* versions, upb_Arena* arena,
     grpc_slice* slice) {
   if (versions == nullptr || arena == nullptr || slice == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Invalid nullptr arguments to "
-            "grpc_gcp_rpc_protocol_versions_encode().");
+    LOG(ERROR) << "Invalid nullptr arguments to "
+                  "grpc_gcp_rpc_protocol_versions_encode().";
     return false;
   }
   size_t buf_length;
@@ -90,9 +86,8 @@ bool grpc_gcp_rpc_protocol_versions_encode(
 bool grpc_gcp_rpc_protocol_versions_decode(
     const grpc_slice& slice, grpc_gcp_rpc_protocol_versions* versions) {
   if (versions == nullptr) {
-    gpr_log(GPR_ERROR,
-            "version is nullptr in "
-            "grpc_gcp_rpc_protocol_versions_decode().");
+    LOG(ERROR)
+        << "version is nullptr in grpc_gcp_rpc_protocol_versions_decode().";
     return false;
   }
   upb::Arena arena;
@@ -157,9 +152,7 @@ bool grpc_gcp_rpc_protocol_versions_copy(
     grpc_gcp_rpc_protocol_versions* dst) {
   if ((src == nullptr && dst != nullptr) ||
       (src != nullptr && dst == nullptr)) {
-    gpr_log(GPR_ERROR,
-            "Invalid arguments to "
-            "grpc_gcp_rpc_protocol_versions_copy().");
+    LOG(ERROR) << "Invalid arguments to grpc_gcp_rpc_protocol_versions_copy().";
     return false;
   }
   if (src == nullptr) {
@@ -197,9 +190,8 @@ bool grpc_gcp_rpc_protocol_versions_check(
     const grpc_gcp_rpc_protocol_versions* peer_versions,
     grpc_gcp_rpc_protocol_versions_version* highest_common_version) {
   if (local_versions == nullptr || peer_versions == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Invalid arguments to "
-            "grpc_gcp_rpc_protocol_versions_check().");
+    LOG(ERROR)
+        << "Invalid arguments to grpc_gcp_rpc_protocol_versions_check().";
     return false;
   }
   // max_common_version is MIN(local.max, peer.max)

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

@@ -24,7 +24,6 @@
 #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/gprpp/crash.h"
@@ -85,8 +84,8 @@ static tsi_result alts_grpc_integrity_only_protect(
   // Input sanity check.
   if (rp == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Invalid nullptr arguments to alts_grpc_record_protocol protect.");
+    LOG(ERROR)
+        << "Invalid nullptr arguments to alts_grpc_record_protocol protect.";
     return TSI_INVALID_ARGUMENT;
   }
   alts_grpc_integrity_only_record_protocol* integrity_only_record_protocol =
@@ -127,9 +126,8 @@ static tsi_result alts_grpc_integrity_only_unprotect(
   // Input sanity check.
   if (rp == nullptr || protected_slices == nullptr ||
       unprotected_slices == nullptr) {
-    gpr_log(
-        GPR_ERROR,
-        "Invalid nullptr arguments to alts_grpc_record_protocol unprotect.");
+    LOG(ERROR)
+        << "Invalid nullptr arguments to alts_grpc_record_protocol unprotect.";
     return TSI_INVALID_ARGUMENT;
   }
   if (protected_slices->length < rp->header_length + rp->tag_length) {
@@ -202,8 +200,8 @@ tsi_result alts_grpc_integrity_only_record_protocol_create(
     gsec_aead_crypter* crypter, size_t overflow_size, bool is_client,
     bool is_protect, bool enable_extra_copy, alts_grpc_record_protocol** rp) {
   if (crypter == nullptr || rp == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Invalid nullptr arguments to alts_grpc_record_protocol create.");
+    LOG(ERROR)
+        << "Invalid nullptr arguments to alts_grpc_record_protocol create.";
     return TSI_INVALID_ARGUMENT;
   }
   alts_grpc_integrity_only_record_protocol* impl =

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

@@ -21,7 +21,6 @@
 #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/gprpp/crash.h"
@@ -41,8 +40,8 @@ static tsi_result alts_grpc_privacy_integrity_protect(
   // Input sanity check.
   if (rp == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Invalid nullptr arguments to alts_grpc_record_protocol protect.");
+    LOG(ERROR)
+        << "Invalid nullptr arguments to alts_grpc_record_protocol protect.";
     return TSI_INVALID_ARGUMENT;
   }
   // Allocates memory for output frame. In privacy-integrity protect, the
@@ -78,9 +77,8 @@ static tsi_result alts_grpc_privacy_integrity_unprotect(
   // Input sanity check.
   if (rp == nullptr || protected_slices == nullptr ||
       unprotected_slices == nullptr) {
-    gpr_log(
-        GPR_ERROR,
-        "Invalid nullptr arguments to alts_grpc_record_protocol unprotect.");
+    LOG(ERROR)
+        << "Invalid nullptr arguments to alts_grpc_record_protocol unprotect.";
     return TSI_INVALID_ARGUMENT;
   }
   // Allocates memory for output frame. In privacy-integrity unprotect, the
@@ -127,8 +125,8 @@ tsi_result alts_grpc_privacy_integrity_record_protocol_create(
     gsec_aead_crypter* crypter, size_t overflow_size, bool is_client,
     bool is_protect, alts_grpc_record_protocol** rp) {
   if (crypter == nullptr || rp == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Invalid nullptr arguments to alts_grpc_record_protocol create.");
+    LOG(ERROR)
+        << "Invalid nullptr arguments to alts_grpc_record_protocol create.";
     return TSI_INVALID_ARGUMENT;
   }
   auto* impl = static_cast<alts_grpc_record_protocol*>(

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

@@ -21,9 +21,9 @@
 #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/gprpp/crash.h"
@@ -96,8 +96,8 @@ tsi_result alts_grpc_record_protocol_init(alts_grpc_record_protocol* rp,
                                           bool is_integrity_only,
                                           bool is_protect) {
   if (rp == nullptr || crypter == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Invalid nullptr arguments to alts_grpc_record_protocol init.");
+    LOG(ERROR)
+        << "Invalid nullptr arguments to alts_grpc_record_protocol init.";
     return TSI_INVALID_ARGUMENT;
   }
   // Creates alts_iovec_record_protocol.
@@ -106,8 +106,8 @@ tsi_result alts_grpc_record_protocol_init(alts_grpc_record_protocol* rp,
       crypter, overflow_size, is_client, is_integrity_only, is_protect,
       &rp->iovec_rp, &error_details);
   if (status != GRPC_STATUS_OK) {
-    gpr_log(GPR_ERROR, "Failed to create alts_iovec_record_protocol, %s.",
-            error_details);
+    LOG(ERROR) << "Failed to create alts_iovec_record_protocol, "
+               << error_details;
     gpr_free(error_details);
     return TSI_INTERNAL_ERROR;
   }

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

@@ -27,7 +27,6 @@
 #include "absl/log/log.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/tsi/alts/crypt/gsec.h"
@@ -180,8 +179,7 @@ static tsi_result alts_zero_copy_grpc_protector_unprotect(
     grpc_slice_buffer* unprotected_slices, int* min_progress_size) {
   if (self == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Invalid nullptr arguments to zero-copy grpc unprotect.");
+    LOG(ERROR) << "Invalid nullptr arguments to zero-copy grpc unprotect.";
     return TSI_INVALID_ARGUMENT;
   }
   alts_zero_copy_grpc_protector* protector =
@@ -266,9 +264,8 @@ tsi_result alts_zero_copy_grpc_protector_create(
     size_t* max_protected_frame_size,
     tsi_zero_copy_grpc_protector** protector) {
   if (protector == nullptr) {
-    gpr_log(
-        GPR_ERROR,
-        "Invalid nullptr arguments to alts_zero_copy_grpc_protector create.");
+    LOG(ERROR)
+        << "Invalid nullptr arguments to alts_zero_copy_grpc_protector create.";
     return TSI_INVALID_ARGUMENT;
   }
   // Creates alts_zero_copy_protector.

data/src/core/tsi/fake_transport_security.cc

@@ -25,7 +25,6 @@
 #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/gprpp/crash.h"
@@ -641,9 +640,9 @@ static tsi_result fake_handshaker_get_bytes_to_send_to_peer(
       next_message_to_send = TSI_FAKE_HANDSHAKE_MESSAGE_MAX;
     }
     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));
+      LOG(INFO) << (impl->is_client ? "Client" : "Server") << " prepared "
+                << tsi_fake_handshake_message_to_string(
+                       impl->next_message_to_send);
     }
     impl->next_message_to_send = next_message_to_send;
   }
@@ -688,9 +687,10 @@ static tsi_result fake_handshaker_process_bytes_from_peer(
     return result;
   }
   if (received_msg != expected_msg) {
-    gpr_log(GPR_ERROR, "Invalid received message (%s instead of %s)",
-            tsi_fake_handshake_message_to_string(received_msg),
-            tsi_fake_handshake_message_to_string(expected_msg));
+    LOG(ERROR) << "Invalid received message ("
+               << tsi_fake_handshake_message_to_string(received_msg)
+               << " instead of "
+               << tsi_fake_handshake_message_to_string(expected_msg) << ")";
   }
   GRPC_TRACE_LOG(tsi, INFO)
       << (impl->is_client ? "Client" : "Server") << " received "

data/src/core/tsi/ssl/key_logging/ssl_key_logging.cc

@@ -17,8 +17,8 @@
 #include <map>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -54,10 +54,8 @@ TlsSessionKeyLoggerCache::TlsSessionKeyLogger::TlsSessionKeyLogger(
   fd_ = fopen(tls_session_key_log_file_path_.c_str(), "a");
   if (fd_ == nullptr) {
     grpc_error_handle error = GRPC_OS_ERROR(errno, "fopen");
-    gpr_log(GPR_ERROR,
-            "Ignoring TLS Key logging. ERROR Opening TLS Keylog "
-            "file: %s",
-            grpc_core::StatusToString(error).c_str());
+    LOG(ERROR) << "Ignoring TLS Key logging. ERROR Opening TLS Keylog file: "
+               << grpc_core::StatusToString(error);
   }
   cache_->tls_session_key_logger_map_.emplace(tls_session_key_log_file_path_,
                                               this);
@@ -89,8 +87,8 @@ void TlsSessionKeyLoggerCache::TlsSessionKeyLogger::LogSessionKeys(
 
   if (err) {
     grpc_error_handle error = GRPC_OS_ERROR(errno, "fwrite");
-    gpr_log(GPR_ERROR, "Error Appending to TLS session key log file: %s",
-            grpc_core::StatusToString(error).c_str());
+    LOG(ERROR) << "Error Appending to TLS session key log file: "
+               << grpc_core::StatusToString(error);
     fclose(fd_);
     fd_ = nullptr;  // disable future attempts to write to this file
   } else {