grpc 1.65.1 → 1.66.0.pre3

data/src/core/load_balancing/xds/xds_override_host.cc

@@ -45,7 +45,6 @@
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/connectivity_state.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/client_channel/client_channel_internal.h"
@@ -466,8 +465,8 @@ XdsOverrideHostLb::Picker::Picker(
       picker_(std::move(picker)),
       override_host_health_status_set_(override_host_health_status_set) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-    gpr_log(GPR_INFO, "[xds_override_host_lb %p] constructed new picker %p",
-            policy_.get(), this);
+    LOG(INFO) << "[xds_override_host_lb " << policy_.get()
+              << "] constructed new picker " << this;
   }
 }
 
@@ -489,18 +488,16 @@ XdsOverrideHostLb::Picker::PickOverridenHost(
       if (!override_host_health_status_set_.Contains(
               it->second->eds_health_status())) {
         if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-          gpr_log(GPR_INFO,
-                  "Subchannel %s health status is not overridden (%s)",
-                  std::string(address).c_str(),
-                  it->second->eds_health_status().ToString());
+          LOG(INFO) << "Subchannel " << address
+                    << " health status is not overridden ("
+                    << it->second->eds_health_status().ToString() << ")";
         }
         continue;
       }
       auto subchannel = it->second->GetSubchannelRef();
       if (subchannel == nullptr) {
         if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-          gpr_log(GPR_INFO, "No subchannel for %s",
-                  std::string(address).c_str());
+          LOG(INFO) << "No subchannel for " << address;
         }
         if (address_with_no_subchannel.empty()) {
           address_with_no_subchannel = it->first;
@@ -512,8 +509,7 @@ XdsOverrideHostLb::Picker::PickOverridenHost(
         // Found a READY subchannel.  Pass back the actual address list
         // and return the subchannel.
         if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-          gpr_log(GPR_INFO, "Picker override found READY subchannel %s",
-                  std::string(address).c_str());
+          LOG(INFO) << "Picker override found READY subchannel " << address;
         }
         it->second->set_last_used_time();
         override_host_attr->set_actual_address_list(it->second->address_list());
@@ -568,8 +564,8 @@ XdsOverrideHostLb::Picker::PickOverridenHost(
 
 LoadBalancingPolicy::PickResult XdsOverrideHostLb::Picker::Pick(PickArgs args) {
   auto* call_state = static_cast<ClientChannelLbCallState*>(args.call_state);
-  auto* override_host_attr = static_cast<XdsOverrideHostAttribute*>(
-      call_state->GetCallAttribute(XdsOverrideHostAttribute::TypeName()));
+  auto* override_host_attr =
+      call_state->GetCallAttribute<XdsOverrideHostAttribute>();
   if (override_host_attr != nullptr) {
     auto overridden_host_pick = PickOverridenHost(override_host_attr);
     if (overridden_host_pick.has_value()) {
@@ -610,10 +606,8 @@ XdsOverrideHostLb::IdleTimer::IdleTimer(RefCountedPtr<XdsOverrideHostLb> policy,
   // with lock contention and CPU usage due to sweeps over the map.
   duration = std::max(duration, Duration::Seconds(5));
   if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-    gpr_log(GPR_INFO,
-            "[xds_override_host_lb %p] idle timer %p: subchannel cleanup "
-            "pass will run in %s",
-            policy_.get(), this, duration.ToString().c_str());
+    LOG(INFO) << "[xds_override_host_lb " << policy_.get() << "] idle timer "
+              << this << ": subchannel cleanup pass will run in " << duration;
   }
   timer_handle_ = policy_->channel_control_helper()->GetEventEngine()->RunAfter(
       duration, [self = RefAsSubclass<IdleTimer>()]() mutable {
@@ -629,8 +623,8 @@ XdsOverrideHostLb::IdleTimer::IdleTimer(RefCountedPtr<XdsOverrideHostLb> policy,
 void XdsOverrideHostLb::IdleTimer::Orphan() {
   if (timer_handle_.has_value()) {
     if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-      gpr_log(GPR_INFO, "[xds_override_host_lb %p] idle timer %p: cancelling",
-              policy_.get(), this);
+      LOG(INFO) << "[xds_override_host_lb " << policy_.get() << "] idle timer "
+                << this << ": cancelling";
     }
     policy_->channel_control_helper()->GetEventEngine()->Cancel(*timer_handle_);
     timer_handle_.reset();
@@ -642,8 +636,8 @@ void XdsOverrideHostLb::IdleTimer::OnTimerLocked() {
   if (timer_handle_.has_value()) {
     timer_handle_.reset();
     if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-      gpr_log(GPR_INFO, "[xds_override_host_lb %p] idle timer %p: timer fired",
-              policy_.get(), this);
+      LOG(INFO) << "[xds_override_host_lb " << policy_.get() << "] idle timer "
+                << this << ": timer fired";
     }
     policy_->CleanupSubchannels();
   }
@@ -656,21 +650,20 @@ void XdsOverrideHostLb::IdleTimer::OnTimerLocked() {
 XdsOverrideHostLb::XdsOverrideHostLb(Args args)
     : LoadBalancingPolicy(std::move(args)) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-    gpr_log(GPR_INFO, "[xds_override_host_lb %p] created", this);
+    LOG(INFO) << "[xds_override_host_lb " << this << "] created";
   }
 }
 
 XdsOverrideHostLb::~XdsOverrideHostLb() {
   if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-    gpr_log(GPR_INFO,
-            "[xds_override_host_lb %p] destroying xds_override_host LB policy",
-            this);
+    LOG(INFO) << "[xds_override_host_lb " << this
+              << "] destroying xds_override_host LB policy";
   }
 }
 
 void XdsOverrideHostLb::ShutdownLocked() {
   if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-    gpr_log(GPR_INFO, "[xds_override_host_lb %p] shutting down", this);
+    LOG(INFO) << "[xds_override_host_lb " << this << "] shutting down";
   }
   shutting_down_ = true;
   ResetState();
@@ -703,9 +696,8 @@ void XdsOverrideHostLb::ResetState() {
 
 void XdsOverrideHostLb::ReportTransientFailure(absl::Status status) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-    gpr_log(GPR_INFO,
-            "[xds_override_host_lb %p] reporting TRANSIENT_FAILURE: %s", this,
-            status.ToString().c_str());
+    LOG(INFO) << "[xds_override_host_lb " << this
+              << "] reporting TRANSIENT_FAILURE: " << status;
   }
   ResetState();
   channel_control_helper()->UpdateState(
@@ -741,10 +733,9 @@ class ChildEndpointIterator final : public EndpointAddressesIterator {
       XdsHealthStatus status = GetEndpointHealthStatus(endpoint);
       if (status.status() != XdsHealthStatus::kDraining) {
         if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-          gpr_log(GPR_INFO,
-                  "[xds_override_host_lb %p] endpoint %s: not draining, "
-                  "passing to child",
-                  this, endpoint.ToString().c_str());
+          LOG(INFO) << "[xds_override_host_lb " << this << "] endpoint "
+                    << endpoint.ToString()
+                    << ": not draining, passing to child";
         }
         callback(endpoint);
       }
@@ -757,7 +748,7 @@ class ChildEndpointIterator final : public EndpointAddressesIterator {
 
 absl::Status XdsOverrideHostLb::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-    gpr_log(GPR_INFO, "[xds_override_host_lb %p] Received update", this);
+    LOG(INFO) << "[xds_override_host_lb " << this << "] Received update";
   }
   // Grab new LB policy config.
   if (args.config == nullptr) {
@@ -787,11 +778,11 @@ absl::Status XdsOverrideHostLb::UpdateLocked(UpdateArgs args) {
   override_host_status_set_ = it->second->cluster->override_host_statuses;
   connection_idle_timeout_ = it->second->cluster->connection_idle_timeout;
   if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-    gpr_log(GPR_INFO,
-            "[xds_override_host_lb %p] override host status set: %s "
-            "connection idle timeout: %s",
-            this, override_host_status_set_.ToString().c_str(),
-            connection_idle_timeout_.ToString().c_str());
+    LOG(INFO) << "[xds_override_host_lb " << this
+              << "] override host status set: "
+              << override_host_status_set_.ToString()
+              << " connection idle timeout: "
+              << connection_idle_timeout_.ToString();
   }
   // Update address map and wrap endpoint iterator for child policy.
   if (args.addresses.ok()) {
@@ -800,8 +791,8 @@ absl::Status XdsOverrideHostLb::UpdateLocked(UpdateArgs args) {
         std::make_shared<ChildEndpointIterator>(std::move(*args.addresses));
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-      gpr_log(GPR_INFO, "[xds_override_host_lb %p] address error: %s", this,
-              args.addresses.status().ToString().c_str());
+      LOG(INFO) << "[xds_override_host_lb " << this
+                << "] address error: " << args.addresses.status();
     }
   }
   // Create child policy if needed.
@@ -815,9 +806,8 @@ absl::Status XdsOverrideHostLb::UpdateLocked(UpdateArgs args) {
   update_args.config = new_config->child_config();
   update_args.args = args_;
   if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-    gpr_log(GPR_INFO,
-            "[xds_override_host_lb %p] Updating child policy handler %p", this,
-            child_policy_.get());
+    LOG(INFO) << "[xds_override_host_lb " << this
+              << "] Updating child policy handler " << child_policy_.get();
   }
   return child_policy_->UpdateLocked(std::move(update_args));
 }
@@ -827,11 +817,10 @@ void XdsOverrideHostLb::MaybeUpdatePickerLocked() {
     auto xds_override_host_picker = MakeRefCounted<Picker>(
         RefAsSubclass<XdsOverrideHostLb>(), picker_, override_host_status_set_);
     if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-      gpr_log(GPR_INFO,
-              "[xds_override_host_lb %p] updating connectivity: state=%s "
-              "status=(%s) picker=%p",
-              this, ConnectivityStateName(state_), status_.ToString().c_str(),
-              xds_override_host_picker.get());
+      LOG(INFO) << "[xds_override_host_lb " << this
+                << "] updating connectivity: state="
+                << ConnectivityStateName(state_) << " status=(" << status_
+                << ") picker=" << xds_override_host_picker.get();
     }
     channel_control_helper()->UpdateState(state_, status_,
                                           std::move(xds_override_host_picker));
@@ -849,9 +838,8 @@ OrphanablePtr<LoadBalancingPolicy> XdsOverrideHostLb::CreateChildPolicyLocked(
       MakeOrphanable<ChildPolicyHandler>(std::move(lb_policy_args),
                                          &xds_override_host_lb_trace);
   if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-    gpr_log(GPR_INFO,
-            "[xds_override_host_lb %p] Created new child policy handler %p",
-            this, lb_policy.get());
+    LOG(INFO) << "[xds_override_host_lb " << this
+              << "] Created new child policy handler " << lb_policy.get();
   }
   // Add our interested_parties pollset_set to that of the newly created
   // child policy. This will make the child policy progress upon activity on
@@ -877,10 +865,10 @@ void XdsOverrideHostLb::UpdateAddressMap(
     if (status.status() == XdsHealthStatus::kDraining &&
         !override_host_status_set_.Contains(status)) {
       if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-        gpr_log(GPR_INFO,
-                "[xds_override_host_lb %p] endpoint %s: draining but not in "
-                "override_host_status set -- ignoring",
-                this, endpoint.ToString().c_str());
+        LOG(INFO) << "[xds_override_host_lb " << this << "] endpoint "
+                  << endpoint.ToString()
+                  << ": draining but not in override_host_status set -- "
+                     "ignoring";
       }
       return;
     }
@@ -890,10 +878,8 @@ void XdsOverrideHostLb::UpdateAddressMap(
       auto key = grpc_sockaddr_to_string(&address, /*normalize=*/false);
       if (!key.ok()) {
         if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-          gpr_log(GPR_INFO,
-                  "[xds_override_host_lb %p] no key for endpoint address; "
-                  "not adding to map",
-                  this);
+          LOG(INFO) << "[xds_override_host_lb " << this
+                    << "] no key for endpoint address; not adding to map";
         }
       } else {
         addresses.push_back(*std::move(key));
@@ -922,8 +908,8 @@ void XdsOverrideHostLb::UpdateAddressMap(
     for (auto it = subchannel_map_.begin(); it != subchannel_map_.end();) {
       if (addresses_for_map.find(it->first) == addresses_for_map.end()) {
         if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-          gpr_log(GPR_INFO, "[xds_override_host_lb %p] removing map key %s",
-                  this, it->first.c_str());
+          LOG(INFO) << "[xds_override_host_lb " << this << "] removing map key "
+                    << it->first;
         }
         it->second->UnsetSubchannel(&subchannel_refs_to_drop);
         it = subchannel_map_.erase(it);
@@ -937,19 +923,18 @@ void XdsOverrideHostLb::UpdateAddressMap(
       auto it = subchannel_map_.find(address);
       if (it == subchannel_map_.end()) {
         if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-          gpr_log(GPR_INFO, "[xds_override_host_lb %p] adding map key %s", this,
-                  address.c_str());
+          LOG(INFO) << "[xds_override_host_lb " << this << "] adding map key "
+                    << address;
         }
         it = subchannel_map_.emplace(address, MakeRefCounted<SubchannelEntry>())
                  .first;
       }
       if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-        gpr_log(GPR_INFO,
-                "[xds_override_host_lb %p] map key %s: setting "
-                "eds_health_status=%s address_list=%s",
-                this, address.c_str(),
-                address_info.eds_health_status.ToString(),
-                address_info.address_list.c_str());
+        LOG(INFO) << "[xds_override_host_lb " << this << "] map key " << address
+                  << ": setting "
+                  << "eds_health_status="
+                  << address_info.eds_health_status.ToString()
+                  << " address_list=" << address_info.address_list.c_str();
       }
       it->second->set_eds_health_status(address_info.eds_health_status);
       it->second->set_address_list(std::move(address_info.address_list));
@@ -989,9 +974,8 @@ XdsOverrideHostLb::AdoptSubchannel(
 
 void XdsOverrideHostLb::CreateSubchannelForAddress(absl::string_view address) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-    gpr_log(GPR_INFO,
-            "[xds_override_host_lb %p] creating owned subchannel for %s", this,
-            std::string(address).c_str());
+    LOG(INFO) << "[xds_override_host_lb " << this
+              << "] creating owned subchannel for " << address;
   }
   auto addr = StringToSockaddr(address);
   CHECK(addr.ok());
@@ -1033,9 +1017,8 @@ void XdsOverrideHostLb::CleanupSubchannels() {
         auto subchannel = p.second->TakeOwnedSubchannel();
         if (subchannel != nullptr) {
           if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-            gpr_log(GPR_INFO,
-                    "[xds_override_host_lb %p] dropping subchannel for %s",
-                    this, p.first.c_str());
+            LOG(INFO) << "[xds_override_host_lb " << this
+                      << "] dropping subchannel for " << p.first;
           }
           subchannel_refs_to_drop.push_back(std::move(subchannel));
         }
@@ -1061,11 +1044,9 @@ RefCountedPtr<SubchannelInterface> XdsOverrideHostLb::Helper::CreateSubchannel(
     const ChannelArgs& args) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
     auto key = grpc_sockaddr_to_string(&address, /*normalize=*/false);
-    gpr_log(GPR_INFO,
-            "[xds_override_host_lb %p] creating subchannel for %s, "
-            "per_address_args=%s, args=%s",
-            this, key.value_or("<unknown>").c_str(),
-            per_address_args.ToString().c_str(), args.ToString().c_str());
+    LOG(INFO) << "[xds_override_host_lb " << this
+              << "] creating subchannel for " << key.value_or("<unknown>")
+              << ", per_address_args=" << per_address_args << ", args=" << args;
   }
   auto subchannel = parent()->channel_control_helper()->CreateSubchannel(
       address, per_address_args, args);
@@ -1113,9 +1094,8 @@ void XdsOverrideHostLb::SubchannelWrapper::CancelConnectivityStateWatch(
 
 void XdsOverrideHostLb::SubchannelWrapper::Orphaned() {
   if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-    gpr_log(GPR_INFO,
-            "[xds_override_host_lb %p] subchannel wrapper %p orphaned",
-            policy_.get(), this);
+    LOG(INFO) << "[xds_override_host_lb " << policy_.get()
+              << "] subchannel wrapper " << this << " orphaned";
   }
   if (!IsWorkSerializerDispatchEnabled()) {
     wrapped_subchannel()->CancelConnectivityStateWatch(watcher_);
@@ -1227,9 +1207,8 @@ void XdsOverrideHostLb::SubchannelEntry::OnSubchannelWrapperOrphan(
   if (subchannel != wrapper) return;
   if (last_used_time_ < (Timestamp::Now() - connection_idle_timeout)) {
     if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-      gpr_log(GPR_INFO,
-              "[xds_override_host_lb] removing unowned subchannel wrapper %p",
-              subchannel);
+      LOG(INFO) << "[xds_override_host_lb] removing unowned subchannel wrapper "
+                << subchannel;
     }
     subchannel_ = nullptr;
   } else {
@@ -1238,10 +1217,8 @@ void XdsOverrideHostLb::SubchannelEntry::OnSubchannelWrapperOrphan(
     // the wrapper with the same underlying subchannel, and we hold
     // our own ref to it.
     if (GRPC_TRACE_FLAG_ENABLED(xds_override_host_lb)) {
-      gpr_log(GPR_INFO,
-              "[xds_override_host_lb] subchannel wrapper %p: cloning "
-              "to gain ownership",
-              subchannel);
+      LOG(INFO) << "[xds_override_host_lb] subchannel wrapper " << subchannel
+                << ": cloning to gain ownership";
     }
     subchannel_ = wrapper->Clone();
   }

data/src/core/load_balancing/xds/xds_wrr_locality.cc

@@ -20,6 +20,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -136,13 +137,13 @@ XdsWrrLocalityLb::XdsWrrLocalityLb(Args args)
 
 XdsWrrLocalityLb::~XdsWrrLocalityLb() {
   if (GRPC_TRACE_FLAG_ENABLED(xds_wrr_locality_lb)) {
-    gpr_log(GPR_INFO, "[xds_wrr_locality_lb %p] destroying", this);
+    LOG(INFO) << "[xds_wrr_locality_lb " << this << "] destroying";
   }
 }
 
 void XdsWrrLocalityLb::ShutdownLocked() {
   if (GRPC_TRACE_FLAG_ENABLED(xds_wrr_locality_lb)) {
-    gpr_log(GPR_INFO, "[xds_wrr_locality_lb %p] shutting down", this);
+    LOG(INFO) << "[xds_wrr_locality_lb " << this << "] shutting down";
   }
   if (child_policy_ != nullptr) {
     grpc_pollset_set_del_pollset_set(child_policy_->interested_parties(),
@@ -161,7 +162,7 @@ void XdsWrrLocalityLb::ResetBackoffLocked() {
 
 absl::Status XdsWrrLocalityLb::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_wrr_locality_lb)) {
-    gpr_log(GPR_INFO, "[xds_wrr_locality_lb %p] Received update", this);
+    LOG(INFO) << "[xds_wrr_locality_lb " << this << "] Received update";
   }
   auto config = args.config.TakeAsSubclass<XdsWrrLocalityLbConfig>();
   // Scan the addresses to find the weight for each locality.
@@ -175,10 +176,10 @@ absl::Status XdsWrrLocalityLb::UpdateLocked(UpdateArgs args) {
         auto p = locality_weights.emplace(
             locality_name->human_readable_string(), weight);
         if (!p.second && p.first->second != weight) {
-          gpr_log(GPR_ERROR,
-                  "INTERNAL ERROR: xds_wrr_locality found different weights "
-                  "for locality %s (%u vs %u); using first value",
-                  p.first->first.c_str(), p.first->second, weight);
+          LOG(ERROR) << "INTERNAL ERROR: xds_wrr_locality found different "
+                        "weights for locality "
+                     << p.first->first.c_str() << " (" << p.first->second
+                     << " vs " << weight << "); using first value";
         }
       }
     });
@@ -203,9 +204,9 @@ absl::Status XdsWrrLocalityLb::UpdateLocked(UpdateArgs args) {
       }),
   });
   if (GRPC_TRACE_FLAG_ENABLED(xds_wrr_locality_lb)) {
-    gpr_log(GPR_INFO,
-            "[xds_wrr_locality_lb %p] generated child policy config: %s", this,
-            JsonDump(child_config_json, /*indent=*/1).c_str());
+    LOG(INFO) << "[xds_wrr_locality_lb " << this
+              << "] generated child policy config: "
+              << JsonDump(child_config_json, /*indent=*/1);
   }
   // Parse config.
   auto child_config =
@@ -214,10 +215,10 @@ absl::Status XdsWrrLocalityLb::UpdateLocked(UpdateArgs args) {
   if (!child_config.ok()) {
     // This should never happen, but if it does, we basically have no
     // way to fix it, so we put the channel in TRANSIENT_FAILURE.
-    gpr_log(GPR_ERROR,
-            "[xds_wrr_locality %p] error parsing generated child policy "
-            "config -- putting channel in TRANSIENT_FAILURE: %s",
-            this, child_config.status().ToString().c_str());
+    LOG(ERROR) << "[xds_wrr_locality " << this
+               << "] error parsing generated child policy config -- putting "
+                  "channel in TRANSIENT_FAILURE: "
+               << child_config.status();
     absl::Status status = absl::InternalError(absl::StrCat(
         "xds_wrr_locality LB policy: error parsing generated child policy "
         "config: ",
@@ -239,8 +240,8 @@ absl::Status XdsWrrLocalityLb::UpdateLocked(UpdateArgs args) {
   update_args.args = std::move(args.args);
   // Update the policy.
   if (GRPC_TRACE_FLAG_ENABLED(xds_wrr_locality_lb)) {
-    gpr_log(GPR_INFO, "[xds_wrr_locality_lb %p] updating child policy %p", this,
-            child_policy_.get());
+    LOG(INFO) << "[xds_wrr_locality_lb " << this << "] updating child policy "
+              << child_policy_.get();
   }
   return child_policy_->UpdateLocked(std::move(update_args));
 }
@@ -256,8 +257,8 @@ OrphanablePtr<LoadBalancingPolicy> XdsWrrLocalityLb::CreateChildPolicyLocked(
       CoreConfiguration::Get().lb_policy_registry().CreateLoadBalancingPolicy(
           "weighted_target_experimental", std::move(lb_policy_args));
   if (GRPC_TRACE_FLAG_ENABLED(xds_wrr_locality_lb)) {
-    gpr_log(GPR_INFO, "[xds_wrr_locality_lb %p] created new child policy %p",
-            this, lb_policy.get());
+    LOG(INFO) << "[xds_wrr_locality_lb " << this
+              << "] created new child policy " << lb_policy.get();
   }
   // Add our interested_parties pollset_set to that of the newly created
   // child policy. This will make the child policy progress upon activity on

data/src/core/resolver/dns/c_ares/dns_resolver_ares.cc

@@ -743,6 +743,13 @@ void grpc_resolver_dns_ares_shutdown() {
   }
 }
 
+void grpc_resolver_dns_ares_reset_dns_resolver() {
+  if (grpc_core::ShouldUseAresDnsResolver(
+          grpc_core::ConfigVars::Get().DnsResolver())) {
+    grpc_core::ResetDNSResolver(std::make_unique<grpc_core::AresDNSResolver>());
+  }
+}
+
 #else  // GRPC_ARES == 1
 
 namespace grpc_core {
@@ -756,4 +763,6 @@ void grpc_resolver_dns_ares_init() {}
 
 void grpc_resolver_dns_ares_shutdown() {}
 
+void grpc_resolver_dns_ares_reset_dns_resolver() {}
+
 #endif  // GRPC_ARES == 1

data/src/core/resolver/dns/c_ares/grpc_ares_wrapper.cc

@@ -19,7 +19,6 @@
 #include <algorithm>
 #include <vector>
 
-#include "absl/log/log.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/impl/channel_arg_names.h>
@@ -48,13 +47,13 @@
 #include <ares.h>
 
 #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"
 #include "absl/strings/str_format.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 
@@ -556,12 +555,11 @@ static void log_address_sorting_list(const grpc_ares_request* r,
                                      const char* input_output_str) {
   for (size_t i = 0; i < addresses.size(); i++) {
     auto addr_str = grpc_sockaddr_to_string(&addresses[i].address(), true);
-    gpr_log(GPR_INFO,
-            "(c-ares resolver) request:%p c-ares address sorting: %s[%" PRIuPTR
-            "]=%s",
-            r, input_output_str, i,
-            addr_str.ok() ? addr_str->c_str()
-                          : addr_str.status().ToString().c_str());
+    LOG(INFO) << "(c-ares resolver) request:" << r
+              << " c-ares address sorting: " << input_output_str << "[" << i
+              << "]="
+              << (addr_str.ok() ? addr_str->c_str()
+                                : addr_str.status().ToString().c_str());
   }
 }
 
@@ -901,18 +899,14 @@ static bool inner_resolve_as_ip_literal_locked(
     std::unique_ptr<grpc_core::EndpointAddressesList>* addrs, std::string* host,
     std::string* port, std::string* hostport) {
   if (!grpc_core::SplitHostPort(name, host, port)) {
-    gpr_log(GPR_ERROR,
-            "Failed to parse %s to host:port while attempting to resolve as ip "
-            "literal.",
-            name);
+    LOG(ERROR) << "Failed to parse " << name
+               << " to host:port while attempting to resolve as ip literal.";
     return false;
   }
   if (port->empty()) {
     if (default_port == nullptr || strlen(default_port) == 0) {
-      gpr_log(GPR_ERROR,
-              "No port or default port for %s while attempting to resolve as "
-              "ip literal.",
-              name);
+      LOG(ERROR) << "No port or default port for " << name
+                 << " while attempting to resolve as ip literal.";
       return false;
     }
     *port = default_port;
@@ -964,18 +958,14 @@ static bool inner_maybe_resolve_localhost_manually_locked(
     std::string* port) {
   grpc_core::SplitHostPort(name, host, port);
   if (host->empty()) {
-    gpr_log(GPR_ERROR,
-            "Failed to parse %s into host:port during manual localhost "
-            "resolution check.",
-            name);
+    LOG(ERROR) << "Failed to parse " << name
+               << " into host:port during manual localhost resolution check.";
     return false;
   }
   if (port->empty()) {
     if (default_port == nullptr || strlen(default_port) == 0) {
-      gpr_log(GPR_ERROR,
-              "No port or default port for %s during manual localhost "
-              "resolution check.",
-              name);
+      LOG(ERROR) << "No port or default port for " << name
+                 << " during manual localhost resolution check.";
       return false;
     }
     *port = default_port;

data/src/core/resolver/dns/c_ares/grpc_ares_wrapper.h

@@ -26,8 +26,8 @@
 #include <ares.h>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/log/log.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -39,11 +39,11 @@
 
 #define GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS 120000
 
-#define GRPC_CARES_TRACE_LOG(format, ...)                           \
-  do {                                                              \
-    if (GRPC_TRACE_FLAG_ENABLED(cares_resolver)) {                  \
-      gpr_log(GPR_DEBUG, "(c-ares resolver) " format, __VA_ARGS__); \
-    }                                                               \
+#define GRPC_CARES_TRACE_LOG(format, ...)                                      \
+  do {                                                                         \
+    if (GRPC_TRACE_FLAG_ENABLED(cares_resolver)) {                             \
+      VLOG(2) << "(c-ares resolver) " << absl::StrFormat(format, __VA_ARGS__); \
+    }                                                                          \
   } while (0)
 
 typedef struct grpc_ares_ev_driver grpc_ares_ev_driver;

data/src/core/resolver/dns/event_engine/event_engine_client_channel_resolver.cc

@@ -36,7 +36,6 @@
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/channel_arg_names.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/backoff/backoff.h"
@@ -78,10 +77,10 @@ using grpc_event_engine::experimental::EventEngine;
 // TODO(hork): Add a test that checks for proper authority from balancer
 // addresses.
 
-#define GRPC_EVENT_ENGINE_RESOLVER_TRACE(format, ...)                    \
-  if (GRPC_TRACE_FLAG_ENABLED(event_engine_client_channel_resolver)) {   \
-    gpr_log(GPR_DEBUG, "(event_engine client channel resolver) " format, \
-            __VA_ARGS__);                                                \
+#define GRPC_EVENT_ENGINE_RESOLVER_TRACE(format, ...)                  \
+  if (GRPC_TRACE_FLAG_ENABLED(event_engine_client_channel_resolver)) { \
+    VLOG(2) << "(event_engine client channel resolver) "               \
+            << absl::StrFormat(format, __VA_ARGS__);                   \
   }
 
 // ----------------------------------------------------------------------------