grpc 1.65.1 → 1.66.0.pre3

data/src/core/load_balancing/rls/rls.cc

@@ -42,6 +42,7 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/hash/hash.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/random/random.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -63,7 +64,6 @@
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/json.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/channelz/channelz.h"
@@ -107,6 +107,7 @@
 #include "src/core/util/json/json_args.h"
 #include "src/core/util/json/json_object_loader.h"
 #include "src/core/util/json/json_writer.h"
+#include "src/core/util/upb_utils.h"
 #include "src/proto/grpc/lookup/v1/rls.upb.h"
 
 using ::grpc_event_engine::experimental::EventEngine;
@@ -314,12 +315,12 @@ class RlsLb final : public LoadBalancingPolicy {
   struct ResponseInfo {
     absl::Status status;
     std::vector<std::string> targets;
-    std::string header_data;
+    grpc_event_engine::experimental::Slice header_data;
 
     std::string ToString() const {
       return absl::StrFormat("{status=%s, targets=[%s], header_data=\"%s\"}",
                              status.ToString(), absl::StrJoin(targets, ","),
-                             header_data);
+                             header_data.as_string_view());
     }
   };
 
@@ -463,7 +464,7 @@ class RlsLb final : public LoadBalancingPolicy {
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_) {
         return data_expiration_time_;
       }
-      const std::string& header_data() const
+      const grpc_event_engine::experimental::Slice& header_data() const
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_) {
         return header_data_;
       }
@@ -542,7 +543,8 @@ class RlsLb final : public LoadBalancingPolicy {
       // RLS response states
       std::vector<RefCountedPtr<ChildPolicyWrapper>> child_policy_wrappers_
           ABSL_GUARDED_BY(&RlsLb::mu_);
-      std::string header_data_ ABSL_GUARDED_BY(&RlsLb::mu_);
+      grpc_event_engine::experimental::Slice header_data_
+          ABSL_GUARDED_BY(&RlsLb::mu_);
       Timestamp data_expiration_time_ ABSL_GUARDED_BY(&RlsLb::mu_) =
           Timestamp::InfPast();
       Timestamp stale_time_ ABSL_GUARDED_BY(&RlsLb::mu_) = Timestamp::InfPast();
@@ -701,7 +703,7 @@ class RlsLb final : public LoadBalancingPolicy {
                RefCountedPtr<RlsChannel> rls_channel,
                std::unique_ptr<BackOff> backoff_state,
                grpc_lookup_v1_RouteLookupRequest_Reason reason,
-               std::string stale_header_data);
+               grpc_event_engine::experimental::Slice stale_header_data);
     ~RlsRequest() override;
 
     // Shuts down the request.  If the request is still in flight, it is
@@ -729,7 +731,7 @@ class RlsLb final : public LoadBalancingPolicy {
     RefCountedPtr<RlsChannel> rls_channel_;
     std::unique_ptr<BackOff> backoff_state_;
     grpc_lookup_v1_RouteLookupRequest_Reason reason_;
-    std::string stale_header_data_;
+    grpc_event_engine::experimental::Slice stale_header_data_;
 
     // RLS call state.
     Timestamp deadline_;
@@ -804,8 +806,9 @@ RlsLb::ChildPolicyWrapper::ChildPolicyWrapper(RefCountedPtr<RlsLb> lb_policy,
 
 void RlsLb::ChildPolicyWrapper::Orphaned() {
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] ChildPolicyWrapper=%p [%s]: shutdown",
-            lb_policy_.get(), this, target_.c_str());
+    LOG(INFO) << "[rlslb " << lb_policy_.get()
+              << "] ChildPolicyWrapper=" << this << " [" << target_
+              << "]: shutdown";
   }
   is_shutdown_ = true;
   lb_policy_->child_policy_map_.erase(target_);
@@ -863,11 +866,10 @@ void RlsLb::ChildPolicyWrapper::StartUpdate() {
       lb_policy_->config_->child_policy_config(), &errors);
   CHECK(child_policy_config.has_value());
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(
-        GPR_INFO,
-        "[rlslb %p] ChildPolicyWrapper=%p [%s]: validating update, config: %s",
-        lb_policy_.get(), this, target_.c_str(),
-        JsonDump(*child_policy_config).c_str());
+    LOG(INFO) << "[rlslb " << lb_policy_.get()
+              << "] ChildPolicyWrapper=" << this << " [" << target_
+              << "]: validating update, config: "
+              << JsonDump(*child_policy_config);
   }
   auto config =
       CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
@@ -875,11 +877,9 @@ void RlsLb::ChildPolicyWrapper::StartUpdate() {
   // Returned RLS target fails the validation.
   if (!config.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-      gpr_log(GPR_INFO,
-              "[rlslb %p] ChildPolicyWrapper=%p [%s]: config failed to parse: "
-              "%s",
-              lb_policy_.get(), this, target_.c_str(),
-              config.status().ToString().c_str());
+      LOG(INFO) << "[rlslb " << lb_policy_.get()
+                << "] ChildPolicyWrapper=" << this << " [" << target_
+                << "]: config failed to parse: " << config.status();
     }
     pending_config_.reset();
     picker_ = MakeRefCounted<TransientFailurePicker>(
@@ -904,20 +904,19 @@ absl::Status RlsLb::ChildPolicyWrapper::MaybeFinishUpdate() {
     child_policy_ = MakeOrphanable<ChildPolicyHandler>(std::move(create_args),
                                                        &rls_lb_trace);
     if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-      gpr_log(GPR_INFO,
-              "[rlslb %p] ChildPolicyWrapper=%p [%s], created new child policy "
-              "handler %p",
-              lb_policy_.get(), this, target_.c_str(), child_policy_.get());
+      LOG(INFO) << "[rlslb " << lb_policy_.get()
+                << "] ChildPolicyWrapper=" << this << " [" << target_
+                << "], created new child policy handler "
+                << child_policy_.get();
     }
     grpc_pollset_set_add_pollset_set(child_policy_->interested_parties(),
                                      lb_policy_->interested_parties());
   }
   // Send the child the updated config.
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO,
-            "[rlslb %p] ChildPolicyWrapper=%p [%s], updating child policy "
-            "handler %p",
-            lb_policy_.get(), this, target_.c_str(), child_policy_.get());
+    LOG(INFO) << "[rlslb " << lb_policy_.get()
+              << "] ChildPolicyWrapper=" << this << " [" << target_
+              << "], updating child policy handler " << child_policy_.get();
   }
   UpdateArgs update_args;
   update_args.config = std::move(pending_config_);
@@ -934,12 +933,11 @@ void RlsLb::ChildPolicyWrapper::ChildPolicyHelper::UpdateState(
     grpc_connectivity_state state, const absl::Status& status,
     RefCountedPtr<SubchannelPicker> picker) {
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO,
-            "[rlslb %p] ChildPolicyWrapper=%p [%s] ChildPolicyHelper=%p: "
-            "UpdateState(state=%s, status=%s, picker=%p)",
-            wrapper_->lb_policy_.get(), wrapper_.get(),
-            wrapper_->target_.c_str(), this, ConnectivityStateName(state),
-            status.ToString().c_str(), picker.get());
+    LOG(INFO) << "[rlslb " << wrapper_->lb_policy_.get()
+              << "] ChildPolicyWrapper=" << wrapper_.get() << " ["
+              << wrapper_->target_ << "] ChildPolicyHelper=" << this
+              << ": UpdateState(state=" << ConnectivityStateName(state)
+              << ", status=" << status << ", picker=" << picker.get() << ")";
   }
   {
     MutexLock lock(&wrapper_->lb_policy_->mu_);
@@ -1042,8 +1040,8 @@ LoadBalancingPolicy::PickResult RlsLb::Picker::Pick(PickArgs args) {
                   lb_policy_->channel_control_helper()->GetAuthority(),
                   args.initial_metadata)};
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] picker=%p: request keys: %s",
-            lb_policy_.get(), this, key.ToString().c_str());
+    LOG(INFO) << "[rlslb " << lb_policy_.get() << "] picker=" << this
+              << ": request keys: " << key.ToString();
   }
   Timestamp now = Timestamp::Now();
   MutexLock lock(&lb_policy_->mu_);
@@ -1080,8 +1078,8 @@ LoadBalancingPolicy::PickResult RlsLb::Picker::Pick(PickArgs args) {
     // If the entry has non-expired data, use it.
     if (entry->data_expiration_time() >= now) {
       if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-        gpr_log(GPR_INFO, "[rlslb %p] picker=%p: using cache entry %p",
-                lb_policy_.get(), this, entry);
+        LOG(INFO) << "[rlslb " << lb_policy_.get() << "] picker=" << this
+                  << ": using cache entry " << entry;
       }
       return entry->Pick(args);
     }
@@ -1096,8 +1094,8 @@ LoadBalancingPolicy::PickResult RlsLb::Picker::Pick(PickArgs args) {
   }
   // RLS call pending.  Queue the pick.
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] picker=%p: RLS request pending; queuing pick",
-            lb_policy_.get(), this);
+    LOG(INFO) << "[rlslb " << lb_policy_.get() << "] picker=" << this
+              << ": RLS request pending; queuing pick";
   }
   return PickResult::Queue();
 }
@@ -1106,8 +1104,8 @@ LoadBalancingPolicy::PickResult RlsLb::Picker::PickFromDefaultTargetOrFail(
     const char* reason, PickArgs args, absl::Status status) {
   if (default_child_policy_ != nullptr) {
     if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-      gpr_log(GPR_INFO, "[rlslb %p] picker=%p: %s; using default target",
-              lb_policy_.get(), this, reason);
+      LOG(INFO) << "[rlslb " << lb_policy_.get() << "] picker=" << this << ": "
+                << reason << "; using default target";
     }
     auto pick_result = default_child_policy_->Pick(args);
     lb_policy_->MaybeExportPickCount(kMetricDefaultTargetPicks,
@@ -1115,8 +1113,8 @@ LoadBalancingPolicy::PickResult RlsLb::Picker::PickFromDefaultTargetOrFail(
     return pick_result;
   }
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] picker=%p: %s; failing pick",
-            lb_policy_.get(), this, reason);
+    LOG(INFO) << "[rlslb " << lb_policy_.get() << "] picker=" << this << ": "
+              << reason << "; failing pick";
   }
   auto& stats_plugins =
       lb_policy_->channel_control_helper()->GetStatsPluginGroup();
@@ -1152,10 +1150,11 @@ void RlsLb::Cache::Entry::BackoffTimer::Orphan() {
       entry_->lb_policy_->channel_control_helper()->GetEventEngine()->Cancel(
           *backoff_timer_task_handle_)) {
     if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-      gpr_log(GPR_INFO, "[rlslb %p] cache entry=%p %s, backoff timer canceled",
-              entry_->lb_policy_.get(), entry_.get(),
-              entry_->is_shutdown_ ? "(shut down)"
-                                   : entry_->lru_iterator_->ToString().c_str());
+      LOG(INFO) << "[rlslb " << entry_->lb_policy_.get()
+                << "] cache entry=" << entry_.get() << " "
+                << (entry_->is_shutdown_ ? "(shut down)"
+                                         : entry_->lru_iterator_->ToString())
+                << ", backoff timer canceled";
     }
   }
   backoff_timer_task_handle_.reset();
@@ -1166,10 +1165,11 @@ void RlsLb::Cache::Entry::BackoffTimer::OnBackoffTimerLocked() {
   {
     MutexLock lock(&entry_->lb_policy_->mu_);
     if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-      gpr_log(GPR_INFO, "[rlslb %p] cache entry=%p %s, backoff timer fired",
-              entry_->lb_policy_.get(), entry_.get(),
-              entry_->is_shutdown_ ? "(shut down)"
-                                   : entry_->lru_iterator_->ToString().c_str());
+      LOG(INFO) << "[rlslb " << entry_->lb_policy_.get()
+                << "] cache entry=" << entry_.get() << " "
+                << (entry_->is_shutdown_ ? "(shut down)"
+                                         : entry_->lru_iterator_->ToString())
+                << ", backoff timer fired";
     }
     // Skip the update if Orphaned
     if (!backoff_timer_task_handle_.has_value()) return;
@@ -1205,8 +1205,8 @@ RlsLb::Cache::Entry::Entry(RefCountedPtr<RlsLb> lb_policy,
 
 void RlsLb::Cache::Entry::Orphan() {
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] cache entry=%p %s: cache entry evicted",
-            lb_policy_.get(), this, lru_iterator_->ToString().c_str());
+    LOG(INFO) << "[rlslb " << lb_policy_.get() << "] cache entry=" << this
+              << " " << lru_iterator_->ToString() << ": cache entry evicted";
   }
   is_shutdown_ = true;
   lb_policy_->cache_.lru_list_.erase(lru_iterator_);
@@ -1236,12 +1236,11 @@ LoadBalancingPolicy::PickResult RlsLb::Cache::Entry::Pick(PickArgs args) {
             GRPC_CHANNEL_TRANSIENT_FAILURE &&
         i < child_policy_wrappers_.size() - 1) {
       if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-        gpr_log(GPR_INFO,
-                "[rlslb %p] cache entry=%p %s: target %s (%" PRIuPTR
-                " of %" PRIuPTR ") in state TRANSIENT_FAILURE; skipping",
-                lb_policy_.get(), this, lru_iterator_->ToString().c_str(),
-                child_policy_wrapper->target().c_str(), i,
-                child_policy_wrappers_.size());
+        LOG(INFO) << "[rlslb " << lb_policy_.get() << "] cache entry=" << this
+                  << " " << lru_iterator_->ToString() << ": target "
+                  << child_policy_wrapper->target() << " (" << i << " of "
+                  << child_policy_wrappers_.size()
+                  << ") in state TRANSIENT_FAILURE; skipping";
       }
       continue;
     }
@@ -1250,27 +1249,25 @@ LoadBalancingPolicy::PickResult RlsLb::Cache::Entry::Pick(PickArgs args) {
   // Child policy not in TRANSIENT_FAILURE or is the last target in
   // the list, so delegate.
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO,
-            "[rlslb %p] cache entry=%p %s: target %s (%" PRIuPTR " of %" PRIuPTR
-            ") in state %s; delegating",
-            lb_policy_.get(), this, lru_iterator_->ToString().c_str(),
-            child_policy_wrapper->target().c_str(), i,
-            child_policy_wrappers_.size(),
-            ConnectivityStateName(child_policy_wrapper->connectivity_state()));
-  }
-  // Add header data.
-  // Note that even if the target we're using is in TRANSIENT_FAILURE,
-  // the pick might still succeed (e.g., if the child is ring_hash), so
-  // we need to pass the right header info down in all cases.
-  if (!header_data_.empty()) {
-    char* copied_header_data =
-        static_cast<char*>(args.call_state->Alloc(header_data_.length() + 1));
-    strcpy(copied_header_data, header_data_.c_str());
-    args.initial_metadata->Add(kRlsHeaderKey, copied_header_data);
+    LOG(INFO) << "[rlslb " << lb_policy_.get() << "] cache entry=" << this
+              << " " << lru_iterator_->ToString() << ": target "
+              << child_policy_wrapper->target() << " (" << i << " of "
+              << child_policy_wrappers_.size() << ") in state "
+              << ConnectivityStateName(
+                     child_policy_wrapper->connectivity_state())
+              << "; delegating";
   }
   auto pick_result = child_policy_wrapper->Pick(args);
   lb_policy_->MaybeExportPickCount(kMetricTargetPicks,
                                    child_policy_wrapper->target(), pick_result);
+  // Add header data.
+  if (!header_data_.empty()) {
+    auto* complete_pick =
+        absl::get_if<PickResult::Complete>(&pick_result.result);
+    if (complete_pick != nullptr) {
+      complete_pick->metadata_mutations.Set(kRlsHeaderKey, header_data_.Ref());
+    }
+  }
   return pick_result;
 }
 
@@ -1407,15 +1404,15 @@ RlsLb::Cache::Entry* RlsLb::Cache::FindOrInsert(const RequestKey& key) {
     map_.emplace(key, OrphanablePtr<Entry>(entry));
     size_ += entry_size;
     if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-      gpr_log(GPR_INFO, "[rlslb %p] key=%s: cache entry added, entry=%p",
-              lb_policy_, key.ToString().c_str(), entry);
+      LOG(INFO) << "[rlslb " << lb_policy_ << "] key=" << key.ToString()
+                << ": cache entry added, entry=" << entry;
     }
     return entry;
   }
   // Entry found, so use it.
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] key=%s: found cache entry %p", lb_policy_,
-            key.ToString().c_str(), it->second.get());
+    LOG(INFO) << "[rlslb " << lb_policy_ << "] key=" << key.ToString()
+              << ": found cache entry " << it->second.get();
   }
   it->second->MarkUsed();
   return it->second.get();
@@ -1423,8 +1420,8 @@ RlsLb::Cache::Entry* RlsLb::Cache::FindOrInsert(const RequestKey& key) {
 
 void RlsLb::Cache::Resize(size_t bytes) {
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] resizing cache to %" PRIuPTR " bytes",
-            lb_policy_, bytes);
+    LOG(INFO) << "[rlslb " << lb_policy_ << "] resizing cache to " << bytes
+              << " bytes";
   }
   size_limit_ = bytes;
   MaybeShrinkSize(size_limit_);
@@ -1444,7 +1441,7 @@ void RlsLb::Cache::Shutdown() {
       lb_policy_->channel_control_helper()->GetEventEngine()->Cancel(
           *cleanup_timer_handle_)) {
     if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-      gpr_log(GPR_INFO, "[rlslb %p] cache cleanup timer canceled", lb_policy_);
+      LOG(INFO) << "[rlslb " << lb_policy_ << "] cache cleanup timer canceled";
     }
   }
   cleanup_timer_handle_.reset();
@@ -1482,7 +1479,7 @@ void RlsLb::Cache::StartCleanupTimer() {
 
 void RlsLb::Cache::OnCleanupTimer() {
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] cache cleanup timer fired", lb_policy_);
+    LOG(INFO) << "[rlslb " << lb_policy_ << "] cache cleanup timer fired";
   }
   MutexLock lock(&lb_policy_->mu_);
   if (!cleanup_timer_handle_.has_value()) return;
@@ -1511,17 +1508,16 @@ void RlsLb::Cache::MaybeShrinkSize(size_t bytes) {
     CHECK(map_it != map_.end());
     if (!map_it->second->CanEvict()) break;
     if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-      gpr_log(GPR_INFO, "[rlslb %p] LRU eviction: removing entry %p %s",
-              lb_policy_, map_it->second.get(), lru_it->ToString().c_str());
+      LOG(INFO) << "[rlslb " << lb_policy_ << "] LRU eviction: removing entry "
+                << map_it->second.get() << " " << lru_it->ToString();
     }
     size_ -= map_it->second->Size();
     map_.erase(map_it);
   }
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO,
-            "[rlslb %p] LRU pass complete: desired size=%" PRIuPTR
-            " size=%" PRIuPTR,
-            lb_policy_, bytes, size_);
+    LOG(INFO) << "[rlslb " << lb_policy_
+              << "] LRU pass complete: desired size=" << bytes
+              << " size=" << size_;
   }
 }
 
@@ -1533,11 +1529,9 @@ void RlsLb::RlsChannel::StateWatcher::OnConnectivityStateChange(
     grpc_connectivity_state new_state, const absl::Status& status) {
   auto* lb_policy = rls_channel_->lb_policy_.get();
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO,
-            "[rlslb %p] RlsChannel=%p StateWatcher=%p: "
-            "state changed to %s (%s)",
-            lb_policy, rls_channel_.get(), this,
-            ConnectivityStateName(new_state), status.ToString().c_str());
+    LOG(INFO) << "[rlslb " << lb_policy << "] RlsChannel=" << rls_channel_.get()
+              << " StateWatcher=" << this << ": state changed to "
+              << ConnectivityStateName(new_state) << " (" << status << ")";
   }
   if (rls_channel_->is_shutdown_) return;
   MutexLock lock(&lb_policy->mu_);
@@ -1632,9 +1626,9 @@ RlsLb::RlsChannel::RlsChannel(RefCountedPtr<RlsLb> lb_policy)
       grpc_channel_create(lb_policy_->config_->lookup_service().c_str(),
                           creds.get(), args.ToC().get())));
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] RlsChannel=%p: created channel %p for %s",
-            lb_policy_.get(), this, channel_.get(),
-            lb_policy_->config_->lookup_service().c_str());
+    LOG(INFO) << "[rlslb " << lb_policy_.get() << "] RlsChannel=" << this
+              << ": created channel " << channel_.get() << " for "
+              << lb_policy_->config_->lookup_service();
   }
   if (channel_ != nullptr) {
     // Set up channelz linkage.
@@ -1655,8 +1649,8 @@ RlsLb::RlsChannel::RlsChannel(RefCountedPtr<RlsLb> lb_policy)
 
 void RlsLb::RlsChannel::Orphan() {
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] RlsChannel=%p, channel=%p: shutdown",
-            lb_policy_.get(), this, channel_.get());
+    LOG(INFO) << "[rlslb " << lb_policy_.get() << "] RlsChannel=" << this
+              << ", channel=" << channel_.get() << ": shutdown";
   }
   is_shutdown_ = true;
   if (channel_ != nullptr) {
@@ -1681,11 +1675,11 @@ void RlsLb::RlsChannel::StartRlsCall(const RequestKey& key,
   std::unique_ptr<BackOff> backoff_state;
   grpc_lookup_v1_RouteLookupRequest_Reason reason =
       grpc_lookup_v1_RouteLookupRequest_REASON_MISS;
-  std::string stale_header_data;
+  grpc_event_engine::experimental::Slice stale_header_data;
   if (stale_entry != nullptr) {
     backoff_state = stale_entry->TakeBackoffState();
     reason = grpc_lookup_v1_RouteLookupRequest_REASON_STALE;
-    stale_header_data = stale_entry->header_data();
+    stale_header_data = stale_entry->header_data().Ref();
   }
   lb_policy_->request_map_.emplace(
       key, MakeOrphanable<RlsRequest>(
@@ -1707,11 +1701,12 @@ void RlsLb::RlsChannel::ResetBackoff() {
 // RlsLb::RlsRequest
 //
 
-RlsLb::RlsRequest::RlsRequest(RefCountedPtr<RlsLb> lb_policy, RequestKey key,
-                              RefCountedPtr<RlsChannel> rls_channel,
-                              std::unique_ptr<BackOff> backoff_state,
-                              grpc_lookup_v1_RouteLookupRequest_Reason reason,
-                              std::string stale_header_data)
+RlsLb::RlsRequest::RlsRequest(
+    RefCountedPtr<RlsLb> lb_policy, RequestKey key,
+    RefCountedPtr<RlsChannel> rls_channel,
+    std::unique_ptr<BackOff> backoff_state,
+    grpc_lookup_v1_RouteLookupRequest_Reason reason,
+    grpc_event_engine::experimental::Slice stale_header_data)
     : InternallyRefCounted<RlsRequest>(
           GRPC_TRACE_FLAG_ENABLED(rls_lb) ? "RlsRequest" : nullptr),
       lb_policy_(std::move(lb_policy)),
@@ -1721,9 +1716,8 @@ RlsLb::RlsRequest::RlsRequest(RefCountedPtr<RlsLb> lb_policy, RequestKey key,
       reason_(reason),
       stale_header_data_(std::move(stale_header_data)) {
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO,
-            "[rlslb %p] rls_request=%p: RLS request created for key %s",
-            lb_policy_.get(), this, key_.ToString().c_str());
+    LOG(INFO) << "[rlslb " << lb_policy_.get() << "] rls_request=" << this
+              << ": RLS request created for key " << key_.ToString();
   }
   GRPC_CLOSURE_INIT(&call_complete_cb_, OnRlsCallComplete, this, nullptr);
   ExecCtx::Run(
@@ -1738,8 +1732,8 @@ RlsLb::RlsRequest::~RlsRequest() { CHECK_EQ(call_, nullptr); }
 void RlsLb::RlsRequest::Orphan() {
   if (call_ != nullptr) {
     if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-      gpr_log(GPR_INFO, "[rlslb %p] rls_request=%p %s: cancelling RLS call",
-              lb_policy_.get(), this, key_.ToString().c_str());
+      LOG(INFO) << "[rlslb " << lb_policy_.get() << "] rls_request=" << this
+                << " " << key_.ToString() << ": cancelling RLS call";
     }
     grpc_call_cancel_internal(call_);
   }
@@ -1812,12 +1806,10 @@ void RlsLb::RlsRequest::OnRlsCallComplete(void* arg, grpc_error_handle error) {
 void RlsLb::RlsRequest::OnRlsCallCompleteLocked(grpc_error_handle error) {
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
     std::string status_message(StringViewFromSlice(status_details_recv_));
-    gpr_log(GPR_INFO,
-            "[rlslb %p] rls_request=%p %s, error=%s, status={%d, %s} RLS call "
-            "response received",
-            lb_policy_.get(), this, key_.ToString().c_str(),
-            StatusToString(error).c_str(), status_recv_,
-            status_message.c_str());
+    LOG(INFO) << "[rlslb " << lb_policy_.get() << "] rls_request=" << this
+              << " " << key_.ToString() << ", error=" << StatusToString(error)
+              << ", status={" << status_recv_ << ", " << status_message << "}"
+              << " RLS call response received";
   }
   // Parse response.
   ResponseInfo response;
@@ -1844,9 +1836,9 @@ void RlsLb::RlsRequest::OnRlsCallCompleteLocked(grpc_error_handle error) {
   call_ = nullptr;
   // Return result to cache.
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] rls_request=%p %s: response info: %s",
-            lb_policy_.get(), this, key_.ToString().c_str(),
-            response.ToString().c_str());
+    LOG(INFO) << "[rlslb " << lb_policy_.get() << "] rls_request=" << this
+              << " " << key_.ToString()
+              << ": response info: " << response.ToString();
   }
   std::vector<ChildPolicyWrapper*> child_policies_to_finish_update;
   {
@@ -1889,8 +1881,7 @@ grpc_byte_buffer* RlsLb::RlsRequest::MakeRequestProto() {
   grpc_lookup_v1_RouteLookupRequest_set_reason(req, reason_);
   if (!stale_header_data_.empty()) {
     grpc_lookup_v1_RouteLookupRequest_set_stale_header_data(
-        req, upb_StringView_FromDataAndSize(stale_header_data_.data(),
-                                            stale_header_data_.size()));
+        req, StdStringToUpbString(stale_header_data_.as_string_view()));
   }
   size_t len;
   char* buf =
@@ -1933,7 +1924,8 @@ RlsLb::ResponseInfo RlsLb::RlsRequest::ParseResponseProto() {
   upb_StringView header_data_strview =
       grpc_lookup_v1_RouteLookupResponse_header_data(response);
   response_info.header_data =
-      std::string(header_data_strview.data, header_data_strview.size);
+      grpc_event_engine::experimental::Slice::FromCopiedBuffer(
+          header_data_strview.data, header_data_strview.size);
   return response_info;
 }
 
@@ -1963,7 +1955,7 @@ RlsLb::RlsLb(Args args)
               },
               Duration::Seconds(5), kMetricCacheSize, kMetricCacheEntries)) {
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] policy created", this);
+    LOG(INFO) << "[rlslb " << this << "] policy created";
   }
 }
 
@@ -1990,7 +1982,7 @@ bool EndpointsEqual(
 
 absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] policy updated", this);
+    LOG(INFO) << "[rlslb " << this << "] policy updated";
   }
   update_in_progress_ = true;
   // Swap out config.
@@ -1999,8 +1991,8 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb) &&
       (old_config == nullptr ||
        old_config->child_policy_config() != config_->child_policy_config())) {
-    gpr_log(GPR_INFO, "[rlslb %p] updated child policy config: %s", this,
-            JsonDump(config_->child_policy_config()).c_str());
+    LOG(INFO) << "[rlslb " << this << "] updated child policy config: "
+              << JsonDump(config_->child_policy_config());
   }
   // Swap out addresses.
   // If the new address list is an error and we have an existing address list,
@@ -2025,14 +2017,14 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
       config_->default_target() != old_config->default_target()) {
     if (config_->default_target().empty()) {
       if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-        gpr_log(GPR_INFO, "[rlslb %p] unsetting default target", this);
+        LOG(INFO) << "[rlslb " << this << "] unsetting default target";
       }
       default_child_policy_.reset();
     } else {
       auto it = child_policy_map_.find(config_->default_target());
       if (it == child_policy_map_.end()) {
         if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-          gpr_log(GPR_INFO, "[rlslb %p] creating new default target", this);
+          LOG(INFO) << "[rlslb " << this << "] creating new default target";
         }
         default_child_policy_ = MakeRefCounted<ChildPolicyWrapper>(
             RefAsSubclass<RlsLb>(DEBUG_LOCATION, "ChildPolicyWrapper"),
@@ -2040,8 +2032,8 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
         created_default_child = true;
       } else {
         if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-          gpr_log(GPR_INFO,
-                  "[rlslb %p] using existing child for default target", this);
+          LOG(INFO) << "[rlslb " << this
+                    << "] using existing child for default target";
         }
         default_child_policy_ =
             it->second->Ref(DEBUG_LOCATION, "DefaultChildPolicy");
@@ -2065,15 +2057,15 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
     // Start update of child policies if needed.
     if (update_child_policies) {
       if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-        gpr_log(GPR_INFO, "[rlslb %p] starting child policy updates", this);
+        LOG(INFO) << "[rlslb " << this << "] starting child policy updates";
       }
       for (auto& p : child_policy_map_) {
         p.second->StartUpdate();
       }
     } else if (created_default_child) {
       if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-        gpr_log(GPR_INFO, "[rlslb %p] starting default child policy update",
-                this);
+        LOG(INFO) << "[rlslb " << this
+                  << "] starting default child policy update";
       }
       default_child_policy_->StartUpdate();
     }
@@ -2082,7 +2074,7 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
   std::vector<std::string> errors;
   if (update_child_policies) {
     if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-      gpr_log(GPR_INFO, "[rlslb %p] finishing child policy updates", this);
+      LOG(INFO) << "[rlslb " << this << "] finishing child policy updates";
     }
     for (auto& p : child_policy_map_) {
       absl::Status status = p.second->MaybeFinishUpdate();
@@ -2093,8 +2085,8 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
     }
   } else if (created_default_child) {
     if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-      gpr_log(GPR_INFO, "[rlslb %p] finishing default child policy update",
-              this);
+      LOG(INFO) << "[rlslb " << this
+                << "] finishing default child policy update";
     }
     absl::Status status = default_child_policy_->MaybeFinishUpdate();
     if (!status.ok()) {
@@ -2138,7 +2130,7 @@ void RlsLb::ResetBackoffLocked() {
 
 void RlsLb::ShutdownLocked() {
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] policy shutdown", this);
+    LOG(INFO) << "[rlslb " << this << "] policy shutdown";
   }
   registered_metric_callback_.reset();
   MutexLock lock(&mu_);
@@ -2182,7 +2174,7 @@ void RlsLb::UpdatePickerLocked() {
   // is being propagated to our children.
   if (update_in_progress_) return;
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] updating picker", this);
+    LOG(INFO) << "[rlslb " << this << "] updating picker";
   }
   grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
   if (!child_policy_map_.empty()) {
@@ -2195,9 +2187,8 @@ void RlsLb::UpdatePickerLocked() {
       for (auto& p : child_policy_map_) {
         grpc_connectivity_state child_state = p.second->connectivity_state();
         if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-          gpr_log(GPR_INFO, "[rlslb %p] target %s in state %s", this,
-                  p.second->target().c_str(),
-                  ConnectivityStateName(child_state));
+          LOG(INFO) << "[rlslb " << this << "] target " << p.second->target()
+                    << " in state " << ConnectivityStateName(child_state);
         }
         if (child_state == GRPC_CHANNEL_READY) {
           state = GRPC_CHANNEL_READY;
@@ -2218,8 +2209,8 @@ void RlsLb::UpdatePickerLocked() {
     }
   }
   if (GRPC_TRACE_FLAG_ENABLED(rls_lb)) {
-    gpr_log(GPR_INFO, "[rlslb %p] reporting state %s", this,
-            ConnectivityStateName(state));
+    LOG(INFO) << "[rlslb " << this << "] reporting state "
+              << ConnectivityStateName(state);
   }
   absl::Status status;
   if (state == GRPC_CHANNEL_TRANSIENT_FAILURE) {