grpc 1.65.2 → 1.66.0.pre3

data/src/core/load_balancing/grpclb/grpclb.cc

@@ -73,6 +73,8 @@
 #include "absl/container/inlined_vector.h"
 #include "absl/functional/function_ref.h"
 #include "absl/log/check.h"
+#include "absl/log/globals.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -91,7 +93,6 @@
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 
 #include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/client_channel_filter.h"
@@ -309,14 +310,17 @@ class GrpcLb final : public LoadBalancingPolicy {
   class SubchannelWrapper final : public DelegatingSubchannel {
    public:
     SubchannelWrapper(RefCountedPtr<SubchannelInterface> subchannel,
-                      RefCountedPtr<GrpcLb> lb_policy, std::string lb_token,
+                      RefCountedPtr<GrpcLb> lb_policy,
+                      grpc_event_engine::experimental::Slice lb_token,
                       RefCountedPtr<GrpcLbClientStats> client_stats)
         : DelegatingSubchannel(std::move(subchannel)),
           lb_policy_(std::move(lb_policy)),
           lb_token_(std::move(lb_token)),
           client_stats_(std::move(client_stats)) {}
 
-    const std::string& lb_token() const { return lb_token_; }
+    const grpc_event_engine::experimental::Slice& lb_token() const {
+      return lb_token_;
+    }
     GrpcLbClientStats* client_stats() const { return client_stats_.get(); }
 
    private:
@@ -338,14 +342,14 @@ class GrpcLb final : public LoadBalancingPolicy {
     }
 
     RefCountedPtr<GrpcLb> lb_policy_;
-    std::string lb_token_;
+    grpc_event_engine::experimental::Slice lb_token_;
     RefCountedPtr<GrpcLbClientStats> client_stats_;
   };
 
   class TokenAndClientStatsArg final
       : public RefCounted<TokenAndClientStatsArg> {
    public:
-    TokenAndClientStatsArg(std::string lb_token,
+    TokenAndClientStatsArg(grpc_event_engine::experimental::Slice lb_token,
                            RefCountedPtr<GrpcLbClientStats> client_stats)
         : lb_token_(std::move(lb_token)),
           client_stats_(std::move(client_stats)) {}
@@ -356,18 +360,21 @@ class GrpcLb final : public LoadBalancingPolicy {
 
     static int ChannelArgsCompare(const TokenAndClientStatsArg* a,
                                   const TokenAndClientStatsArg* b) {
-      int r = a->lb_token_.compare(b->lb_token_);
+      int r =
+          a->lb_token_.as_string_view().compare(b->lb_token_.as_string_view());
       if (r != 0) return r;
       return QsortCompare(a->client_stats_.get(), b->client_stats_.get());
     }
 
-    const std::string& lb_token() const { return lb_token_; }
+    const grpc_event_engine::experimental::Slice& lb_token() const {
+      return lb_token_;
+    }
     RefCountedPtr<GrpcLbClientStats> client_stats() const {
       return client_stats_;
     }
 
    private:
-    std::string lb_token_;
+    grpc_event_engine::experimental::Slice lb_token_;
     RefCountedPtr<GrpcLbClientStats> client_stats_;
   };
 
@@ -607,19 +614,15 @@ bool IsServerValid(const GrpcLbServer& server, size_t idx, bool log) {
   if (server.drop) return false;
   if (GPR_UNLIKELY(server.port >> 16 != 0)) {
     if (log) {
-      gpr_log(GPR_ERROR,
-              "Invalid port '%d' at index %" PRIuPTR
-              " of serverlist. Ignoring.",
-              server.port, idx);
+      LOG(ERROR) << "Invalid port '" << server.port << "' at index " << idx
+                 << " of serverlist. Ignoring.";
     }
     return false;
   }
   if (GPR_UNLIKELY(server.ip_size != 4 && server.ip_size != 16)) {
     if (log) {
-      gpr_log(GPR_ERROR,
-              "Expected IP to be 4 or 16 bytes, got %d at index %" PRIuPTR
-              " of serverlist. Ignoring",
-              server.ip_size, idx);
+      LOG(ERROR) << "Expected IP to be 4 or 16 bytes, got " << server.ip_size
+                 << " at index " << idx << " of serverlist. Ignoring";
     }
     return false;
   }
@@ -667,7 +670,8 @@ class GrpcLb::Serverlist::AddressIterator final
       // LB token processing.
       const size_t lb_token_length = strnlen(
           server.load_balance_token, GPR_ARRAY_SIZE(server.load_balance_token));
-      std::string lb_token(server.load_balance_token, lb_token_length);
+      auto lb_token = grpc_event_engine::experimental::Slice::FromCopiedBuffer(
+          server.load_balance_token, lb_token_length);
       if (lb_token.empty()) {
         auto addr_uri = grpc_sockaddr_to_uri(&addr);
         GRPC_TRACE_LOG(glb, INFO)
@@ -776,9 +780,10 @@ GrpcLb::PickResult GrpcLb::Picker::Pick(PickArgs args) {
       // a string and rely on the client_load_reporting filter to know
       // how to interpret it.
       // NOLINTBEGIN(bugprone-string-constructor)
-      args.initial_metadata->Add(
+      complete_pick->metadata_mutations.Set(
           GrpcLbClientStatsMetadata::key(),
-          absl::string_view(reinterpret_cast<const char*>(client_stats), 0));
+          grpc_event_engine::experimental::Slice(grpc_slice_from_static_buffer(
+              reinterpret_cast<const char*>(client_stats), 0)));
       // NOLINTEND(bugprone-string-constructor)
       // Update calls-started.
       client_stats->AddCallStarted();
@@ -788,10 +793,8 @@ GrpcLb::PickResult GrpcLb::Picker::Pick(PickArgs args) {
     // may get refreshed between when we return this pick and when the
     // initial metadata goes out on the wire.
     if (!subchannel_wrapper->lb_token().empty()) {
-      char* lb_token = static_cast<char*>(
-          args.call_state->Alloc(subchannel_wrapper->lb_token().size() + 1));
-      strcpy(lb_token, subchannel_wrapper->lb_token().c_str());
-      args.initial_metadata->Add(LbTokenMetadata::key(), lb_token);
+      complete_pick->metadata_mutations.Set(
+          LbTokenMetadata::key(), subchannel_wrapper->lb_token().Ref());
     }
     // Unwrap subchannel to pass up to the channel.
     complete_pick->subchannel = subchannel_wrapper->wrapped_subchannel();
@@ -814,13 +817,11 @@ RefCountedPtr<SubchannelInterface> GrpcLb::Helper::CreateSubchannel(
         absl::StrFormat("[grpclb %p] no TokenAndClientStatsArg for address %s",
                         parent(), addr_str.value_or("N/A").c_str()));
   }
-  std::string lb_token = arg->lb_token();
-  RefCountedPtr<GrpcLbClientStats> client_stats = arg->client_stats();
   return MakeRefCounted<SubchannelWrapper>(
       parent()->channel_control_helper()->CreateSubchannel(
           address, per_address_args, args),
       parent()->RefAsSubclass<GrpcLb>(DEBUG_LOCATION, "SubchannelWrapper"),
-      std::move(lb_token), std::move(client_stats));
+      arg->lb_token().Ref(), arg->client_stats());
 }
 
 void GrpcLb::Helper::UpdateState(grpc_connectivity_state state,
@@ -948,8 +949,8 @@ void GrpcLb::BalancerCallState::Orphan() {
 void GrpcLb::BalancerCallState::StartQuery() {
   CHECK_NE(lb_call_, nullptr);
   if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-    gpr_log(GPR_INFO, "[grpclb %p] lb_calld=%p: Starting LB call %p",
-            grpclb_policy_.get(), this, lb_call_);
+    LOG(INFO) << "[grpclb " << grpclb_policy_.get() << "] lb_calld=" << this
+              << ": Starting LB call " << lb_call_;
   }
   // Create the ops.
   grpc_call_error call_error;
@@ -1091,9 +1092,8 @@ void GrpcLb::BalancerCallState::SendClientLoadReportLocked() {
   grpc_call_error call_error = grpc_call_start_batch_and_execute(
       lb_call_, &op, 1, &client_load_report_done_closure_);
   if (GPR_UNLIKELY(call_error != GRPC_CALL_OK)) {
-    gpr_log(GPR_ERROR,
-            "[grpclb %p] lb_calld=%p call_error=%d sending client load report",
-            grpclb_policy_.get(), this, call_error);
+    LOG(ERROR) << "[grpclb " << grpclb_policy_.get() << "] lb_calld=" << this
+               << " call_error=" << call_error << " sending client load report";
     CHECK_EQ(call_error, GRPC_CALL_OK);
   }
 }
@@ -1161,13 +1161,12 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked() {
   upb::Arena arena;
   if (!GrpcLbResponseParse(response_slice, arena.ptr(), &response) ||
       (response.type == response.INITIAL && seen_initial_response_)) {
-    if (gpr_should_log(GPR_LOG_SEVERITY_ERROR)) {
+    if (absl::MinLogLevel() <= absl::LogSeverityAtLeast::kError) {
       char* response_slice_str =
           grpc_dump_slice(response_slice, GPR_DUMP_ASCII | GPR_DUMP_HEX);
-      gpr_log(GPR_ERROR,
-              "[grpclb %p] lb_calld=%p: Invalid LB response received: '%s'. "
-              "Ignoring.",
-              grpclb_policy(), this, response_slice_str);
+      LOG(ERROR) << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
+                 << ": Invalid LB response received: '" << response_slice_str
+                 << "'. Ignoring.";
       gpr_free(response_slice_str);
     }
   } else {
@@ -1177,18 +1176,16 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked() {
           client_stats_report_interval_ = std::max(
               Duration::Seconds(1), response.client_stats_report_interval);
           if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-            gpr_log(GPR_INFO,
-                    "[grpclb %p] lb_calld=%p: Received initial LB response "
-                    "message; client load reporting interval = %" PRId64
-                    " milliseconds",
-                    grpclb_policy(), this,
-                    client_stats_report_interval_.millis());
+            LOG(INFO) << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
+                      << ": Received initial LB response message; client load "
+                         "reporting interval = "
+                      << client_stats_report_interval_.millis()
+                      << " milliseconds";
           }
         } else if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-          gpr_log(GPR_INFO,
-                  "[grpclb %p] lb_calld=%p: Received initial LB response "
-                  "message; client load reporting NOT enabled",
-                  grpclb_policy(), this);
+          LOG(INFO) << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
+                    << ": Received initial LB response message; client load "
+                       "reporting NOT enabled";
         }
         seen_initial_response_ = true;
         break;
@@ -1198,12 +1195,11 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked() {
         auto serverlist_wrapper =
             MakeRefCounted<Serverlist>(std::move(response.serverlist));
         if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-          gpr_log(GPR_INFO,
-                  "[grpclb %p] lb_calld=%p: Serverlist with %" PRIuPTR
-                  " servers received:\n%s",
-                  grpclb_policy(), this,
-                  serverlist_wrapper->serverlist().size(),
-                  serverlist_wrapper->AsText().c_str());
+          LOG(INFO) << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
+                    << ": Serverlist with "
+                    << serverlist_wrapper->serverlist().size()
+                    << " servers received:\n"
+                    << serverlist_wrapper->AsText();
         }
         seen_serverlist_ = true;
         // Start sending client load report only after we start using the
@@ -1219,10 +1215,9 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked() {
         if (grpclb_policy()->serverlist_ != nullptr &&
             *grpclb_policy()->serverlist_ == *serverlist_wrapper) {
           if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-            gpr_log(GPR_INFO,
-                    "[grpclb %p] lb_calld=%p: Incoming server list identical "
-                    "to current, ignoring.",
-                    grpclb_policy(), this);
+            LOG(INFO) << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
+                      << ": Incoming server list identical to current, "
+                         "ignoring.";
           }
         } else {  // New serverlist.
           // Dispose of the fallback.
@@ -1245,10 +1240,9 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked() {
           // it in favor of the xds policy.  We will implement this the
           // right way in the xds policy instead.
           if (grpclb_policy()->fallback_mode_) {
-            gpr_log(GPR_INFO,
-                    "[grpclb %p] Received response from balancer; exiting "
-                    "fallback mode",
-                    grpclb_policy());
+            LOG(INFO) << "[grpclb " << grpclb_policy()
+                      << "] Received response from balancer; exiting fallback "
+                         "mode";
             grpclb_policy()->fallback_mode_ = false;
           }
           if (grpclb_policy()->fallback_at_startup_checks_pending_) {
@@ -1267,9 +1261,8 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked() {
       }
       case response.FALLBACK: {
         if (!grpclb_policy()->fallback_mode_) {
-          gpr_log(GPR_INFO,
-                  "[grpclb %p] Entering fallback mode as requested by balancer",
-                  grpclb_policy());
+          LOG(INFO) << "[grpclb " << grpclb_policy()
+                    << "] Entering fallback mode as requested by balancer";
           if (grpclb_policy()->fallback_at_startup_checks_pending_) {
             grpclb_policy()->fallback_at_startup_checks_pending_ = false;
             grpclb_policy()->channel_control_helper()->GetEventEngine()->Cancel(
@@ -1318,11 +1311,11 @@ void GrpcLb::BalancerCallState::OnBalancerStatusReceivedLocked(
   CHECK_NE(lb_call_, nullptr);
   if (GRPC_TRACE_FLAG_ENABLED(glb)) {
     char* status_details = grpc_slice_to_c_string(lb_call_status_details_);
-    gpr_log(GPR_INFO,
-            "[grpclb %p] lb_calld=%p: Status from LB server received. "
-            "Status = %d, details = '%s', (lb_call: %p), error '%s'",
-            grpclb_policy(), this, lb_call_status_, status_details, lb_call_,
-            StatusToString(error).c_str());
+    LOG(INFO) << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
+              << ": Status from LB server received. Status = "
+              << lb_call_status_ << ", details = '" << status_details
+              << "', (lb_call: " << lb_call_ << "), error '"
+              << StatusToString(error) << "'";
     gpr_free(status_details);
   }
   // If this lb_calld is still in use, this call ended because of a failure so
@@ -1335,10 +1328,9 @@ void GrpcLb::BalancerCallState::OnBalancerStatusReceivedLocked(
     grpclb_policy()->lb_calld_.reset();
     if (grpclb_policy()->fallback_at_startup_checks_pending_) {
       CHECK(!seen_serverlist_);
-      gpr_log(GPR_INFO,
-              "[grpclb %p] Balancer call finished without receiving "
-              "serverlist; entering fallback mode",
-              grpclb_policy());
+      LOG(INFO) << "[grpclb " << grpclb_policy()
+                << "] Balancer call finished without receiving serverlist; "
+                   "entering fallback mode";
       grpclb_policy()->fallback_at_startup_checks_pending_ = false;
       grpclb_policy()->channel_control_helper()->GetEventEngine()->Cancel(
           *grpclb_policy()->lb_fallback_timer_handle_);
@@ -1467,10 +1459,9 @@ GrpcLb::GrpcLb(Args args)
               .value_or(Duration::Milliseconds(
                   GRPC_GRPCLB_DEFAULT_SUBCHANNEL_DELETION_DELAY_MS)))) {
   if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-    gpr_log(GPR_INFO,
-            "[grpclb %p] Will use '%s' as the server name for LB request.",
-            this,
-            std::string(channel_control_helper()->GetAuthority()).c_str());
+    LOG(INFO) << "[grpclb " << this << "] Will use '"
+              << std::string(channel_control_helper()->GetAuthority())
+              << "' as the server name for LB request.";
   }
 }
 
@@ -1537,8 +1528,8 @@ class GrpcLb::NullLbTokenEndpointIterator final
       const override {
     parent_it_->ForEach([&](const EndpointAddresses& endpoint) {
       if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-        gpr_log(GPR_INFO, "[grpclb %p] fallback address: %s", this,
-                endpoint.ToString().c_str());
+        LOG(INFO) << "[grpclb " << this
+                  << "] fallback address: " << endpoint.ToString();
       }
       callback(EndpointAddresses(endpoint.addresses(),
                                  endpoint.args().SetObject(empty_token_)));
@@ -1548,12 +1539,13 @@ class GrpcLb::NullLbTokenEndpointIterator final
  private:
   std::shared_ptr<EndpointAddressesIterator> parent_it_;
   RefCountedPtr<TokenAndClientStatsArg> empty_token_ =
-      MakeRefCounted<TokenAndClientStatsArg>("", nullptr);
+      MakeRefCounted<TokenAndClientStatsArg>(
+          grpc_event_engine::experimental::Slice(), nullptr);
 };
 
 absl::Status GrpcLb::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-    gpr_log(GPR_INFO, "[grpclb %p] received update", this);
+    LOG(INFO) << "[grpclb " << this << "] received update";
   }
   const bool is_initial_update = lb_channel_ == nullptr;
   config_ = args.config.TakeAsSubclass<GrpcLbConfig>();
@@ -1611,8 +1603,8 @@ absl::Status GrpcLb::UpdateBalancerChannelLocked() {
   EndpointAddressesList balancer_addresses = ExtractBalancerAddresses(args_);
   if (GRPC_TRACE_FLAG_ENABLED(glb)) {
     for (const auto& endpoint : balancer_addresses) {
-      gpr_log(GPR_INFO, "[grpclb %p] balancer address: %s", this,
-              endpoint.ToString().c_str());
+      LOG(INFO) << "[grpclb " << this
+                << "] balancer address: " << endpoint.ToString();
     }
   }
   absl::Status status;
@@ -1667,9 +1659,9 @@ void GrpcLb::StartBalancerCallLocked() {
   CHECK(lb_calld_ == nullptr);
   lb_calld_ = MakeOrphanable<BalancerCallState>(Ref());
   if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-    gpr_log(GPR_INFO,
-            "[grpclb %p] Query for backends (lb_channel: %p, lb_calld: %p)",
-            this, lb_channel_.get(), lb_calld_.get());
+    LOG(INFO) << "[grpclb " << this
+              << "] Query for backends (lb_channel: " << lb_channel_.get()
+              << ", lb_calld: " << lb_calld_.get() << ")";
   }
   lb_calld_->StartQuery();
 }
@@ -1677,13 +1669,13 @@ void GrpcLb::StartBalancerCallLocked() {
 void GrpcLb::StartBalancerCallRetryTimerLocked() {
   Duration timeout = lb_call_backoff_.NextAttemptTime() - Timestamp::Now();
   if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-    gpr_log(GPR_INFO, "[grpclb %p] Connection to LB server lost...", this);
+    LOG(INFO) << "[grpclb " << this << "] Connection to LB server lost...";
     if (timeout > Duration::Zero()) {
-      gpr_log(GPR_INFO, "[grpclb %p] ... retry_timer_active in %" PRId64 "ms.",
-              this, timeout.millis());
+      LOG(INFO) << "[grpclb " << this << "] ... retry_timer_active in "
+                << timeout.millis() << "ms.";
     } else {
-      gpr_log(GPR_INFO, "[grpclb %p] ... retry_timer_active immediately.",
-              this);
+      LOG(INFO) << "[grpclb " << this
+                << "] ... retry_timer_active immediately.";
     }
   }
   lb_call_retry_timer_handle_ =
@@ -1706,7 +1698,7 @@ void GrpcLb::OnBalancerCallRetryTimerLocked() {
   lb_call_retry_timer_handle_.reset();
   if (!shutting_down_ && lb_calld_ == nullptr) {
     if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-      gpr_log(GPR_INFO, "[grpclb %p] Restarting call to LB server", this);
+      LOG(INFO) << "[grpclb " << this << "] Restarting call to LB server";
     }
     StartBalancerCallLocked();
   }
@@ -1725,10 +1717,9 @@ void GrpcLb::MaybeEnterFallbackModeAfterStartup() {
   if (!fallback_mode_ && !fallback_at_startup_checks_pending_ &&
       (lb_calld_ == nullptr || !lb_calld_->seen_serverlist()) &&
       !child_policy_ready_) {
-    gpr_log(GPR_INFO,
-            "[grpclb %p] lost contact with balancer and backends from "
-            "most recent serverlist; entering fallback mode",
-            this);
+    LOG(INFO) << "[grpclb " << this
+              << "] lost contact with balancer and backends from most recent "
+                 "serverlist; entering fallback mode";
     fallback_mode_ = true;
     CreateOrUpdateChildPolicyLocked();
   }
@@ -1738,10 +1729,9 @@ void GrpcLb::OnFallbackTimerLocked() {
   // If we receive a serverlist after the timer fires but before this callback
   // actually runs, don't fall back.
   if (fallback_at_startup_checks_pending_ && !shutting_down_) {
-    gpr_log(GPR_INFO,
-            "[grpclb %p] No response from balancer after fallback timeout; "
-            "entering fallback mode",
-            this);
+    LOG(INFO) << "[grpclb " << this
+              << "] No response from balancer after fallback timeout; "
+                 "entering fallback mode";
     fallback_at_startup_checks_pending_ = false;
     CancelBalancerChannelConnectivityWatchLocked();
     fallback_mode_ = true;
@@ -1776,8 +1766,8 @@ OrphanablePtr<LoadBalancingPolicy> GrpcLb::CreateChildPolicyLocked(
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       MakeOrphanable<ChildPolicyHandler>(std::move(lb_policy_args), &glb_trace);
   if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-    gpr_log(GPR_INFO, "[grpclb %p] Created new child policy handler (%p)", this,
-            lb_policy.get());
+    LOG(INFO) << "[grpclb " << this << "] Created new child policy handler ("
+              << lb_policy.get() << ")";
   }
   // Add the gRPC LB's interested_parties pollset_set to that of the newly
   // created child policy. This will make the child policy progress upon
@@ -1830,8 +1820,8 @@ void GrpcLb::CreateOrUpdateChildPolicyLocked() {
   }
   // Update the policy.
   if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-    gpr_log(GPR_INFO, "[grpclb %p] Updating child policy handler %p", this,
-            child_policy_.get());
+    LOG(INFO) << "[grpclb " << this << "] Updating child policy handler "
+              << child_policy_.get();
   }
   // TODO(roth): If we're in fallback mode and the child policy rejects the
   // update, we should propagate that failure back to the resolver somehow.
@@ -1875,9 +1865,8 @@ void GrpcLb::OnSubchannelCacheTimerLocked() {
     auto it = cached_subchannels_.begin();
     if (it != cached_subchannels_.end()) {
       if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-        gpr_log(GPR_INFO,
-                "[grpclb %p] removing %" PRIuPTR " subchannels from cache",
-                this, it->second.size());
+        LOG(INFO) << "[grpclb " << this << "] removing " << it->second.size()
+                  << " subchannels from cache";
       }
       cached_subchannels_.erase(it);
     }

data/src/core/load_balancing/health_check_client.cc

@@ -25,6 +25,7 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -37,7 +38,6 @@
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/channelz/channel_trace.h"
@@ -144,27 +144,12 @@ void HealthProducer::HealthChecker::OnConnectivityStateChangeLocked(
   }
 }
 
-void HealthProducer::HealthChecker::StartHealthStreamLocked() {
-  if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    gpr_log(GPR_INFO,
-            "HealthProducer %p HealthChecker %p: "
-            "creating HealthClient for \"%s\"",
-            producer_.get(), this,
-            std::string(health_check_service_name_).c_str());
-  }
-  stream_client_ = MakeOrphanable<SubchannelStreamClient>(
-      producer_->connected_subchannel_, producer_->subchannel_->pollset_set(),
-      std::make_unique<HealthStreamEventHandler>(Ref()),
-      GRPC_TRACE_FLAG_ENABLED(health_check_client) ? "HealthClient" : nullptr);
-}
-
 void HealthProducer::HealthChecker::NotifyWatchersLocked(
     grpc_connectivity_state state, absl::Status status) {
   if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    gpr_log(
-        GPR_INFO,
-        "HealthProducer %p HealthChecker %p: reporting state %s to watchers",
-        producer_.get(), this, ConnectivityStateName(state));
+    LOG(INFO) << "HealthProducer " << producer_.get() << " HealthChecker "
+              << this << ": reporting state " << ConnectivityStateName(state)
+              << " to watchers";
   }
   work_serializer_->Schedule(
       [self = Ref(), state, status = std::move(status)]() {
@@ -269,7 +254,7 @@ class HealthProducer::HealthChecker::HealthStreamEventHandler final
       static const char kErrorMessage[] =
           "health checking Watch method returned UNIMPLEMENTED; "
           "disabling health checks but assuming server is healthy";
-      gpr_log(GPR_ERROR, kErrorMessage);
+      LOG(ERROR) << kErrorMessage;
       auto* channelz_node =
           health_checker_->producer_->subchannel_->channelz_node();
       if (channelz_node != nullptr) {
@@ -301,8 +286,9 @@ class HealthProducer::HealthChecker::HealthStreamEventHandler final
                              grpc_connectivity_state state,
                              const char* reason) {
     if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-      gpr_log(GPR_INFO, "HealthCheckClient %p: setting state=%s reason=%s",
-              client, ConnectivityStateName(state), reason);
+      LOG(INFO) << "HealthCheckClient " << client
+                << ": setting state=" << ConnectivityStateName(state)
+                << " reason=" << reason;
     }
     health_checker_->OnHealthWatchStatusChange(
         state, state == GRPC_CHANNEL_TRANSIENT_FAILURE
@@ -313,6 +299,18 @@ class HealthProducer::HealthChecker::HealthStreamEventHandler final
   RefCountedPtr<HealthChecker> health_checker_;
 };
 
+void HealthProducer::HealthChecker::StartHealthStreamLocked() {
+  if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
+    LOG(INFO) << "HealthProducer " << producer_.get() << " HealthChecker "
+              << this << ": creating HealthClient for \""
+              << health_check_service_name_ << "\"";
+  }
+  stream_client_ = MakeOrphanable<SubchannelStreamClient>(
+      producer_->connected_subchannel_, producer_->subchannel_->pollset_set(),
+      std::make_unique<HealthStreamEventHandler>(Ref()),
+      GRPC_TRACE_FLAG_ENABLED(health_check_client) ? "HealthClient" : nullptr);
+}
+
 //
 // HealthProducer::ConnectivityWatcher
 //
@@ -344,8 +342,8 @@ class HealthProducer::ConnectivityWatcher final
 
 void HealthProducer::Start(RefCountedPtr<Subchannel> subchannel) {
   if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    gpr_log(GPR_INFO, "HealthProducer %p: starting with subchannel %p", this,
-            subchannel.get());
+    LOG(INFO) << "HealthProducer " << this << ": starting with subchannel "
+              << subchannel.get();
   }
   subchannel_ = std::move(subchannel);
   {
@@ -360,7 +358,7 @@ void HealthProducer::Start(RefCountedPtr<Subchannel> subchannel) {
 
 void HealthProducer::Orphaned() {
   if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    gpr_log(GPR_INFO, "HealthProducer %p: shutting down", this);
+    LOG(INFO) << "HealthProducer " << this << ": shutting down";
   }
   {
     MutexLock lock(&mu_);
@@ -410,9 +408,9 @@ void HealthProducer::RemoveWatcher(
 void HealthProducer::OnConnectivityStateChange(grpc_connectivity_state state,
                                                const absl::Status& status) {
   if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    gpr_log(GPR_INFO,
-            "HealthProducer %p: subchannel state update: state=%s status=%s",
-            this, ConnectivityStateName(state), status.ToString().c_str());
+    LOG(INFO) << "HealthProducer " << this
+              << ": subchannel state update: state="
+              << ConnectivityStateName(state) << " status=" << status;
   }
   MutexLock lock(&mu_);
   state_ = state;
@@ -436,11 +434,9 @@ void HealthProducer::OnConnectivityStateChange(grpc_connectivity_state state,
 
 HealthWatcher::~HealthWatcher() {
   if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    gpr_log(GPR_INFO,
-            "HealthWatcher %p: unregistering from producer %p "
-            "(health_check_service_name=\"%s\")",
-            this, producer_.get(),
-            health_check_service_name_.value_or("N/A").c_str());
+    LOG(INFO) << "HealthWatcher " << this << ": unregistering from producer "
+              << producer_.get() << " (health_check_service_name=\""
+              << health_check_service_name_.value_or("N/A") << "\")";
   }
   if (producer_ != nullptr) {
     producer_->RemoveWatcher(this, health_check_service_name_);
@@ -472,11 +468,10 @@ void HealthWatcher::SetSubchannel(Subchannel* subchannel) {
   // Register ourself with the producer.
   producer_->AddWatcher(this, health_check_service_name_);
   if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    gpr_log(GPR_INFO,
-            "HealthWatcher %p: registered with producer %p (created=%d, "
-            "health_check_service_name=\"%s\")",
-            this, producer_.get(), created,
-            health_check_service_name_.value_or("N/A").c_str());
+    LOG(INFO) << "HealthWatcher " << this << ": registered with producer "
+              << producer_.get() << " (created=" << created
+              << ", health_check_service_name=\""
+              << health_check_service_name_.value_or("N/A") << "\")";
   }
 }
 
@@ -504,9 +499,8 @@ MakeHealthCheckWatcher(
         args.GetOwnedString(GRPC_ARG_HEALTH_CHECK_SERVICE_NAME);
   }
   if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    gpr_log(GPR_INFO,
-            "creating HealthWatcher -- health_check_service_name=\"%s\"",
-            health_check_service_name.value_or("N/A").c_str());
+    LOG(INFO) << "creating HealthWatcher -- health_check_service_name=\""
+              << health_check_service_name.value_or("N/A") << "\"";
   }
   return std::make_unique<HealthWatcher>(std::move(work_serializer),
                                          std::move(health_check_service_name),