grpc 1.63.0 → 1.71.0

data/src/core/client_channel/client_channel_filter.cc

@@ -14,22 +14,32 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/client_channel/client_channel_filter.h"
 
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/impl/channel_arg_names.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
+#include <grpc/support/json.h>
+#include <grpc/support/port_platform.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/time.h>
 #include <inttypes.h>
 #include <limits.h>
 
 #include <algorithm>
 #include <functional>
 #include <new>
+#include <optional>
 #include <set>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/cleanup/cleanup.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/cord.h"
@@ -37,51 +47,30 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
-
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/impl/channel_arg_names.h>
-#include <grpc/slice.h>
-#include <grpc/status.h>
-#include <grpc/support/json.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-#include <grpc/support/time.h>
-
+#include "src/core/channelz/channel_trace.h"
 #include "src/core/client_channel/backup_poller.h"
-#include "src/core/client_channel/client_channel_channelz.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/client_channel_service_config.h"
 #include "src/core/client_channel/config_selector.h"
 #include "src/core/client_channel/dynamic_filters.h"
 #include "src/core/client_channel/global_subchannel_pool.h"
+#include "src/core/client_channel/lb_metadata.h"
 #include "src/core/client_channel/local_subchannel_pool.h"
 #include "src/core/client_channel/retry_filter.h"
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/client_channel/subchannel_interface_internal.h"
-#include "src/core/ext/filters/deadline/deadline_filter.h"
+#include "src/core/config/core_configuration.h"
+#include "src/core/handshaker/proxy_mapper_registry.h"
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/status_util.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/crash.h"
-#include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
-#include "src/core/lib/gprpp/status_helper.h"
-#include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/gprpp/unique_type_name.h"
-#include "src/core/lib/gprpp/work_serializer.h"
-#include "src/core/lib/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/json/json.h"
 #include "src/core/lib/promise/cancel_callback.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/latch.h"
@@ -105,6 +94,15 @@
 #include "src/core/resolver/resolver_registry.h"
 #include "src/core/service_config/service_config_call_data.h"
 #include "src/core/service_config/service_config_impl.h"
+#include "src/core/util/crash.h"
+#include "src/core/util/debug_location.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/manual_constructor.h"
+#include "src/core/util/status_helper.h"
+#include "src/core/util/sync.h"
+#include "src/core/util/unique_type_name.h"
+#include "src/core/util/useful.h"
+#include "src/core/util/work_serializer.h"
 
 //
 // Client channel filter
@@ -114,10 +112,6 @@ namespace grpc_core {
 
 using internal::ClientChannelMethodParsedConfig;
 
-TraceFlag grpc_client_channel_trace(false, "client_channel");
-TraceFlag grpc_client_channel_call_trace(false, "client_channel_call");
-TraceFlag grpc_client_channel_lb_call_trace(false, "client_channel_lb_call");
-
 //
 // ClientChannelFilter::CallData definition
 //
@@ -145,14 +139,14 @@ class ClientChannelFilter::CallData {
   // Checks whether a resolver result is available.  The following
   // outcomes are possible:
   // - No resolver result is available yet.  The call will be queued and
-  //   absl::nullopt will be returned.  Later, when a resolver result
+  //   std::nullopt will be returned.  Later, when a resolver result
   //   becomes available, RetryCheckResolutionLocked() will be called.
   // - The resolver has returned a transient failure.  If the call is
   //   not wait_for_ready, a non-OK status will be returned.  (If the
   //   call *is* wait_for_ready, it will be queued instead.)
   // - There is a valid resolver result.  The service config will be
   //   stored in the call context and an OK status will be returned.
-  absl::optional<absl::Status> CheckResolution(bool was_queued);
+  std::optional<absl::Status> CheckResolution(bool was_queued);
 
  private:
   // Accessors for data stored in the subclass.
@@ -160,7 +154,6 @@ class ClientChannelFilter::CallData {
   virtual Arena* arena() const = 0;
   virtual grpc_polling_entity* pollent() = 0;
   virtual grpc_metadata_batch* send_initial_metadata() = 0;
-  virtual grpc_call_context_element* call_context() const = 0;
 
   // Helper function for CheckResolution().  Returns true if the call
   // can continue (i.e., there is a valid resolution result, or there is
@@ -210,22 +203,19 @@ class ClientChannelFilter::FilterBasedCallData final
                       const grpc_call_element_args& args);
   ~FilterBasedCallData() override;
 
-  grpc_call_element* elem() const { return deadline_state_.elem; }
-  grpc_call_stack* owning_call() const { return deadline_state_.call_stack; }
-  CallCombiner* call_combiner() const { return deadline_state_.call_combiner; }
+  grpc_call_element* elem() const { return elem_; }
+  grpc_call_stack* owning_call() const { return owning_call_; }
+  CallCombiner* call_combiner() const { return call_combiner_; }
 
   ClientChannelFilter* chand() const override {
     return static_cast<ClientChannelFilter*>(elem()->channel_data);
   }
-  Arena* arena() const override { return deadline_state_.arena; }
+  Arena* arena() const override { return arena_; }
   grpc_polling_entity* pollent() override { return pollent_; }
   grpc_metadata_batch* send_initial_metadata() override {
     return pending_batches_[0]
         ->payload->send_initial_metadata.send_initial_metadata;
   }
-  grpc_call_context_element* call_context() const override {
-    return call_context_;
-  }
 
   // Returns the index into pending_batches_ to be used for batch.
   static size_t GetBatchIndex(grpc_transport_stream_op_batch* batch);
@@ -270,10 +260,7 @@ class ClientChannelFilter::FilterBasedCallData final
   void ResetDeadline(Duration timeout) override {
     const Timestamp per_method_deadline =
         Timestamp::FromCycleCounterRoundUp(call_start_time_) + timeout;
-    if (per_method_deadline < deadline_) {
-      deadline_ = per_method_deadline;
-      grpc_deadline_state_reset(&deadline_state_, deadline_);
-    }
+    arena_->GetContext<Call>()->UpdateDeadline(per_method_deadline);
   }
 
   void CreateDynamicCall();
@@ -282,12 +269,13 @@ class ClientChannelFilter::FilterBasedCallData final
       void* arg, grpc_error_handle error);
 
   grpc_slice path_;  // Request path.
-  grpc_call_context_element* call_context_;
   gpr_cycle_counter call_start_time_;
   Timestamp deadline_;
 
-  // State for handling deadlines.
-  grpc_deadline_state deadline_state_;
+  Arena* const arena_;
+  grpc_call_element* const elem_;
+  grpc_call_stack* const owning_call_;
+  CallCombiner* const call_combiner_;
 
   grpc_polling_entity* pollent_ = nullptr;
 
@@ -311,104 +299,12 @@ class ClientChannelFilter::FilterBasedCallData final
   grpc_error_handle cancel_error_;
 };
 
-class ClientChannelFilter::PromiseBasedCallData final
-    : public ClientChannelFilter::CallData {
- public:
-  explicit PromiseBasedCallData(ClientChannelFilter* chand) : chand_(chand) {}
-
-  ~PromiseBasedCallData() override {
-    if (was_queued_ && client_initial_metadata_ != nullptr) {
-      MutexLock lock(&chand_->resolution_mu_);
-      RemoveCallFromResolverQueuedCallsLocked();
-      chand_->resolver_queued_calls_.erase(this);
-    }
-  }
-
-  ArenaPromise<absl::StatusOr<CallArgs>> MakeNameResolutionPromise(
-      CallArgs call_args) {
-    pollent_ = NowOrNever(call_args.polling_entity->WaitAndCopy()).value();
-    client_initial_metadata_ = std::move(call_args.client_initial_metadata);
-    // If we're still in IDLE, we need to start resolving.
-    if (GPR_UNLIKELY(chand_->CheckConnectivityState(false) ==
-                     GRPC_CHANNEL_IDLE)) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-        gpr_log(GPR_INFO, "chand=%p calld=%p: %striggering exit idle", chand_,
-                this, GetContext<Activity>()->DebugTag().c_str());
-      }
-      // Bounce into the control plane work serializer to start resolving.
-      GRPC_CHANNEL_STACK_REF(chand_->owning_stack_, "ExitIdle");
-      chand_->work_serializer_->Run(
-          [chand = chand_]()
-              ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
-                chand->CheckConnectivityState(/*try_to_connect=*/true);
-                GRPC_CHANNEL_STACK_UNREF(chand->owning_stack_, "ExitIdle");
-              },
-          DEBUG_LOCATION);
-    }
-    return [this, call_args = std::move(
-                      call_args)]() mutable -> Poll<absl::StatusOr<CallArgs>> {
-      auto result = CheckResolution(was_queued_);
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-        gpr_log(GPR_INFO, "chand=%p calld=%p: %sCheckResolution returns %s",
-                chand_, this, GetContext<Activity>()->DebugTag().c_str(),
-                result.has_value() ? result->ToString().c_str() : "Pending");
-      }
-      if (!result.has_value()) return Pending{};
-      if (!result->ok()) return *result;
-      call_args.client_initial_metadata = std::move(client_initial_metadata_);
-      return std::move(call_args);
-    };
-  }
-
- private:
-  ClientChannelFilter* chand() const override { return chand_; }
-  Arena* arena() const override { return GetContext<Arena>(); }
-  grpc_polling_entity* pollent() override { return &pollent_; }
-  grpc_metadata_batch* send_initial_metadata() override {
-    return client_initial_metadata_.get();
-  }
-  grpc_call_context_element* call_context() const override {
-    return GetContext<grpc_call_context_element>();
-  }
-
-  void OnAddToQueueLocked() override
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannelFilter::resolution_mu_) {
-    waker_ = GetContext<Activity>()->MakeNonOwningWaker();
-    was_queued_ = true;
-  }
-
-  void RetryCheckResolutionLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
-      &ClientChannelFilter::resolution_mu_) override {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-      gpr_log(GPR_INFO, "chand=%p calld=%p: RetryCheckResolutionLocked(): %s",
-              chand_, this, waker_.ActivityDebugTag().c_str());
-    }
-    waker_.WakeupAsync();
-  }
-
-  void ResetDeadline(Duration timeout) override {
-    CallContext* call_context = GetContext<CallContext>();
-    const Timestamp per_method_deadline =
-        Timestamp::FromCycleCounterRoundUp(call_context->call_start_time()) +
-        timeout;
-    call_context->UpdateDeadline(per_method_deadline);
-  }
-
-  ClientChannelFilter* chand_;
-  grpc_polling_entity pollent_;
-  ClientMetadataHandle client_initial_metadata_;
-  bool was_queued_ = false;
-  Waker waker_ ABSL_GUARDED_BY(&ClientChannelFilter::resolution_mu_);
-};
-
 //
 // Filter vtable
 //
 
-const grpc_channel_filter ClientChannelFilter::kFilterVtableWithPromises = {
+const grpc_channel_filter ClientChannelFilter::kFilter = {
     ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch,
-    ClientChannelFilter::MakeCallPromise,
-    /* init_call: */ nullptr,
     ClientChannelFilter::StartTransportOp,
     sizeof(ClientChannelFilter::FilterBasedCallData),
     ClientChannelFilter::FilterBasedCallData::Init,
@@ -419,24 +315,7 @@ const grpc_channel_filter ClientChannelFilter::kFilterVtableWithPromises = {
     grpc_channel_stack_no_post_init,
     ClientChannelFilter::Destroy,
     ClientChannelFilter::GetChannelInfo,
-    "client-channel",
-};
-
-const grpc_channel_filter ClientChannelFilter::kFilterVtableWithoutPromises = {
-    ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch,
-    nullptr,
-    /* init_call: */ nullptr,
-    ClientChannelFilter::StartTransportOp,
-    sizeof(ClientChannelFilter::FilterBasedCallData),
-    ClientChannelFilter::FilterBasedCallData::Init,
-    ClientChannelFilter::FilterBasedCallData::SetPollent,
-    ClientChannelFilter::FilterBasedCallData::Destroy,
-    sizeof(ClientChannelFilter),
-    ClientChannelFilter::Init,
-    grpc_channel_stack_no_post_init,
-    ClientChannelFilter::Destroy,
-    ClientChannelFilter::GetChannelInfo,
-    "client-channel",
+    GRPC_UNIQUE_TYPE_NAME_HERE("client-channel"),
 };
 
 //
@@ -445,10 +324,9 @@ const grpc_channel_filter ClientChannelFilter::kFilterVtableWithoutPromises = {
 
 namespace {
 
-ClientChannelServiceConfigCallData* GetServiceConfigCallData(
-    grpc_call_context_element* context) {
-  return static_cast<ClientChannelServiceConfigCallData*>(
-      context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value);
+ClientChannelServiceConfigCallData* GetServiceConfigCallData(Arena* arena) {
+  return DownCast<ClientChannelServiceConfigCallData*>(
+      arena->GetContext<ServiceConfigCallData>());
 }
 
 class DynamicTerminationFilter final {
@@ -459,8 +337,8 @@ class DynamicTerminationFilter final {
 
   static grpc_error_handle Init(grpc_channel_element* elem,
                                 grpc_channel_element_args* args) {
-    GPR_ASSERT(args->is_last);
-    GPR_ASSERT(elem->filter == &kFilterVtable);
+    CHECK(args->is_last);
+    CHECK(elem->filter == &kFilterVtable);
     new (elem->channel_data) DynamicTerminationFilter(args->channel_args);
     return absl::OkStatus();
   }
@@ -476,19 +354,6 @@ class DynamicTerminationFilter final {
   static void GetChannelInfo(grpc_channel_element* /*elem*/,
                              const grpc_channel_info* /*info*/) {}
 
-  static ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      grpc_channel_element* elem, CallArgs call_args, NextPromiseFactory) {
-    auto* chand = static_cast<DynamicTerminationFilter*>(elem->channel_data);
-    return chand->chand_->CreateLoadBalancedCallPromise(
-        std::move(call_args),
-        []() {
-          auto* service_config_call_data =
-              GetServiceConfigCallData(GetContext<grpc_call_context_element>());
-          service_config_call_data->Commit();
-        },
-        /*is_transparent_retry=*/false);
-  }
-
  private:
   explicit DynamicTerminationFilter(const ChannelArgs& args)
       : chand_(args.GetObject<ClientChannelFilter>()) {}
@@ -532,21 +397,18 @@ class DynamicTerminationFilter::CallData final {
     auto* calld = static_cast<CallData*>(elem->call_data);
     auto* chand = static_cast<DynamicTerminationFilter*>(elem->channel_data);
     ClientChannelFilter* client_channel = chand->chand_;
-    grpc_call_element_args args = {calld->owning_call_,  nullptr,
-                                   calld->call_context_, calld->path_,
-                                   /*start_time=*/0,     calld->deadline_,
-                                   calld->arena_,        calld->call_combiner_};
-    auto* service_config_call_data =
-        GetServiceConfigCallData(calld->call_context_);
+    grpc_call_element_args args = {calld->owning_call_, nullptr,
+                                   calld->path_,
+                                   /*start_time=*/0,    calld->deadline_,
+                                   calld->arena_,       calld->call_combiner_};
+    auto* service_config_call_data = GetServiceConfigCallData(calld->arena_);
     calld->lb_call_ = client_channel->CreateLoadBalancedCall(
         args, pollent, nullptr,
         [service_config_call_data]() { service_config_call_data->Commit(); },
         /*is_transparent_retry=*/false);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-      gpr_log(GPR_INFO,
-              "chand=%p dynamic_termination_calld=%p: create lb_call=%p", chand,
-              client_channel, calld->lb_call_.get());
-    }
+    GRPC_TRACE_LOG(client_channel_call, INFO)
+        << "chand=" << chand << " dynamic_termination_calld=" << client_channel
+        << ": create lb_call=" << calld->lb_call_.get();
   }
 
  private:
@@ -555,8 +417,7 @@ class DynamicTerminationFilter::CallData final {
         deadline_(args.deadline),
         arena_(args.arena),
         owning_call_(args.call_stack),
-        call_combiner_(args.call_combiner),
-        call_context_(args.context) {}
+        call_combiner_(args.call_combiner) {}
 
   ~CallData() { CSliceUnref(path_); }
 
@@ -565,15 +426,12 @@ class DynamicTerminationFilter::CallData final {
   Arena* arena_;
   grpc_call_stack* owning_call_;
   CallCombiner* call_combiner_;
-  grpc_call_context_element* call_context_;
 
   OrphanablePtr<ClientChannelFilter::FilterBasedLoadBalancedCall> lb_call_;
 };
 
 const grpc_channel_filter DynamicTerminationFilter::kFilterVtable = {
     DynamicTerminationFilter::CallData::StartTransportStreamOpBatch,
-    DynamicTerminationFilter::MakeCallPromise,
-    /* init_call: */ nullptr,
     DynamicTerminationFilter::StartTransportOp,
     sizeof(DynamicTerminationFilter::CallData),
     DynamicTerminationFilter::CallData::Init,
@@ -584,7 +442,7 @@ const grpc_channel_filter DynamicTerminationFilter::kFilterVtable = {
     grpc_channel_stack_no_post_init,
     DynamicTerminationFilter::Destroy,
     DynamicTerminationFilter::GetChannelInfo,
-    "dynamic_filter_termination",
+    GRPC_UNIQUE_TYPE_NAME_HERE("dynamic_filter_termination"),
 };
 
 }  // namespace
@@ -601,9 +459,8 @@ class ClientChannelFilter::ResolverResultHandler final
   }
 
   ~ResolverResultHandler() override {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-      gpr_log(GPR_INFO, "chand=%p: resolver shutdown complete", chand_);
-    }
+    GRPC_TRACE_LOG(client_channel, INFO)
+        << "chand=" << chand_ << ": resolver shutdown complete";
     GRPC_CHANNEL_STACK_UNREF(chand_->owning_stack_, "ResolverResultHandler");
   }
 
@@ -633,18 +490,18 @@ class ClientChannelFilter::SubchannelWrapper final
  public:
   SubchannelWrapper(ClientChannelFilter* chand,
                     RefCountedPtr<Subchannel> subchannel)
-      : SubchannelInterface(GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)
+      : SubchannelInterface(GRPC_TRACE_FLAG_ENABLED(client_channel)
                                 ? "SubchannelWrapper"
                                 : nullptr),
         chand_(chand),
         subchannel_(std::move(subchannel)) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-      gpr_log(GPR_INFO,
-              "chand=%p: creating subchannel wrapper %p for subchannel %p",
-              chand, this, subchannel_.get());
-    }
+    GRPC_TRACE_LOG(client_channel, INFO)
+        << "chand=" << chand << ": creating subchannel wrapper " << this
+        << " for subchannel " << subchannel_.get();
     GRPC_CHANNEL_STACK_REF(chand_->owning_stack_, "SubchannelWrapper");
-    GPR_DEBUG_ASSERT(chand_->work_serializer_->RunningInWorkSerializer());
+#ifndef NDEBUG
+    DCHECK(chand_->work_serializer_->RunningInWorkSerializer());
+#endif
     if (chand_->channelz_node_ != nullptr) {
       auto* subchannel_node = subchannel_->channelz_node();
       if (subchannel_node != nullptr) {
@@ -661,18 +518,25 @@ class ClientChannelFilter::SubchannelWrapper final
   }
 
   ~SubchannelWrapper() override {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-      gpr_log(GPR_INFO,
-              "chand=%p: destroying subchannel wrapper %p for subchannel %p",
-              chand_, this, subchannel_.get());
-    }
-    if (!IsWorkSerializerDispatchEnabled()) {
+    GRPC_TRACE_LOG(client_channel, INFO)
+        << "chand=" << chand_ << ": destroying subchannel wrapper " << this
+        << "for subchannel " << subchannel_.get();
+    GRPC_CHANNEL_STACK_UNREF(chand_->owning_stack_, "SubchannelWrapper");
+  }
+
+  void Orphaned() override {
+    // Make sure we clean up the channel's subchannel maps inside the
+    // WorkSerializer.
+    // Ref held by callback.
+    WeakRef(DEBUG_LOCATION, "subchannel map cleanup").release();
+    chand_->work_serializer_->Run([this]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
+                                      *chand_->work_serializer_) {
       chand_->subchannel_wrappers_.erase(this);
       if (chand_->channelz_node_ != nullptr) {
         auto* subchannel_node = subchannel_->channelz_node();
         if (subchannel_node != nullptr) {
           auto it = chand_->subchannel_refcount_map_.find(subchannel_.get());
-          GPR_ASSERT(it != chand_->subchannel_refcount_map_.end());
+          CHECK(it != chand_->subchannel_refcount_map_.end());
           --it->second;
           if (it->second == 0) {
             chand_->channelz_node_->RemoveChildSubchannel(
@@ -681,43 +545,15 @@ class ClientChannelFilter::SubchannelWrapper final
           }
         }
       }
-    }
-    GRPC_CHANNEL_STACK_UNREF(chand_->owning_stack_, "SubchannelWrapper");
-  }
-
-  void Orphaned() override {
-    if (!IsWorkSerializerDispatchEnabled()) return;
-    // Make sure we clean up the channel's subchannel maps inside the
-    // WorkSerializer.
-    // Ref held by callback.
-    WeakRef(DEBUG_LOCATION, "subchannel map cleanup").release();
-    chand_->work_serializer_->Run(
-        [this]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
-          chand_->subchannel_wrappers_.erase(this);
-          if (chand_->channelz_node_ != nullptr) {
-            auto* subchannel_node = subchannel_->channelz_node();
-            if (subchannel_node != nullptr) {
-              auto it =
-                  chand_->subchannel_refcount_map_.find(subchannel_.get());
-              GPR_ASSERT(it != chand_->subchannel_refcount_map_.end());
-              --it->second;
-              if (it->second == 0) {
-                chand_->channelz_node_->RemoveChildSubchannel(
-                    subchannel_node->uuid());
-                chand_->subchannel_refcount_map_.erase(it);
-              }
-            }
-          }
-          WeakUnref(DEBUG_LOCATION, "subchannel map cleanup");
-        },
-        DEBUG_LOCATION);
+      WeakUnref(DEBUG_LOCATION, "subchannel map cleanup");
+    });
   }
 
   void WatchConnectivityState(
       std::unique_ptr<ConnectivityStateWatcherInterface> watcher) override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     auto& watcher_wrapper = watcher_map_[watcher.get()];
-    GPR_ASSERT(watcher_wrapper == nullptr);
+    CHECK_EQ(watcher_wrapper, nullptr);
     watcher_wrapper = new WatcherWrapper(
         std::move(watcher),
         RefAsSubclass<SubchannelWrapper>(DEBUG_LOCATION, "WatcherWrapper"));
@@ -729,7 +565,7 @@ class ClientChannelFilter::SubchannelWrapper final
   void CancelConnectivityStateWatch(ConnectivityStateWatcherInterface* watcher)
       override ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     auto it = watcher_map_.find(watcher);
-    GPR_ASSERT(it != watcher_map_.end());
+    CHECK(it != watcher_map_.end());
     subchannel_->CancelConnectivityStateWatch(it->second);
     watcher_map_.erase(it);
   }
@@ -746,7 +582,7 @@ class ClientChannelFilter::SubchannelWrapper final
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     static_cast<InternalSubchannelDataWatcherInterface*>(watcher.get())
         ->SetSubchannel(subchannel_.get());
-    GPR_ASSERT(data_watchers_.insert(std::move(watcher)).second);
+    CHECK(data_watchers_.insert(std::move(watcher)).second);
   }
 
   void CancelDataWatcher(DataWatcherInterface* watcher) override
@@ -759,6 +595,8 @@ class ClientChannelFilter::SubchannelWrapper final
     subchannel_->ThrottleKeepaliveTime(new_keepalive_time);
   }
 
+  std::string address() const override { return subchannel_->address(); }
+
  private:
   // This wrapper provides a bridge between the internal Subchannel API
   // and the SubchannelInterface API that we expose to LB policies.
@@ -771,7 +609,7 @@ class ClientChannelFilter::SubchannelWrapper final
   //
   // This class handles things like hopping into the WorkSerializer
   // before passing notifications to the LB policy and propagating
-  // keepalive information betwen subchannels.
+  // keepalive information between subchannels.
   class WatcherWrapper final
       : public Subchannel::ConnectivityStateWatcherInterface {
    public:
@@ -782,36 +620,24 @@ class ClientChannelFilter::SubchannelWrapper final
         : watcher_(std::move(watcher)), parent_(std::move(parent)) {}
 
     ~WatcherWrapper() override {
-      if (!IsWorkSerializerDispatchEnabled()) {
-        auto* parent = parent_.release();  // ref owned by lambda
-        parent->chand_->work_serializer_->Run(
-            [parent]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
-                *parent_->chand_->work_serializer_) {
-              parent->Unref(DEBUG_LOCATION, "WatcherWrapper");
-            },
-            DEBUG_LOCATION);
-        return;
-      }
       parent_.reset(DEBUG_LOCATION, "WatcherWrapper");
     }
 
     void OnConnectivityStateChange(
         RefCountedPtr<ConnectivityStateWatcherInterface> self,
         grpc_connectivity_state state, const absl::Status& status) override {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-        gpr_log(GPR_INFO,
-                "chand=%p: connectivity change for subchannel wrapper %p "
-                "subchannel %p; hopping into work_serializer",
-                parent_->chand_, parent_.get(), parent_->subchannel_.get());
-      }
+      GRPC_TRACE_LOG(client_channel, INFO)
+          << "chand=" << parent_->chand_
+          << ": connectivity change for subchannel wrapper " << parent_.get()
+          << " subchannel " << parent_->subchannel_.get()
+          << "hopping into work_serializer";
       self.release();  // Held by callback.
       parent_->chand_->work_serializer_->Run(
           [this, state, status]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
               *parent_->chand_->work_serializer_) {
             ApplyUpdateInControlPlaneWorkSerializer(state, status);
             Unref();
-          },
-          DEBUG_LOCATION);
+          });
     }
 
     grpc_pollset_set* interested_parties() override {
@@ -822,27 +648,24 @@ class ClientChannelFilter::SubchannelWrapper final
     void ApplyUpdateInControlPlaneWorkSerializer(grpc_connectivity_state state,
                                                  const absl::Status& status)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(*parent_->chand_->work_serializer_) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-        gpr_log(GPR_INFO,
-                "chand=%p: processing connectivity change in work serializer "
-                "for subchannel wrapper %p subchannel %p watcher=%p "
-                "state=%s status=%s",
-                parent_->chand_, parent_.get(), parent_->subchannel_.get(),
-                watcher_.get(), ConnectivityStateName(state),
-                status.ToString().c_str());
-      }
-      absl::optional<absl::Cord> keepalive_throttling =
-          status.GetPayload(kKeepaliveThrottlingKey);
+      GRPC_TRACE_LOG(client_channel, INFO)
+          << "chand=" << parent_->chand_
+          << ": processing connectivity change in work serializer for "
+             "subchannel wrapper "
+          << parent_.get() << " subchannel " << parent_->subchannel_.get()
+          << " watcher=" << watcher_.get()
+          << " state=" << ConnectivityStateName(state) << " status=" << status;
+      auto keepalive_throttling = status.GetPayload(kKeepaliveThrottlingKey);
       if (keepalive_throttling.has_value()) {
         int new_keepalive_time = -1;
         if (absl::SimpleAtoi(std::string(keepalive_throttling.value()),
                              &new_keepalive_time)) {
           if (new_keepalive_time > parent_->chand_->keepalive_time_) {
             parent_->chand_->keepalive_time_ = new_keepalive_time;
-            if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-              gpr_log(GPR_INFO, "chand=%p: throttling keepalive time to %d",
-                      parent_->chand_, parent_->chand_->keepalive_time_);
-            }
+            GRPC_TRACE_LOG(client_channel, INFO)
+                << "chand=" << parent_->chand_
+                << ": throttling keepalive time to "
+                << parent_->chand_->keepalive_time_;
             // Propagate the new keepalive time to all subchannels. This is so
             // that new transports created by any subchannel (and not just the
             // subchannel that received the GOAWAY), use the new keepalive time.
@@ -852,9 +675,9 @@ class ClientChannelFilter::SubchannelWrapper final
             }
           }
         } else {
-          gpr_log(GPR_ERROR, "chand=%p: Illegal keepalive throttling value %s",
-                  parent_->chand_,
-                  std::string(keepalive_throttling.value()).c_str());
+          LOG(ERROR) << "chand=" << parent_->chand_
+                     << ": Illegal keepalive throttling value "
+                     << std::string(keepalive_throttling.value());
         }
       }
       // Propagate status only in state TF.
@@ -922,7 +745,7 @@ ClientChannelFilter::ExternalConnectivityWatcher::ExternalConnectivityWatcher(
   {
     MutexLock lock(&chand_->external_watchers_mu_);
     // Will be deleted when the watch is complete.
-    GPR_ASSERT(chand->external_watchers_[on_complete] == nullptr);
+    CHECK(chand->external_watchers_[on_complete] == nullptr);
     // Store a ref to the watcher in the external_watchers_ map.
     chand->external_watchers_[on_complete] =
         RefAsSubclass<ExternalConnectivityWatcher>(
@@ -933,8 +756,7 @@ ClientChannelFilter::ExternalConnectivityWatcher::ExternalConnectivityWatcher(
       [this]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
         // The ref is passed to AddWatcherLocked().
         AddWatcherLocked();
-      },
-      DEBUG_LOCATION);
+      });
 }
 
 ClientChannelFilter::ExternalConnectivityWatcher::
@@ -987,8 +809,7 @@ void ClientChannelFilter::ExternalConnectivityWatcher::Notify(
         [this]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
           RemoveWatcherLocked();
           Unref(DEBUG_LOCATION, "RemoveWatcherLocked()");
-        },
-        DEBUG_LOCATION);
+        });
   }
 }
 
@@ -1007,8 +828,7 @@ void ClientChannelFilter::ExternalConnectivityWatcher::Cancel() {
       [this]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
         RemoveWatcherLocked();
         Unref(DEBUG_LOCATION, "RemoveWatcherLocked()");
-      },
-      DEBUG_LOCATION);
+      });
 }
 
 void ClientChannelFilter::ExternalConnectivityWatcher::AddWatcherLocked() {
@@ -1038,8 +858,7 @@ class ClientChannelFilter::ConnectivityWatcherAdder final {
     chand_->work_serializer_->Run(
         [this]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
           AddWatcherLocked();
-        },
-        DEBUG_LOCATION);
+        });
   }
 
  private:
@@ -1068,8 +887,7 @@ class ClientChannelFilter::ConnectivityWatcherRemover final {
     chand_->work_serializer_->Run(
         [this]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
           RemoveWatcherLocked();
-        },
-        DEBUG_LOCATION);
+        });
   }
 
  private:
@@ -1107,7 +925,7 @@ class ClientChannelFilter::ClientChannelControlHelper final
       const ChannelArgs& args) override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     if (chand_->resolver_ == nullptr) return nullptr;  // Shutting down.
-    ChannelArgs subchannel_args = ClientChannelFilter::MakeSubchannelArgs(
+    ChannelArgs subchannel_args = Subchannel::MakeSubchannelArgs(
         args, per_address_args, chand_->subchannel_pool_,
         chand_->default_authority_);
     // Create subchannel.
@@ -1125,14 +943,13 @@ class ClientChannelFilter::ClientChannelControlHelper final
                    RefCountedPtr<LoadBalancingPolicy::SubchannelPicker> picker)
       override ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     if (chand_->resolver_ == nullptr) return;  // Shutting down.
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-      const char* extra = chand_->disconnect_error_.ok()
-                              ? ""
-                              : " (ignoring -- channel shutting down)";
-      gpr_log(GPR_INFO, "chand=%p: update: state=%s status=(%s) picker=%p%s",
-              chand_, ConnectivityStateName(state), status.ToString().c_str(),
-              picker.get(), extra);
-    }
+    GRPC_TRACE_LOG(client_channel, INFO)
+        << "chand=" << chand_
+        << ": update: state=" << ConnectivityStateName(state) << " status=("
+        << status << ") picker=" << picker.get()
+        << (chand_->disconnect_error_.ok()
+                ? ""
+                : " (ignoring -- channel shutting down)");
     // Do update only if not shutting down.
     if (chand_->disconnect_error_.ok()) {
       chand_->UpdateStateAndPickerLocked(state, status, "helper",
@@ -1143,9 +960,8 @@ class ClientChannelFilter::ClientChannelControlHelper final
   void RequestReresolution() override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     if (chand_->resolver_ == nullptr) return;  // Shutting down.
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-      gpr_log(GPR_INFO, "chand=%p: started name re-resolving", chand_);
-    }
+    GRPC_TRACE_LOG(client_channel, INFO)
+        << "chand=" << chand_ << ": started name re-resolving";
     chand_->resolver_->RequestReresolutionLocked();
   }
 
@@ -1200,9 +1016,8 @@ class ClientChannelFilter::ClientChannelControlHelper final
 
 grpc_error_handle ClientChannelFilter::Init(grpc_channel_element* elem,
                                             grpc_channel_element_args* args) {
-  GPR_ASSERT(args->is_last);
-  GPR_ASSERT(elem->filter == &kFilterVtableWithPromises ||
-             elem->filter == &kFilterVtableWithoutPromises);
+  CHECK(args->is_last);
+  CHECK(elem->filter == &kFilter);
   grpc_error_handle error;
   new (elem->channel_data) ClientChannelFilter(args, &error);
   return error;
@@ -1228,9 +1043,6 @@ RefCountedPtr<SubchannelPoolInterface> GetSubchannelPool(
 ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
                                          grpc_error_handle* error)
     : channel_args_(args->channel_args),
-      deadline_checking_enabled_(
-          channel_args_.GetBool(GRPC_ARG_ENABLE_DEADLINE_CHECKS)
-              .value_or(!channel_args_.WantMinimalStack())),
       owning_stack_(args->channel_stack),
       client_channel_factory_(channel_args_.GetObject<ClientChannelFactory>()),
       channelz_node_(channel_args_.GetObject<channelz::ChannelNode>()),
@@ -1241,10 +1053,9 @@ ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
           std::make_shared<WorkSerializer>(*args->channel_stack->event_engine)),
       state_tracker_("client_channel", GRPC_CHANNEL_IDLE),
       subchannel_pool_(GetSubchannelPool(channel_args_)) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-    gpr_log(GPR_INFO, "chand=%p: creating client_channel for channel stack %p",
-            this, owning_stack_);
-  }
+  GRPC_TRACE_LOG(client_channel, INFO)
+      << "chand=" << this << ": creating client_channel for channel stack "
+      << owning_stack_;
   // Start backup polling.
   grpc_client_channel_start_backup_polling(interested_parties_);
   // Check client channel factory.
@@ -1255,7 +1066,7 @@ ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
   }
   // Get default service config.  If none is specified via the client API,
   // we use an empty config.
-  absl::optional<absl::string_view> service_config_json =
+  std::optional<absl::string_view> service_config_json =
       channel_args_.GetString(GRPC_ARG_SERVICE_CONFIG);
   if (!service_config_json.has_value()) service_config_json = "{}";
   *error = absl::OkStatus();
@@ -1267,7 +1078,7 @@ ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
   }
   default_service_config_ = std::move(*service_config);
   // Get URI to resolve, using proxy mapper if needed.
-  absl::optional<std::string> target_uri =
+  std::optional<std::string> target_uri =
       channel_args_.GetOwnedString(GRPC_ARG_SERVER_URI);
   if (!target_uri.has_value()) {
     *error = GRPC_ERROR_CREATE(
@@ -1299,7 +1110,7 @@ ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
     keepalive_time_ = -1;  // unset
   }
   // Set default authority.
-  absl::optional<std::string> default_authority =
+  std::optional<std::string> default_authority =
       channel_args_.GetOwnedString(GRPC_ARG_DEFAULT_AUTHORITY);
   if (!default_authority.has_value()) {
     default_authority_ =
@@ -1313,30 +1124,14 @@ ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
 }
 
 ClientChannelFilter::~ClientChannelFilter() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-    gpr_log(GPR_INFO, "chand=%p: destroying channel", this);
-  }
+  GRPC_TRACE_LOG(client_channel, INFO)
+      << "chand=" << this << ": destroying channel";
   DestroyResolverAndLbPolicyLocked();
   // Stop backup polling.
   grpc_client_channel_stop_backup_polling(interested_parties_);
   grpc_pollset_set_destroy(interested_parties_);
 }
 
-ArenaPromise<ServerMetadataHandle> ClientChannelFilter::MakeCallPromise(
-    grpc_channel_element* elem, CallArgs call_args, NextPromiseFactory) {
-  auto* chand = static_cast<ClientChannelFilter*>(elem->channel_data);
-  // TODO(roth): Is this the right lifetime story for calld?
-  auto* calld = GetContext<Arena>()->ManagedNew<PromiseBasedCallData>(chand);
-  return TrySeq(
-      // Name resolution.
-      calld->MakeNameResolutionPromise(std::move(call_args)),
-      // Dynamic filter stack.
-      [calld](CallArgs call_args) mutable {
-        return calld->dynamic_filters()->channel_stack()->MakeClientCallPromise(
-            std::move(call_args));
-      });
-}
-
 OrphanablePtr<ClientChannelFilter::FilterBasedLoadBalancedCall>
 ClientChannelFilter::CreateLoadBalancedCall(
     const grpc_call_element_args& args, grpc_polling_entity* pollent,
@@ -1349,42 +1144,6 @@ ClientChannelFilter::CreateLoadBalancedCall(
           std::move(on_commit), is_transparent_retry));
 }
 
-ArenaPromise<ServerMetadataHandle>
-ClientChannelFilter::CreateLoadBalancedCallPromise(
-    CallArgs call_args, absl::AnyInvocable<void()> on_commit,
-    bool is_transparent_retry) {
-  OrphanablePtr<PromiseBasedLoadBalancedCall> lb_call(
-      GetContext<Arena>()->New<PromiseBasedLoadBalancedCall>(
-          this, std::move(on_commit), is_transparent_retry));
-  auto* call_ptr = lb_call.get();
-  return call_ptr->MakeCallPromise(std::move(call_args), std::move(lb_call));
-}
-
-ChannelArgs ClientChannelFilter::MakeSubchannelArgs(
-    const ChannelArgs& channel_args, const ChannelArgs& address_args,
-    const RefCountedPtr<SubchannelPoolInterface>& subchannel_pool,
-    const std::string& channel_default_authority) {
-  // Note that we start with the channel-level args and then apply the
-  // per-address args, so that if a value is present in both, the one
-  // in the channel-level args is used.  This is particularly important
-  // for the GRPC_ARG_DEFAULT_AUTHORITY arg, which we want to allow
-  // resolvers to set on a per-address basis only if the application
-  // did not explicitly set it at the channel level.
-  return channel_args.UnionWith(address_args)
-      .SetObject(subchannel_pool)
-      // If we haven't already set the default authority arg (i.e., it
-      // was not explicitly set by the application nor overridden by
-      // the resolver), add it from the channel's default.
-      .SetIfUnset(GRPC_ARG_DEFAULT_AUTHORITY, channel_default_authority)
-      // Remove channel args that should not affect subchannel
-      // uniqueness.
-      .Remove(GRPC_ARG_HEALTH_CHECK_SERVICE_NAME)
-      .Remove(GRPC_ARG_INHIBIT_HEALTH_CHECKING)
-      .Remove(GRPC_ARG_CHANNELZ_CHANNEL_NODE)
-      // Remove all keys with the no-subchannel prefix.
-      .RemoveAllKeysWithPrefix(GRPC_ARG_NO_SUBCHANNEL_PREFIX);
-}
-
 void ClientChannelFilter::ReprocessQueuedResolverCalls() {
   for (CallData* calld : resolver_queued_calls_) {
     calld->RemoveCallFromResolverQueuedCallsLocked();
@@ -1404,7 +1163,7 @@ RefCountedPtr<LoadBalancingPolicy::Config> ChooseLbPolicy(
   }
   // Try the deprecated LB policy name from the service config.
   // If not, try the setting from channel args.
-  absl::optional<absl::string_view> policy_name;
+  std::optional<absl::string_view> policy_name;
   if (!parsed_service_config->parsed_deprecated_lb_policy().empty()) {
     policy_name = parsed_service_config->parsed_deprecated_lb_policy();
   } else {
@@ -1416,15 +1175,13 @@ RefCountedPtr<LoadBalancingPolicy::Config> ChooseLbPolicy(
               .LoadBalancingPolicyExists(*policy_name, &requires_config) ||
          requires_config)) {
       if (requires_config) {
-        gpr_log(GPR_ERROR,
-                "LB policy: %s passed through channel_args must not "
-                "require a config. Using pick_first instead.",
-                std::string(*policy_name).c_str());
+        LOG(ERROR) << "LB policy: " << *policy_name
+                   << " passed through channel_args must not "
+                      "require a config. Using pick_first instead.";
       } else {
-        gpr_log(GPR_ERROR,
-                "LB policy: %s passed through channel_args does not exist. "
-                "Using pick_first instead.",
-                std::string(*policy_name).c_str());
+        LOG(ERROR) << "LB policy: " << *policy_name
+                   << " passed through channel_args does not exist. "
+                      "Using pick_first instead.";
       }
       policy_name = "pick_first";
     }
@@ -1448,7 +1205,7 @@ RefCountedPtr<LoadBalancingPolicy::Config> ChooseLbPolicy(
   // - A channel arg, in which case we check that the specified policy exists
   //   and accepts an empty config. If not, we revert to using pick_first
   //   lb_policy
-  GPR_ASSERT(lb_policy_config.ok());
+  CHECK(lb_policy_config.ok());
   return std::move(*lb_policy_config);
 }
 
@@ -1458,9 +1215,8 @@ void ClientChannelFilter::OnResolverResultChangedLocked(
     Resolver::Result result) {
   // Handle race conditions.
   if (resolver_ == nullptr) return;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-    gpr_log(GPR_INFO, "chand=%p: got resolver result", this);
-  }
+  GRPC_TRACE_LOG(client_channel, INFO)
+      << "chand=" << this << ": got resolver result";
   // Grab resolver result health callback.
   auto resolver_callback = std::move(result.result_health_callback);
   absl::Status resolver_result_status;
@@ -1494,19 +1250,16 @@ void ClientChannelFilter::OnResolverResultChangedLocked(
   RefCountedPtr<ServiceConfig> service_config;
   RefCountedPtr<ConfigSelector> config_selector;
   if (!result.service_config.ok()) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-      gpr_log(GPR_INFO, "chand=%p: resolver returned service config error: %s",
-              this, result.service_config.status().ToString().c_str());
-    }
+    GRPC_TRACE_LOG(client_channel, INFO)
+        << "chand=" << this << ": resolver returned service config error: "
+        << result.service_config.status();
     // If the service config was invalid, then fallback to the
     // previously returned service config.
     if (saved_service_config_ != nullptr) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-        gpr_log(GPR_INFO,
-                "chand=%p: resolver returned invalid service config. "
-                "Continuing to use previous service config.",
-                this);
-      }
+      GRPC_TRACE_LOG(client_channel, INFO)
+          << "chand=" << this
+          << ": resolver returned invalid service config. "
+             "Continuing to use previous service config.";
       service_config = saved_service_config_;
       config_selector = saved_config_selector_;
     } else {
@@ -1520,18 +1273,20 @@ void ClientChannelFilter::OnResolverResultChangedLocked(
     }
   } else if (*result.service_config == nullptr) {
     // Resolver did not return any service config.
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-      gpr_log(GPR_INFO,
-              "chand=%p: resolver returned no service config. Using default "
-              "service config for channel.",
-              this);
-    }
+    GRPC_TRACE_LOG(client_channel, INFO)
+        << "chand=" << this
+        << ": resolver returned no service config. Using default service "
+           "config for channel.";
     service_config = default_service_config_;
   } else {
     // Use ServiceConfig and ConfigSelector returned by resolver.
     service_config = std::move(*result.service_config);
     config_selector = result.args.GetObjectRef<ConfigSelector>();
   }
+  // Remove the config selector from channel args so that we're not holding
+  // unnecessary refs that cause it to be destroyed somewhere other than in the
+  // WorkSerializer.
+  result.args = result.args.Remove(GRPC_ARG_CONFIG_SELECTOR);
   // Note: The only case in which service_config is null here is if the resolver
   // returned a service config error and we don't have a previous service
   // config to fall back to.
@@ -1557,10 +1312,12 @@ void ClientChannelFilter::OnResolverResultChangedLocked(
       UpdateServiceConfigInControlPlaneLocked(
           std::move(service_config), std::move(config_selector),
           std::string(lb_policy_config->name()));
-    } else if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-      gpr_log(GPR_INFO, "chand=%p: service config not changed", this);
+    } else {
+      GRPC_TRACE_LOG(client_channel, INFO)
+          << "chand=" << this << ": service config not changed";
     }
     // Create or update LB policy, as needed.
+    ChannelArgs new_args = result.args;
     resolver_result_status = CreateOrUpdateLbPolicyLocked(
         std::move(lb_policy_config),
         parsed_service_config->health_check_service_name(), std::move(result));
@@ -1569,7 +1326,7 @@ void ClientChannelFilter::OnResolverResultChangedLocked(
       // This needs to happen after the LB policy has been updated, since
       // the ConfigSelector may need the LB policy to know about new
       // destinations before it can send RPCs to those destinations.
-      UpdateServiceConfigInDataPlaneLocked();
+      UpdateServiceConfigInDataPlaneLocked(new_args);
       // TODO(ncteisen): might be worth somehow including a snippet of the
       // config in the trace, at the risk of bloating the trace logs.
       trace_strings.push_back("Service config changed");
@@ -1592,10 +1349,8 @@ void ClientChannelFilter::OnResolverResultChangedLocked(
 
 void ClientChannelFilter::OnResolverErrorLocked(absl::Status status) {
   if (resolver_ == nullptr) return;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-    gpr_log(GPR_INFO, "chand=%p: resolver transient failure: %s", this,
-            status.ToString().c_str());
-  }
+  GRPC_TRACE_LOG(client_channel, INFO)
+      << "chand=" << this << ": resolver transient failure: " << status;
   // If we already have an LB policy from a previous resolution
   // result, then we continue to let it set the connectivity state.
   // Otherwise, we go into TRANSIENT_FAILURE.
@@ -1615,7 +1370,7 @@ void ClientChannelFilter::OnResolverErrorLocked(absl::Status status) {
 
 absl::Status ClientChannelFilter::CreateOrUpdateLbPolicyLocked(
     RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config,
-    const absl::optional<std::string>& health_check_service_name,
+    const std::optional<std::string>& health_check_service_name,
     Resolver::Result result) {
   // Construct update.
   LoadBalancingPolicy::UpdateArgs update_args;
@@ -1627,10 +1382,7 @@ absl::Status ClientChannelFilter::CreateOrUpdateLbPolicyLocked(
   }
   update_args.config = std::move(lb_policy_config);
   update_args.resolution_note = std::move(result.resolution_note);
-  // Remove the config selector from channel args so that we're not holding
-  // unnecessary refs that cause it to be destroyed somewhere other than in the
-  // WorkSerializer.
-  update_args.args = result.args.Remove(GRPC_ARG_CONFIG_SELECTOR);
+  update_args.args = std::move(result.args);
   // Add health check service name to channel args.
   if (health_check_service_name.has_value()) {
     update_args.args = update_args.args.Set(GRPC_ARG_HEALTH_CHECK_SERVICE_NAME,
@@ -1641,10 +1393,8 @@ absl::Status ClientChannelFilter::CreateOrUpdateLbPolicyLocked(
     lb_policy_ = CreateLbPolicyLocked(update_args.args);
   }
   // Update the policy.
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-    gpr_log(GPR_INFO, "chand=%p: Updating child policy %p", this,
-            lb_policy_.get());
-  }
+  GRPC_TRACE_LOG(client_channel, INFO)
+      << "chand=" << this << ": Updating child policy " << lb_policy_.get();
   return lb_policy_->UpdateLocked(std::move(update_args));
 }
 
@@ -1666,11 +1416,9 @@ OrphanablePtr<LoadBalancingPolicy> ClientChannelFilter::CreateLbPolicyLocked(
   lb_policy_args.args = args;
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       MakeOrphanable<ChildPolicyHandler>(std::move(lb_policy_args),
-                                         &grpc_client_channel_trace);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-    gpr_log(GPR_INFO, "chand=%p: created new LB policy %p", this,
-            lb_policy.get());
-  }
+                                         &client_channel_trace);
+  GRPC_TRACE_LOG(client_channel, INFO)
+      << "chand=" << this << ": created new LB policy " << lb_policy.get();
   grpc_pollset_set_add_pollset_set(lb_policy->interested_parties(),
                                    interested_parties_);
   return lb_policy;
@@ -1680,10 +1428,9 @@ void ClientChannelFilter::UpdateServiceConfigInControlPlaneLocked(
     RefCountedPtr<ServiceConfig> service_config,
     RefCountedPtr<ConfigSelector> config_selector, std::string lb_policy_name) {
   std::string service_config_json(service_config->json_string());
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-    gpr_log(GPR_INFO, "chand=%p: using service config: \"%s\"", this,
-            service_config_json.c_str());
-  }
+  GRPC_TRACE_LOG(client_channel, INFO)
+      << "chand=" << this << ": using service config: \"" << service_config_json
+      << "\"";
   // Save service config.
   saved_service_config_ = std::move(service_config);
   // Swap out the data used by GetChannelInfo().
@@ -1694,27 +1441,26 @@ void ClientChannelFilter::UpdateServiceConfigInControlPlaneLocked(
   }
   // Save config selector.
   saved_config_selector_ = std::move(config_selector);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-    gpr_log(GPR_INFO, "chand=%p: using ConfigSelector %p", this,
-            saved_config_selector_.get());
-  }
+  GRPC_TRACE_LOG(client_channel, INFO)
+      << "chand=" << this << ": using ConfigSelector "
+      << saved_config_selector_.get();
 }
 
-void ClientChannelFilter::UpdateServiceConfigInDataPlaneLocked() {
+void ClientChannelFilter::UpdateServiceConfigInDataPlaneLocked(
+    const ChannelArgs& args) {
   // Grab ref to service config.
   RefCountedPtr<ServiceConfig> service_config = saved_service_config_;
   // Grab ref to config selector.  Use default if resolver didn't supply one.
   RefCountedPtr<ConfigSelector> config_selector = saved_config_selector_;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-    gpr_log(GPR_INFO, "chand=%p: switching to ConfigSelector %p", this,
-            saved_config_selector_.get());
-  }
+  GRPC_TRACE_LOG(client_channel, INFO)
+      << "chand=" << this << ": switching to ConfigSelector "
+      << saved_config_selector_.get();
   if (config_selector == nullptr) {
     config_selector =
         MakeRefCounted<DefaultConfigSelector>(saved_service_config_);
   }
-  ChannelArgs new_args =
-      channel_args_.SetObject(this).SetObject(service_config);
+  // Modify channel args.
+  ChannelArgs new_args = args.SetObject(this).SetObject(service_config);
   bool enable_retries =
       !new_args.WantMinimalStack() &&
       new_args.GetBool(GRPC_ARG_ENABLE_RETRIES).value_or(true);
@@ -1726,9 +1472,11 @@ void ClientChannelFilter::UpdateServiceConfigInDataPlaneLocked() {
   } else {
     filters.push_back(&DynamicTerminationFilter::kFilterVtable);
   }
-  RefCountedPtr<DynamicFilters> dynamic_filters =
-      DynamicFilters::Create(new_args, std::move(filters));
-  GPR_ASSERT(dynamic_filters != nullptr);
+  auto new_blackboard = MakeRefCounted<Blackboard>();
+  RefCountedPtr<DynamicFilters> dynamic_filters = DynamicFilters::Create(
+      new_args, std::move(filters), blackboard_.get(), new_blackboard.get());
+  CHECK(dynamic_filters != nullptr);
+  blackboard_ = std::move(new_blackboard);
   // Grab data plane lock to update service config.
   //
   // We defer unreffing the old values (and deallocating memory) until
@@ -1750,30 +1498,26 @@ void ClientChannelFilter::UpdateServiceConfigInDataPlaneLocked() {
 }
 
 void ClientChannelFilter::CreateResolverLocked() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-    gpr_log(GPR_INFO, "chand=%p: starting name resolution for %s", this,
-            uri_to_resolve_.c_str());
-  }
+  GRPC_TRACE_LOG(client_channel, INFO)
+      << "chand=" << this << ": starting name resolution for "
+      << uri_to_resolve_;
   resolver_ = CoreConfiguration::Get().resolver_registry().CreateResolver(
       uri_to_resolve_, channel_args_, interested_parties_, work_serializer_,
       std::make_unique<ResolverResultHandler>(this));
   // Since the validity of the args was checked when the channel was created,
   // CreateResolver() must return a non-null result.
-  GPR_ASSERT(resolver_ != nullptr);
+  CHECK(resolver_ != nullptr);
   UpdateStateLocked(GRPC_CHANNEL_CONNECTING, absl::Status(),
                     "started resolving");
   resolver_->StartLocked();
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-    gpr_log(GPR_INFO, "chand=%p: created resolver=%p", this, resolver_.get());
-  }
+  GRPC_TRACE_LOG(client_channel, INFO)
+      << "chand=" << this << ": created resolver=" << resolver_.get();
 }
 
 void ClientChannelFilter::DestroyResolverAndLbPolicyLocked() {
   if (resolver_ != nullptr) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-      gpr_log(GPR_INFO, "chand=%p: shutting down resolver=%p", this,
-              resolver_.get());
-    }
+    GRPC_TRACE_LOG(client_channel, INFO)
+        << "chand=" << this << ": shutting down resolver=" << resolver_.get();
     resolver_.reset();
     // Clear resolution state.
     saved_service_config_.reset();
@@ -1793,10 +1537,9 @@ void ClientChannelFilter::DestroyResolverAndLbPolicyLocked() {
     }
     // Clear LB policy if set.
     if (lb_policy_ != nullptr) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-        gpr_log(GPR_INFO, "chand=%p: shutting down lb_policy=%p", this,
-                lb_policy_.get());
-      }
+      GRPC_TRACE_LOG(client_channel, INFO)
+          << "chand=" << this
+          << ": shutting down lb_policy=" << lb_policy_.get();
       grpc_pollset_set_del_pollset_set(lb_policy_->interested_parties(),
                                        interested_parties_);
       lb_policy_.reset();
@@ -1842,7 +1585,7 @@ void ClientChannelFilter::UpdateStateAndPickerLocked(
 
 namespace {
 
-// TODO(roth): Remove this in favor of the gprpp Match() function once
+// TODO(roth): Remove this in favor of src/core/util/match.h once
 // we can do that without breaking lock annotations.
 template <typename T>
 T HandlePickResult(
@@ -1852,23 +1595,23 @@ T HandlePickResult(
     std::function<T(LoadBalancingPolicy::PickResult::Fail*)> fail_func,
     std::function<T(LoadBalancingPolicy::PickResult::Drop*)> drop_func) {
   auto* complete_pick =
-      absl::get_if<LoadBalancingPolicy::PickResult::Complete>(&result->result);
+      std::get_if<LoadBalancingPolicy::PickResult::Complete>(&result->result);
   if (complete_pick != nullptr) {
     return complete_func(complete_pick);
   }
   auto* queue_pick =
-      absl::get_if<LoadBalancingPolicy::PickResult::Queue>(&result->result);
+      std::get_if<LoadBalancingPolicy::PickResult::Queue>(&result->result);
   if (queue_pick != nullptr) {
     return queue_func(queue_pick);
   }
   auto* fail_pick =
-      absl::get_if<LoadBalancingPolicy::PickResult::Fail>(&result->result);
+      std::get_if<LoadBalancingPolicy::PickResult::Fail>(&result->result);
   if (fail_pick != nullptr) {
     return fail_func(fail_pick);
   }
   auto* drop_pick =
-      absl::get_if<LoadBalancingPolicy::PickResult::Drop>(&result->result);
-  GPR_ASSERT(drop_pick != nullptr);
+      std::get_if<LoadBalancingPolicy::PickResult::Drop>(&result->result);
+  CHECK_NE(drop_pick, nullptr);
   return drop_func(drop_pick);
 }
 
@@ -1942,10 +1685,9 @@ void ClientChannelFilter::StartTransportOpLocked(grpc_transport_op* op) {
   }
   // Disconnect or enter IDLE.
   if (!op->disconnect_with_error.ok()) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-      gpr_log(GPR_INFO, "chand=%p: disconnect_with_error: %s", this,
-              StatusToString(op->disconnect_with_error).c_str());
-    }
+    GRPC_TRACE_LOG(client_channel, INFO)
+        << "chand=" << this << ": disconnect_with_error: "
+        << StatusToString(op->disconnect_with_error);
     DestroyResolverAndLbPolicyLocked();
     intptr_t value;
     if (grpc_error_get_int(op->disconnect_with_error,
@@ -1962,7 +1704,7 @@ void ClientChannelFilter::StartTransportOpLocked(grpc_transport_op* op) {
       }
     } else {
       // Disconnect.
-      GPR_ASSERT(disconnect_error_.ok());
+      CHECK(disconnect_error_.ok());
       disconnect_error_ = op->disconnect_with_error;
       UpdateStateAndPickerLocked(
           GRPC_CHANNEL_SHUTDOWN, absl::Status(), "shutdown from API",
@@ -1980,7 +1722,7 @@ void ClientChannelFilter::StartTransportOpLocked(grpc_transport_op* op) {
 void ClientChannelFilter::StartTransportOp(grpc_channel_element* elem,
                                            grpc_transport_op* op) {
   auto* chand = static_cast<ClientChannelFilter*>(elem->channel_data);
-  GPR_ASSERT(op->set_accept_stream == false);
+  CHECK(op->set_accept_stream == false);
   // Handle bind_pollset.
   if (op->bind_pollset != nullptr) {
     grpc_pollset_set_add_pollset(chand->interested_parties_, op->bind_pollset);
@@ -1990,8 +1732,7 @@ void ClientChannelFilter::StartTransportOp(grpc_channel_element* elem,
   chand->work_serializer_->Run(
       [chand, op]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand->work_serializer_) {
         chand->StartTransportOpLocked(op);
-      },
-      DEBUG_LOCATION);
+      });
 }
 
 void ClientChannelFilter::GetChannelInfo(grpc_channel_element* elem,
@@ -2028,8 +1769,7 @@ grpc_connectivity_state ClientChannelFilter::CheckConnectivityState(
   if (out == GRPC_CHANNEL_IDLE && try_to_connect) {
     GRPC_CHANNEL_STACK_REF(owning_stack_, "TryToConnect");
     work_serializer_->Run([this]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
-                              *work_serializer_) { TryToConnectLocked(); },
-                          DEBUG_LOCATION);
+                              *work_serializer_) { TryToConnectLocked(); });
   }
   return out;
 }
@@ -2050,11 +1790,9 @@ void ClientChannelFilter::RemoveConnectivityWatcher(
 //
 
 void ClientChannelFilter::CallData::RemoveCallFromResolverQueuedCallsLocked() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-    gpr_log(GPR_INFO,
-            "chand=%p calld=%p: removing from resolver queued picks list",
-            chand(), this);
-  }
+  GRPC_TRACE_LOG(client_channel_call, INFO)
+      << "chand=" << chand() << " calld=" << this
+      << ": removing from resolver queued picks list";
   // Remove call's pollent from channel's interested_parties.
   grpc_polling_entity_del_from_pollset_set(pollent(),
                                            chand()->interested_parties_);
@@ -2065,12 +1803,10 @@ void ClientChannelFilter::CallData::RemoveCallFromResolverQueuedCallsLocked() {
 }
 
 void ClientChannelFilter::CallData::AddCallToResolverQueuedCallsLocked() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-    gpr_log(
-        GPR_INFO,
-        "chand=%p calld=%p: adding to resolver queued picks list; pollent=%s",
-        chand(), this, grpc_polling_entity_string(pollent()).c_str());
-  }
+  GRPC_TRACE_LOG(client_channel_call, INFO)
+      << "chand=" << chand() << " calld=" << this
+      << ": adding to resolver queued picks list; pollent="
+      << grpc_polling_entity_string(pollent());
   // Add call's pollent to channel's interested_parties, so that I/O
   // can be done under the call's CQ.
   grpc_polling_entity_add_to_pollset_set(pollent(),
@@ -2082,10 +1818,9 @@ void ClientChannelFilter::CallData::AddCallToResolverQueuedCallsLocked() {
 
 grpc_error_handle ClientChannelFilter::CallData::ApplyServiceConfigToCallLocked(
     const absl::StatusOr<RefCountedPtr<ConfigSelector>>& config_selector) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-    gpr_log(GPR_INFO, "chand=%p calld=%p: applying service config to call",
-            chand(), this);
-  }
+  GRPC_TRACE_LOG(client_channel_call, INFO)
+      << "chand=" << chand() << " calld=" << this
+      << ": applying service config to call";
   if (!config_selector.ok()) return config_selector.status();
   // Create a ClientChannelServiceConfigCallData for the call.  This stores
   // a ref to the ServiceConfig and caches the right set of parsed configs
@@ -2093,7 +1828,7 @@ grpc_error_handle ClientChannelFilter::CallData::ApplyServiceConfigToCallLocked(
   // itself in the call context, so that it can be accessed by filters
   // below us in the stack, and it will be cleaned up when the call ends.
   auto* service_config_call_data =
-      arena()->New<ClientChannelServiceConfigCallData>(arena(), call_context());
+      arena()->New<ClientChannelServiceConfigCallData>(arena());
   // Use the ConfigSelector to determine the config for the call.
   absl::Status call_config_status =
       (*config_selector)
@@ -2110,8 +1845,7 @@ grpc_error_handle ClientChannelFilter::CallData::ApplyServiceConfigToCallLocked(
   if (method_params != nullptr) {
     // If the deadline from the service config is shorter than the one
     // from the client API, reset the deadline timer.
-    if (chand()->deadline_checking_enabled_ &&
-        method_params->timeout() != Duration::Zero()) {
+    if (method_params->timeout() != Duration::Zero()) {
       ResetDeadline(method_params->timeout());
     }
     // If the service config set wait_for_ready and the application
@@ -2126,7 +1860,7 @@ grpc_error_handle ClientChannelFilter::CallData::ApplyServiceConfigToCallLocked(
   return absl::OkStatus();
 }
 
-absl::optional<absl::Status> ClientChannelFilter::CallData::CheckResolution(
+std::optional<absl::Status> ClientChannelFilter::CallData::CheckResolution(
     bool was_queued) {
   // Check if we have a resolver result to use.
   absl::StatusOr<RefCountedPtr<ConfigSelector>> config_selector;
@@ -2136,32 +1870,21 @@ absl::optional<absl::Status> ClientChannelFilter::CallData::CheckResolution(
     // If no result is available, queue the call.
     if (!result_ready) {
       AddCallToResolverQueuedCallsLocked();
-      return absl::nullopt;
+      return std::nullopt;
     }
   }
   // We have a result.  Apply service config to call.
   grpc_error_handle error = ApplyServiceConfigToCallLocked(config_selector);
-  // ConfigSelector must be unreffed inside the WorkSerializer.
-  if (!IsWorkSerializerDispatchEnabled() && config_selector.ok()) {
-    chand()->work_serializer_->Run(
-        [config_selector = std::move(*config_selector)]() mutable {
-          config_selector.reset();
-        },
-        DEBUG_LOCATION);
-  }
   // Handle errors.
   if (!error.ok()) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-      gpr_log(GPR_INFO,
-              "chand=%p calld=%p: error applying config to call: error=%s",
-              chand(), this, StatusToString(error).c_str());
-    }
+    GRPC_TRACE_LOG(client_channel_call, INFO)
+        << "chand=" << chand() << " calld=" << this
+        << ": error applying config to call: error=" << StatusToString(error);
     return error;
   }
   // If the call was queued, add trace annotation.
   if (was_queued) {
-    auto* call_tracer = static_cast<CallTracerAnnotationInterface*>(
-        call_context()[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value);
+    auto* call_tracer = arena()->GetContext<CallTracerAnnotationInterface>();
     if (call_tracer != nullptr) {
       call_tracer->RecordAnnotation("Delayed name resolution complete.");
     }
@@ -2179,20 +1902,18 @@ bool ClientChannelFilter::CallData::CheckResolutionLocked(
     absl::Status resolver_error = chand()->resolver_transient_failure_error_;
     if (!resolver_error.ok() &&
         !send_initial_metadata()->GetOrCreatePointer(WaitForReady())->value) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-        gpr_log(GPR_INFO, "chand=%p calld=%p: resolution failed, failing call",
-                chand(), this);
-      }
+      GRPC_TRACE_LOG(client_channel_call, INFO)
+          << "chand=" << chand() << " calld=" << this
+          << ": resolution failed, failing call";
       *config_selector = absl_status_to_grpc_error(resolver_error);
       return true;
     }
     // Either the resolver has not yet returned a result, or it has
     // returned transient failure but the call is wait_for_ready.  In
     // either case, queue the call.
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-      gpr_log(GPR_INFO, "chand=%p calld=%p: no resolver result yet", chand(),
-              this);
-    }
+    GRPC_TRACE_LOG(client_channel_call, INFO)
+        << "chand=" << chand() << " calld=" << this
+        << ": no resolver result yet";
     return false;
   }
   // Result found.
@@ -2208,25 +1929,21 @@ bool ClientChannelFilter::CallData::CheckResolutionLocked(
 ClientChannelFilter::FilterBasedCallData::FilterBasedCallData(
     grpc_call_element* elem, const grpc_call_element_args& args)
     : path_(CSliceRef(args.path)),
-      call_context_(args.context),
       call_start_time_(args.start_time),
       deadline_(args.deadline),
-      deadline_state_(
-          elem, args,
-          GPR_LIKELY(static_cast<ClientChannelFilter*>(elem->channel_data)
-                         ->deadline_checking_enabled_)
-              ? args.deadline
-              : Timestamp::InfFuture()) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-    gpr_log(GPR_INFO, "chand=%p calld=%p: created call", chand(), this);
-  }
+      arena_(args.arena),
+      elem_(elem),
+      owning_call_(args.call_stack),
+      call_combiner_(args.call_combiner) {
+  GRPC_TRACE_LOG(client_channel_call, INFO)
+      << "chand=" << chand() << " calld=" << this << ": created call";
 }
 
 ClientChannelFilter::FilterBasedCallData::~FilterBasedCallData() {
   CSliceUnref(path_);
   // Make sure there are no remaining pending batches.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    GPR_ASSERT(pending_batches_[i] == nullptr);
+    CHECK_EQ(pending_batches_[i], nullptr);
   }
 }
 
@@ -2255,14 +1972,11 @@ void ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
   auto* calld = static_cast<FilterBasedCallData*>(elem->call_data);
   auto* chand = static_cast<ClientChannelFilter*>(elem->channel_data);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace) &&
-      !GRPC_TRACE_FLAG_ENABLED(grpc_trace_channel)) {
-    gpr_log(GPR_INFO, "chand=%p calld=%p: batch started from above: %s", chand,
-            calld, grpc_transport_stream_op_batch_string(batch, false).c_str());
-  }
-  if (GPR_LIKELY(chand->deadline_checking_enabled_)) {
-    grpc_deadline_state_client_start_transport_stream_op_batch(
-        &calld->deadline_state_, batch);
+  if (GRPC_TRACE_FLAG_ENABLED(client_channel_call) &&
+      !GRPC_TRACE_FLAG_ENABLED(channel)) {
+    LOG(INFO) << "chand=" << chand << " calld=" << calld
+              << ": batch started from above: "
+              << grpc_transport_stream_op_batch_string(batch, false);
   }
   // Intercept recv_trailing_metadata to commit the call, in case we wind up
   // failing the call before we get down to the retry or LB call layer.
@@ -2279,10 +1993,9 @@ void ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch(
   // Note that once we have done so, we do not need to acquire the channel's
   // resolution mutex, which is more efficient (especially for streaming calls).
   if (calld->dynamic_call_ != nullptr) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-      gpr_log(GPR_INFO, "chand=%p calld=%p: starting batch on dynamic_call=%p",
-              chand, calld, calld->dynamic_call_.get());
-    }
+    GRPC_TRACE_LOG(client_channel_call, INFO)
+        << "chand=" << chand << " calld=" << calld
+        << ": starting batch on dynamic_call=" << calld->dynamic_call_.get();
     calld->dynamic_call_->StartTransportStreamOpBatch(batch);
     return;
   }
@@ -2290,10 +2003,10 @@ void ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch(
   //
   // If we've previously been cancelled, immediately fail any new batches.
   if (GPR_UNLIKELY(!calld->cancel_error_.ok())) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-      gpr_log(GPR_INFO, "chand=%p calld=%p: failing batch with error: %s",
-              chand, calld, StatusToString(calld->cancel_error_).c_str());
-    }
+    GRPC_TRACE_LOG(client_channel_call, INFO)
+        << "chand=" << chand << " calld=" << calld
+        << ": failing batch with error: "
+        << StatusToString(calld->cancel_error_);
     // Note: This will release the call combiner.
     grpc_transport_stream_op_batch_finish_with_failure(
         batch, calld->cancel_error_, calld->call_combiner());
@@ -2307,10 +2020,9 @@ void ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch(
     // is in the past when the call starts), we can return the right
     // error to the caller when the first batch does get passed down.
     calld->cancel_error_ = batch->payload->cancel_stream.cancel_error;
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-      gpr_log(GPR_INFO, "chand=%p calld=%p: recording cancel_error=%s", chand,
-              calld, StatusToString(calld->cancel_error_).c_str());
-    }
+    GRPC_TRACE_LOG(client_channel_call, INFO)
+        << "chand=" << chand << " calld=" << calld
+        << ": recording cancel_error=" << StatusToString(calld->cancel_error_);
     // Fail all pending batches.
     calld->PendingBatchesFail(calld->cancel_error_, NoYieldCallCombiner);
     // Note: This will release the call combiner.
@@ -2324,36 +2036,29 @@ void ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch(
   // channel's resolution mutex to apply the service config to the call,
   // after which we will create a dynamic call.
   if (GPR_LIKELY(batch->send_initial_metadata)) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-      gpr_log(GPR_INFO,
-              "chand=%p calld=%p: grabbing resolution mutex to apply service "
-              "config",
-              chand, calld);
-    }
+    GRPC_TRACE_LOG(client_channel_call, INFO)
+        << "chand=" << chand << " calld=" << calld
+        << ": grabbing resolution mutex to apply service ";
     // If we're still in IDLE, we need to start resolving.
     if (GPR_UNLIKELY(chand->CheckConnectivityState(false) ==
                      GRPC_CHANNEL_IDLE)) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-        gpr_log(GPR_INFO, "chand=%p calld=%p: triggering exit idle", chand,
-                calld);
-      }
+      GRPC_TRACE_LOG(client_channel_call, INFO)
+          << "chand=" << chand << " calld=" << calld
+          << ": triggering exit idle";
       // Bounce into the control plane work serializer to start resolving.
       GRPC_CHANNEL_STACK_REF(chand->owning_stack_, "ExitIdle");
       chand->work_serializer_->Run(
           [chand]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand->work_serializer_) {
             chand->CheckConnectivityState(/*try_to_connect=*/true);
             GRPC_CHANNEL_STACK_UNREF(chand->owning_stack_, "ExitIdle");
-          },
-          DEBUG_LOCATION);
+          });
     }
     calld->TryCheckResolution(/*was_queued=*/false);
   } else {
     // For all other batches, release the call combiner.
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-      gpr_log(GPR_INFO,
-              "chand=%p calld=%p: saved batch, yielding call combiner", chand,
-              calld);
-    }
+    GRPC_TRACE_LOG(client_channel_call, INFO)
+        << "chand=" << chand << " calld=" << calld
+        << ": saved batch, yielding call combiner";
     GRPC_CALL_COMBINER_STOP(calld->call_combiner(),
                             "batch does not include send_initial_metadata");
   }
@@ -2382,13 +2087,11 @@ size_t ClientChannelFilter::FilterBasedCallData::GetBatchIndex(
 void ClientChannelFilter::FilterBasedCallData::PendingBatchesAdd(
     grpc_transport_stream_op_batch* batch) {
   const size_t idx = GetBatchIndex(batch);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-    gpr_log(GPR_INFO,
-            "chand=%p calld=%p: adding pending batch at index %" PRIuPTR,
-            chand(), this, idx);
-  }
+  GRPC_TRACE_LOG(client_channel_call, INFO)
+      << "chand=" << chand() << " calld=" << this
+      << ": adding pending batch at index " << idx;
   grpc_transport_stream_op_batch*& pending = pending_batches_[idx];
-  GPR_ASSERT(pending == nullptr);
+  CHECK_EQ(pending, nullptr);
   pending = batch;
 }
 
@@ -2408,15 +2111,14 @@ void ClientChannelFilter::FilterBasedCallData::FailPendingBatchInCallCombiner(
 void ClientChannelFilter::FilterBasedCallData::PendingBatchesFail(
     grpc_error_handle error,
     YieldCallCombinerPredicate yield_call_combiner_predicate) {
-  GPR_ASSERT(!error.ok());
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
+  CHECK(!error.ok());
+  if (GRPC_TRACE_FLAG_ENABLED(client_channel_call)) {
     size_t num_batches = 0;
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
       if (pending_batches_[i] != nullptr) ++num_batches;
     }
-    gpr_log(GPR_INFO,
-            "chand=%p calld=%p: failing %" PRIuPTR " pending batches: %s",
-            chand(), this, num_batches, StatusToString(error).c_str());
+    LOG(INFO) << "chand=" << chand() << " calld=" << this << ": failing "
+              << num_batches << " pending batches: " << StatusToString(error);
   }
   CallCombinerClosureList closures;
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -2452,15 +2154,14 @@ void ClientChannelFilter::FilterBasedCallData::ResumePendingBatchInCallCombiner(
 // This is called via the call combiner, so access to calld is synchronized.
 void ClientChannelFilter::FilterBasedCallData::PendingBatchesResume() {
   // Retries not enabled; send down batches as-is.
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(client_channel_call)) {
     size_t num_batches = 0;
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
       if (pending_batches_[i] != nullptr) ++num_batches;
     }
-    gpr_log(GPR_INFO,
-            "chand=%p calld=%p: starting %" PRIuPTR
-            " pending batches on dynamic_call=%p",
-            chand(), this, num_batches, dynamic_call_.get());
+    LOG(INFO) << "chand=" << chand() << " calld=" << this << ": starting "
+              << num_batches
+              << " pending batches on dynamic_call=" << dynamic_call_.get();
   }
   CallCombinerClosureList closures;
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -2498,13 +2199,13 @@ class ClientChannelFilter::FilterBasedCallData::ResolverQueuedCallCanceller
     auto* chand = calld->chand();
     {
       MutexLock lock(&chand->resolution_mu_);
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-        gpr_log(GPR_INFO,
-                "chand=%p calld=%p: cancelling resolver queued pick: "
-                "error=%s self=%p calld->resolver_pick_canceller=%p",
-                chand, calld, StatusToString(error).c_str(), self,
-                calld->resolver_call_canceller_);
-      }
+      GRPC_TRACE_LOG(client_channel_call, INFO)
+          << "chand=" << chand << " calld=" << calld
+          << ": cancelling resolver queued pick: "
+             "error="
+          << StatusToString(error) << " self=" << self
+          << " calld->resolver_pick_canceller="
+          << calld->resolver_call_canceller_;
       if (calld->resolver_call_canceller_ == self && !error.ok()) {
         // Remove pick from list of queued picks.
         calld->RemoveCallFromResolverQueuedCallsLocked();
@@ -2545,31 +2246,25 @@ void ClientChannelFilter::FilterBasedCallData::RetryCheckResolutionLocked() {
   // Do an async callback to resume call processing, so that we're not
   // doing it while holding the channel's resolution mutex.
   chand()->owning_stack_->EventEngine()->Run([this]() {
-    ApplicationCallbackExecCtx application_exec_ctx;
     ExecCtx exec_ctx;
     TryCheckResolution(/*was_queued=*/true);
   });
 }
 
 void ClientChannelFilter::FilterBasedCallData::CreateDynamicCall() {
-  DynamicFilters::Call::Args args = {dynamic_filters(), pollent_,       path_,
-                                     call_start_time_,  deadline_,      arena(),
-                                     call_context_,     call_combiner()};
+  DynamicFilters::Call::Args args = {dynamic_filters(), pollent_,  path_,
+                                     call_start_time_,  deadline_, arena(),
+                                     call_combiner()};
   grpc_error_handle error;
   DynamicFilters* channel_stack = args.channel_stack.get();
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-    gpr_log(
-        GPR_INFO,
-        "chand=%p calld=%p: creating dynamic call stack on channel_stack=%p",
-        chand(), this, channel_stack);
-  }
+  GRPC_TRACE_LOG(client_channel_call, INFO)
+      << "chand=" << chand() << " calld=" << this
+      << ": creating dynamic call stack on channel_stack=" << channel_stack;
   dynamic_call_ = channel_stack->CreateCall(std::move(args), &error);
   if (!error.ok()) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-      gpr_log(GPR_INFO,
-              "chand=%p calld=%p: failed to create dynamic call: error=%s",
-              chand(), this, StatusToString(error).c_str());
-    }
+    GRPC_TRACE_LOG(client_channel_call, INFO)
+        << "chand=" << chand() << " calld=" << this
+        << ": failed to create dynamic call: error=" << StatusToString(error);
     PendingBatchesFail(error, YieldCallCombiner);
     return;
   }
@@ -2581,15 +2276,11 @@ void ClientChannelFilter::FilterBasedCallData::
         void* arg, grpc_error_handle error) {
   auto* calld = static_cast<FilterBasedCallData*>(arg);
   auto* chand = calld->chand();
-  auto* service_config_call_data =
-      GetServiceConfigCallData(calld->call_context());
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
-    gpr_log(GPR_INFO,
-            "chand=%p calld=%p: got recv_trailing_metadata_ready: error=%s "
-            "service_config_call_data=%p",
-            chand, calld, StatusToString(error).c_str(),
-            service_config_call_data);
-  }
+  auto* service_config_call_data = GetServiceConfigCallData(calld->arena());
+  GRPC_TRACE_LOG(client_channel_call, INFO)
+      << "chand=" << chand << " calld=" << calld
+      << ": got recv_trailing_metadata_ready: error=" << StatusToString(error)
+      << " service_config_call_data=" << service_config_call_data;
   if (service_config_call_data != nullptr) {
     service_config_call_data->Commit();
   }
@@ -2607,7 +2298,7 @@ class ClientChannelFilter::LoadBalancedCall::LbCallState final
  public:
   explicit LbCallState(LoadBalancedCall* lb_call) : lb_call_(lb_call) {}
 
-  void* Alloc(size_t size) override { return lb_call_->arena()->Alloc(size); }
+  void* Alloc(size_t size) override { return lb_call_->arena_->Alloc(size); }
 
   // Internal API to allow first-party LB policies to access per-call
   // attributes set by the ConfigSelector.
@@ -2620,81 +2311,6 @@ class ClientChannelFilter::LoadBalancedCall::LbCallState final
   LoadBalancedCall* lb_call_;
 };
 
-//
-// ClientChannelFilter::LoadBalancedCall::Metadata
-//
-
-class ClientChannelFilter::LoadBalancedCall::Metadata final
-    : public LoadBalancingPolicy::MetadataInterface {
- public:
-  explicit Metadata(grpc_metadata_batch* batch) : batch_(batch) {}
-
-  void Add(absl::string_view key, absl::string_view value) override {
-    if (batch_ == nullptr) return;
-    // Gross, egregious hack to support legacy grpclb behavior.
-    // TODO(ctiller): Use a promise context for this once that plumbing is done.
-    if (key == GrpcLbClientStatsMetadata::key()) {
-      batch_->Set(
-          GrpcLbClientStatsMetadata(),
-          const_cast<GrpcLbClientStats*>(
-              reinterpret_cast<const GrpcLbClientStats*>(value.data())));
-      return;
-    }
-    batch_->Append(key, Slice::FromStaticString(value),
-                   [key](absl::string_view error, const Slice& value) {
-                     gpr_log(GPR_ERROR, "%s",
-                             absl::StrCat(error, " key:", key,
-                                          " value:", value.as_string_view())
-                                 .c_str());
-                   });
-  }
-
-  std::vector<std::pair<std::string, std::string>> TestOnlyCopyToVector()
-      override {
-    if (batch_ == nullptr) return {};
-    Encoder encoder;
-    batch_->Encode(&encoder);
-    return encoder.Take();
-  }
-
-  absl::optional<absl::string_view> Lookup(absl::string_view key,
-                                           std::string* buffer) const override {
-    if (batch_ == nullptr) return absl::nullopt;
-    return batch_->GetStringValue(key, buffer);
-  }
-
- private:
-  class Encoder final {
-   public:
-    void Encode(const Slice& key, const Slice& value) {
-      out_.emplace_back(std::string(key.as_string_view()),
-                        std::string(value.as_string_view()));
-    }
-
-    template <class Which>
-    void Encode(Which, const typename Which::ValueType& value) {
-      auto value_slice = Which::Encode(value);
-      out_.emplace_back(std::string(Which::key()),
-                        std::string(value_slice.as_string_view()));
-    }
-
-    void Encode(GrpcTimeoutMetadata,
-                const typename GrpcTimeoutMetadata::ValueType&) {}
-    void Encode(HttpPathMetadata, const Slice&) {}
-    void Encode(HttpMethodMetadata,
-                const typename HttpMethodMetadata::ValueType&) {}
-
-    std::vector<std::pair<std::string, std::string>> Take() {
-      return std::move(out_);
-    }
-
-   private:
-    std::vector<std::pair<std::string, std::string>> out_;
-  };
-
-  grpc_metadata_batch* batch_;
-};
-
 //
 // ClientChannelFilter::LoadBalancedCall::LbCallState
 //
@@ -2702,8 +2318,7 @@ class ClientChannelFilter::LoadBalancedCall::Metadata final
 ServiceConfigCallData::CallAttributeInterface*
 ClientChannelFilter::LoadBalancedCall::LbCallState::GetCallAttribute(
     UniqueTypeName type) const {
-  auto* service_config_call_data =
-      GetServiceConfigCallData(lb_call_->call_context_);
+  auto* service_config_call_data = GetServiceConfigCallData(lb_call_->arena_);
   return service_config_call_data->GetCallAttribute(type);
 }
 
@@ -2729,7 +2344,7 @@ class ClientChannelFilter::LoadBalancedCall::BackendMetricAccessor final
         recv_trailing_metadata_ != nullptr) {
       if (const auto* md = recv_trailing_metadata_->get_pointer(
               EndpointLoadMetricsBinMetadata())) {
-        BackendMetricAllocator allocator(lb_call_->arena());
+        BackendMetricAllocator allocator(lb_call_->arena_);
         lb_call_->backend_metric_data_ =
             ParseBackendMetricData(md->as_string_view(), &allocator);
       }
@@ -2764,31 +2379,31 @@ class ClientChannelFilter::LoadBalancedCall::BackendMetricAccessor final
 
 namespace {
 
-void CreateCallAttemptTracer(grpc_call_context_element* context,
-                             bool is_transparent_retry) {
-  auto* call_tracer = static_cast<ClientCallTracer*>(
-      context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value);
-  if (call_tracer == nullptr) return;
+ClientCallTracer::CallAttemptTracer* CreateCallAttemptTracer(
+    Arena* arena, bool is_transparent_retry) {
+  auto* call_tracer = DownCast<ClientCallTracer*>(
+      arena->GetContext<CallTracerAnnotationInterface>());
+  if (call_tracer == nullptr) return nullptr;
   auto* tracer = call_tracer->StartNewAttempt(is_transparent_retry);
-  context[GRPC_CONTEXT_CALL_TRACER].value = tracer;
+  arena->SetContext<CallTracerInterface>(tracer);
+  return tracer;
 }
 
 }  // namespace
 
 ClientChannelFilter::LoadBalancedCall::LoadBalancedCall(
-    ClientChannelFilter* chand, grpc_call_context_element* call_context,
+    ClientChannelFilter* chand, Arena* arena,
     absl::AnyInvocable<void()> on_commit, bool is_transparent_retry)
-    : InternallyRefCounted(
-          GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)
-              ? "LoadBalancedCall"
-              : nullptr),
+    : InternallyRefCounted(GRPC_TRACE_FLAG_ENABLED(client_channel_lb_call)
+                               ? "LoadBalancedCall"
+                               : nullptr),
       chand_(chand),
+      call_attempt_tracer_(
+          CreateCallAttemptTracer(arena, is_transparent_retry)),
       on_commit_(std::move(on_commit)),
-      call_context_(call_context) {
-  CreateCallAttemptTracer(call_context, is_transparent_retry);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-    gpr_log(GPR_INFO, "chand=%p lb_call=%p: created", chand_, this);
-  }
+      arena_(arena) {
+  GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+      << "chand=" << chand_ << " lb_call=" << this << ": created";
 }
 
 ClientChannelFilter::LoadBalancedCall::~LoadBalancedCall() {
@@ -2809,7 +2424,7 @@ void ClientChannelFilter::LoadBalancedCall::RecordCallCompletion(
   // If the LB policy requested a callback for trailing metadata, invoke
   // the callback.
   if (lb_subchannel_call_tracker_ != nullptr) {
-    Metadata trailing_metadata(recv_trailing_metadata);
+    LbMetadata trailing_metadata(recv_trailing_metadata);
     BackendMetricAccessor backend_metric_accessor(this, recv_trailing_metadata);
     LoadBalancingPolicy::SubchannelCallTrackerInterface::FinishArgs args = {
         peer_address, status, &trailing_metadata, &backend_metric_accessor};
@@ -2829,24 +2444,22 @@ void ClientChannelFilter::LoadBalancedCall::RecordLatency() {
 
 void ClientChannelFilter::LoadBalancedCall::
     RemoveCallFromLbQueuedCallsLocked() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-    gpr_log(GPR_INFO, "chand=%p lb_call=%p: removing from queued picks list",
-            chand_, this);
-  }
+  GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+      << "chand=" << chand_ << " lb_call=" << this
+      << ": removing from queued picks list";
   // Remove pollset_set linkage.
   grpc_polling_entity_del_from_pollset_set(pollent(),
                                            chand_->interested_parties_);
   // Note: There's no need to actually remove the call from the queue
-  // here, beacuse that will be done in either
+  // here, because that will be done in either
   // LbQueuedCallCanceller::CancelLocked() or
   // in ClientChannelFilter::UpdateStateAndPickerLocked().
 }
 
 void ClientChannelFilter::LoadBalancedCall::AddCallToLbQueuedCallsLocked() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-    gpr_log(GPR_INFO, "chand=%p lb_call=%p: adding to queued picks list",
-            chand_, this);
-  }
+  GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+      << "chand=" << chand_ << " lb_call=" << this
+      << ": adding to queued picks list";
   // Add call's pollent to channel's interested_parties, so that I/O
   // can be done under the call's CQ.
   grpc_polling_entity_add_to_pollset_set(pollent(),
@@ -2856,84 +2469,48 @@ void ClientChannelFilter::LoadBalancedCall::AddCallToLbQueuedCallsLocked() {
   OnAddToQueueLocked();
 }
 
-absl::optional<absl::Status>
+std::optional<absl::Status>
 ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
-  // We may accumulate multiple pickers here, because if a picker says
-  // to queue the call, we check again to see if the picker has been
-  // updated before we queue it.
-  // We need to unref pickers in the WorkSerializer.
-  std::vector<RefCountedPtr<LoadBalancingPolicy::SubchannelPicker>> pickers;
-  auto cleanup = absl::MakeCleanup([&]() {
-    if (IsWorkSerializerDispatchEnabled()) return;
-    chand_->work_serializer_->Run(
-        [pickers = std::move(pickers)]() mutable {
-          for (auto& picker : pickers) {
-            picker.reset(DEBUG_LOCATION, "PickSubchannel");
-          }
-        },
-        DEBUG_LOCATION);
-  });
-  absl::AnyInvocable<void(RefCountedPtr<LoadBalancingPolicy::SubchannelPicker>)>
-      set_picker;
-  if (!IsWorkSerializerDispatchEnabled()) {
-    set_picker =
-        [&](RefCountedPtr<LoadBalancingPolicy::SubchannelPicker> picker) {
-          pickers.emplace_back(std::move(picker));
-        };
-  } else {
-    pickers.emplace_back();
-    set_picker =
-        [&](RefCountedPtr<LoadBalancingPolicy::SubchannelPicker> picker) {
-          pickers[0] = std::move(picker);
-        };
-  }
-  // Grab mutex and take a ref to the picker.
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-    gpr_log(GPR_INFO, "chand=%p lb_call=%p: grabbing LB mutex to get picker",
-            chand_, this);
-  }
   RefCountedPtr<LoadBalancingPolicy::SubchannelPicker> picker;
+  // Grab mutex and take a ref to the picker.
+  GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+      << "chand=" << chand_ << " lb_call=" << this
+      << ": grabbing LB mutex to get picker";
   {
     MutexLock lock(&chand_->lb_mu_);
-    set_picker(chand_->picker_);
+    picker = chand_->picker_;
   }
   while (true) {
     // TODO(roth): Fix race condition in channel_idle filter and any
     // other possible causes of this.
-    if (pickers.back() == nullptr) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-        gpr_log(GPR_ERROR, "chand=%p lb_call=%p: picker is null, failing call",
-                chand_, this);
-      }
+    if (picker == nullptr) {
+      GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+          << "chand=" << chand_ << " lb_call=" << this
+          << ": picker is null, failing call";
       return absl::InternalError("picker is null -- shouldn't happen");
     }
     // Do pick.
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-      gpr_log(GPR_INFO, "chand=%p lb_call=%p: performing pick with picker=%p",
-              chand_, this, pickers.back().get());
-    }
+    GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+        << "chand=" << chand_ << " lb_call=" << this
+        << ": performing pick with picker=" << picker.get();
     grpc_error_handle error;
-    bool pick_complete = PickSubchannelImpl(pickers.back().get(), &error);
+    bool pick_complete = PickSubchannelImpl(picker.get(), &error);
     if (!pick_complete) {
       RefCountedPtr<LoadBalancingPolicy::SubchannelPicker> old_picker;
       MutexLock lock(&chand_->lb_mu_);
       // If picker has been swapped out since we grabbed it, try again.
-      if (pickers.back() != chand_->picker_) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-          gpr_log(GPR_INFO,
-                  "chand=%p lb_call=%p: pick not complete, but picker changed",
-                  chand_, this);
-        }
-        if (IsWorkSerializerDispatchEnabled()) {
-          // Don't unref until after we release the mutex.
-          old_picker = std::move(pickers.back());
-        }
-        set_picker(chand_->picker_);
+      if (picker != chand_->picker_) {
+        GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+            << "chand=" << chand_ << " lb_call=" << this
+            << ": pick not complete, but picker changed";
+        // Don't unref until after we release the mutex.
+        old_picker = std::move(picker);
+        picker = chand_->picker_;
         continue;
       }
       // Otherwise queue the pick to try again later when we get a new picker.
       AddCallToLbQueuedCallsLocked();
-      return absl::nullopt;
+      return std::nullopt;
     }
     // Pick is complete.
     // If it was queued, add a trace annotation.
@@ -2942,11 +2519,9 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
     }
     // If the pick failed, fail the call.
     if (!error.ok()) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-        gpr_log(GPR_INFO,
-                "chand=%p lb_call=%p: failed to pick subchannel: error=%s",
-                chand_, this, StatusToString(error).c_str());
-      }
+      GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+          << "chand=" << chand_ << " lb_call=" << this
+          << ": failed to pick subchannel: error=" << StatusToString(error);
       return error;
     }
     // Pick succeeded.
@@ -2957,27 +2532,26 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
 
 bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
     LoadBalancingPolicy::SubchannelPicker* picker, grpc_error_handle* error) {
-  GPR_ASSERT(connected_subchannel_ == nullptr);
+  CHECK(connected_subchannel_ == nullptr);
   // Perform LB pick.
   LoadBalancingPolicy::PickArgs pick_args;
   Slice* path = send_initial_metadata()->get_pointer(HttpPathMetadata());
-  GPR_ASSERT(path != nullptr);
+  CHECK_NE(path, nullptr);
   pick_args.path = path->as_string_view();
   LbCallState lb_call_state(this);
   pick_args.call_state = &lb_call_state;
-  Metadata initial_metadata(send_initial_metadata());
+  LbMetadata initial_metadata(send_initial_metadata());
   pick_args.initial_metadata = &initial_metadata;
   auto result = picker->Pick(pick_args);
   return HandlePickResult<bool>(
       &result,
       // CompletePick
       [this](LoadBalancingPolicy::PickResult::Complete* complete_pick) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-          gpr_log(GPR_INFO,
-                  "chand=%p lb_call=%p: LB pick succeeded: subchannel=%p",
-                  chand_, this, complete_pick->subchannel.get());
-        }
-        GPR_ASSERT(complete_pick->subchannel != nullptr);
+        GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+            << "chand=" << chand_ << " lb_call=" << this
+            << ": LB pick succeeded: subchannel="
+            << complete_pick->subchannel.get();
+        CHECK(complete_pick->subchannel != nullptr);
         // Grab a ref to the connected subchannel while we're still
         // holding the data plane mutex.
         SubchannelWrapper* subchannel =
@@ -2988,12 +2562,10 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
         // yet seen that change and given us a new picker), then just
         // queue the pick.  We'll try again as soon as we get a new picker.
         if (connected_subchannel_ == nullptr) {
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-            gpr_log(GPR_INFO,
-                    "chand=%p lb_call=%p: subchannel returned by LB picker "
-                    "has no connected subchannel; queueing pick",
-                    chand_, this);
-          }
+          GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+              << "chand=" << chand_ << " lb_call=" << this
+              << ": subchannel returned by LB picker "
+                 "has no connected subchannel; queueing pick";
           return false;
         }
         lb_subchannel_call_tracker_ =
@@ -3001,22 +2573,24 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
         if (lb_subchannel_call_tracker_ != nullptr) {
           lb_subchannel_call_tracker_->Start();
         }
+        // Handle metadata mutations.
+        MetadataMutationHandler::Apply(complete_pick->metadata_mutations,
+                                       send_initial_metadata());
+        MaybeOverrideAuthority(std::move(complete_pick->authority_override),
+                               send_initial_metadata());
         return true;
       },
       // QueuePick
       [this](LoadBalancingPolicy::PickResult::Queue* /*queue_pick*/) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-          gpr_log(GPR_INFO, "chand=%p lb_call=%p: LB pick queued", chand_,
-                  this);
-        }
+        GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+            << "chand=" << chand_ << " lb_call=" << this << ": LB pick queued";
         return false;
       },
       // FailPick
       [this, &error](LoadBalancingPolicy::PickResult::Fail* fail_pick) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-          gpr_log(GPR_INFO, "chand=%p lb_call=%p: LB pick failed: %s", chand_,
-                  this, fail_pick->status.ToString().c_str());
-        }
+        GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+            << "chand=" << chand_ << " lb_call=" << this
+            << ": LB pick failed: " << fail_pick->status;
         // If wait_for_ready is false, then the error indicates the RPC
         // attempt's final status.
         if (!send_initial_metadata()
@@ -3032,10 +2606,9 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
       },
       // DropPick
       [this, &error](LoadBalancingPolicy::PickResult::Drop* drop_pick) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-          gpr_log(GPR_INFO, "chand=%p lb_call=%p: LB pick dropped: %s", chand_,
-                  this, drop_pick->status.ToString().c_str());
-        }
+        GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+            << "chand=" << chand_ << " lb_call=" << this
+            << ": LB pick dropped: " << drop_pick->status;
         *error = grpc_error_set_int(
             absl_status_to_grpc_error(MaybeRewriteIllegalStatusCode(
                 std::move(drop_pick->status), "LB drop")),
@@ -3052,10 +2625,8 @@ ClientChannelFilter::FilterBasedLoadBalancedCall::FilterBasedLoadBalancedCall(
     ClientChannelFilter* chand, const grpc_call_element_args& args,
     grpc_polling_entity* pollent, grpc_closure* on_call_destruction_complete,
     absl::AnyInvocable<void()> on_commit, bool is_transparent_retry)
-    : LoadBalancedCall(chand, args.context, std::move(on_commit),
+    : LoadBalancedCall(chand, args.arena, std::move(on_commit),
                        is_transparent_retry),
-      deadline_(args.deadline),
-      arena_(args.arena),
       owning_call_(args.call_stack),
       call_combiner_(args.call_combiner),
       pollent_(pollent),
@@ -3065,7 +2636,7 @@ ClientChannelFilter::FilterBasedLoadBalancedCall::
     ~FilterBasedLoadBalancedCall() {
   // Make sure there are no remaining pending batches.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    GPR_ASSERT(pending_batches_[i] == nullptr);
+    CHECK_EQ(pending_batches_[i], nullptr);
   }
   if (on_call_destruction_complete_ != nullptr) {
     ExecCtx::Run(DEBUG_LOCATION, on_call_destruction_complete_,
@@ -3103,12 +2674,10 @@ size_t ClientChannelFilter::FilterBasedLoadBalancedCall::GetBatchIndex(
 void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesAdd(
     grpc_transport_stream_op_batch* batch) {
   const size_t idx = GetBatchIndex(batch);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-    gpr_log(GPR_INFO,
-            "chand=%p lb_call=%p: adding pending batch at index %" PRIuPTR,
-            chand(), this, idx);
-  }
-  GPR_ASSERT(pending_batches_[idx] == nullptr);
+  GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+      << "chand=" << chand() << " lb_call=" << this
+      << ": adding pending batch at index " << idx;
+  CHECK_EQ(pending_batches_[idx], nullptr);
   pending_batches_[idx] = batch;
 }
 
@@ -3128,16 +2697,15 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
 void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesFail(
     grpc_error_handle error,
     YieldCallCombinerPredicate yield_call_combiner_predicate) {
-  GPR_ASSERT(!error.ok());
+  CHECK(!error.ok());
   failure_error_ = error;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(client_channel_lb_call)) {
     size_t num_batches = 0;
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
       if (pending_batches_[i] != nullptr) ++num_batches;
     }
-    gpr_log(GPR_INFO,
-            "chand=%p lb_call=%p: failing %" PRIuPTR " pending batches: %s",
-            chand(), this, num_batches, StatusToString(error).c_str());
+    LOG(INFO) << "chand=" << chand() << " lb_call=" << this << ": failing "
+              << num_batches << " pending batches: " << StatusToString(error);
   }
   CallCombinerClosureList closures;
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -3172,15 +2740,14 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
 
 // This is called via the call combiner, so access to calld is synchronized.
 void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesResume() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(client_channel_lb_call)) {
     size_t num_batches = 0;
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
       if (pending_batches_[i] != nullptr) ++num_batches;
     }
-    gpr_log(GPR_INFO,
-            "chand=%p lb_call=%p: starting %" PRIuPTR
-            " pending batches on subchannel_call=%p",
-            chand(), this, num_batches, subchannel_call_.get());
+    LOG(INFO) << "chand=" << chand() << " lb_call=" << this << ": starting "
+              << num_batches << " pending batches on subchannel_call="
+              << subchannel_call_.get();
   }
   CallCombinerClosureList closures;
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -3201,14 +2768,12 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesResume() {
 
 void ClientChannelFilter::FilterBasedLoadBalancedCall::
     StartTransportStreamOpBatch(grpc_transport_stream_op_batch* batch) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace) ||
-      GRPC_TRACE_FLAG_ENABLED(grpc_trace_channel)) {
-    gpr_log(GPR_INFO,
-            "chand=%p lb_call=%p: batch started from above: %s, "
-            "call_attempt_tracer()=%p",
-            chand(), this,
-            grpc_transport_stream_op_batch_string(batch, false).c_str(),
-            call_attempt_tracer());
+  if (GRPC_TRACE_FLAG_ENABLED(client_channel_lb_call) ||
+      GRPC_TRACE_FLAG_ENABLED(channel)) {
+    LOG(INFO) << "chand=" << chand() << " lb_call=" << this
+              << ": batch started from above: "
+              << grpc_transport_stream_op_batch_string(batch, false)
+              << ", call_attempt_tracer()=" << call_attempt_tracer();
   }
   // Handle call tracing.
   if (call_attempt_tracer() != nullptr) {
@@ -3256,11 +2821,9 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
   // the channel's data plane mutex, which is more efficient (especially for
   // streaming calls).
   if (subchannel_call_ != nullptr) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-      gpr_log(GPR_INFO,
-              "chand=%p lb_call=%p: starting batch on subchannel_call=%p",
-              chand(), this, subchannel_call_.get());
-    }
+    GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+        << "chand=" << chand() << " lb_call=" << this
+        << ": starting batch on subchannel_call=" << subchannel_call_.get();
     subchannel_call_->StartTransportStreamOpBatch(batch);
     return;
   }
@@ -3268,10 +2831,9 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
   //
   // If we've previously been cancelled, immediately fail any new batches.
   if (GPR_UNLIKELY(!cancel_error_.ok())) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-      gpr_log(GPR_INFO, "chand=%p lb_call=%p: failing batch with error: %s",
-              chand(), this, StatusToString(cancel_error_).c_str());
-    }
+    GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+        << "chand=" << chand() << " lb_call=" << this
+        << ": failing batch with error: " << StatusToString(cancel_error_);
     // Note: This will release the call combiner.
     grpc_transport_stream_op_batch_finish_with_failure(batch, cancel_error_,
                                                        call_combiner_);
@@ -3285,10 +2847,9 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
     // is in the past when the call starts), we can return the right
     // error to the caller when the first batch does get passed down.
     cancel_error_ = batch->payload->cancel_stream.cancel_error;
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-      gpr_log(GPR_INFO, "chand=%p lb_call=%p: recording cancel_error=%s",
-              chand(), this, StatusToString(cancel_error_).c_str());
-    }
+    GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+        << "chand=" << chand() << " lb_call=" << this
+        << ": recording cancel_error=" << StatusToString(cancel_error_).c_str();
     // Fail all pending batches.
     PendingBatchesFail(cancel_error_, NoYieldCallCombiner);
     // Note: This will release the call combiner.
@@ -3304,11 +2865,9 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
     TryPick(/*was_queued=*/false);
   } else {
     // For all other batches, release the call combiner.
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-      gpr_log(GPR_INFO,
-              "chand=%p lb_call=%p: saved batch, yielding call combiner",
-              chand(), this);
-    }
+    GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+        << "chand=" << chand() << " lb_call=" << this
+        << ": saved batch, yielding call combiner";
     GRPC_CALL_COMBINER_STOP(call_combiner_,
                             "batch does not include send_initial_metadata");
   }
@@ -3317,11 +2876,9 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
 void ClientChannelFilter::FilterBasedLoadBalancedCall::RecvInitialMetadataReady(
     void* arg, grpc_error_handle error) {
   auto* self = static_cast<FilterBasedLoadBalancedCall*>(arg);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-    gpr_log(GPR_INFO,
-            "chand=%p lb_call=%p: got recv_initial_metadata_ready: error=%s",
-            self->chand(), self, StatusToString(error).c_str());
-  }
+  GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+      << "chand=" << self->chand() << " lb_call=" << self
+      << ": got recv_initial_metadata_ready: error=" << StatusToString(error);
   if (error.ok()) {
     // recv_initial_metadata_flags is not populated for clients
     self->call_attempt_tracer()->RecordReceivedInitialMetadata(
@@ -3336,15 +2893,12 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::RecvInitialMetadataReady(
 void ClientChannelFilter::FilterBasedLoadBalancedCall::
     RecvTrailingMetadataReady(void* arg, grpc_error_handle error) {
   auto* self = static_cast<FilterBasedLoadBalancedCall*>(arg);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-    gpr_log(GPR_INFO,
-            "chand=%p lb_call=%p: got recv_trailing_metadata_ready: error=%s "
-            "call_attempt_tracer()=%p lb_subchannel_call_tracker_=%p "
-            "failure_error_=%s",
-            self->chand(), self, StatusToString(error).c_str(),
-            self->call_attempt_tracer(), self->lb_subchannel_call_tracker(),
-            StatusToString(self->failure_error_).c_str());
-  }
+  GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+      << "chand=" << self->chand() << " lb_call=" << self
+      << ": got recv_trailing_metadata_ready: error=" << StatusToString(error)
+      << " call_attempt_tracer()=" << self->call_attempt_tracer()
+      << " lb_subchannel_call_tracker_=" << self->lb_subchannel_call_tracker()
+      << " failure_error_=" << StatusToString(self->failure_error_);
   // Check if we have a tracer or an LB callback to invoke.
   if (self->call_attempt_tracer() != nullptr ||
       self->lb_subchannel_call_tracker() != nullptr) {
@@ -3354,8 +2908,9 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
       // Get status from error.
       grpc_status_code code;
       std::string message;
-      grpc_error_get_status(error, self->deadline_, &code, &message,
-                            /*http_error=*/nullptr, /*error_string=*/nullptr);
+      grpc_error_get_status(
+          error, self->arena()->GetContext<Call>()->deadline(), &code, &message,
+          /*http_error=*/nullptr, /*error_string=*/nullptr);
       status = absl::Status(static_cast<absl::StatusCode>(code), message);
     } else {
       // Get status from headers.
@@ -3411,13 +2966,11 @@ class ClientChannelFilter::FilterBasedLoadBalancedCall::LbQueuedCallCanceller
     auto* chand = lb_call->chand();
     {
       MutexLock lock(&chand->lb_mu_);
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-        gpr_log(GPR_INFO,
-                "chand=%p lb_call=%p: cancelling queued pick: "
-                "error=%s self=%p calld->pick_canceller=%p",
-                chand, lb_call, StatusToString(error).c_str(), self,
-                lb_call->lb_call_canceller_);
-      }
+      GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+          << "chand=" << chand << " lb_call=" << lb_call
+          << ": cancelling queued pick: error=" << StatusToString(error)
+          << " self=" << self
+          << " calld->pick_canceller=" << lb_call->lb_call_canceller_;
       if (lb_call->lb_call_canceller_ == self && !error.ok()) {
         lb_call->Commit();
         // Remove pick from list of queued picks.
@@ -3490,20 +3043,19 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::RetryPickLocked() {
 
 void ClientChannelFilter::FilterBasedLoadBalancedCall::CreateSubchannelCall() {
   Slice* path = send_initial_metadata()->get_pointer(HttpPathMetadata());
-  GPR_ASSERT(path != nullptr);
+  CHECK_NE(path, nullptr);
   SubchannelCall::Args call_args = {
       connected_subchannel()->Ref(), pollent_, path->Ref(), /*start_time=*/0,
-      deadline_, arena_,
+      arena()->GetContext<Call>()->deadline(),
       // TODO(roth): When we implement hedging support, we will probably
-      // need to use a separate call context for each subchannel call.
-      call_context(), call_combiner_};
+      // need to use a separate call arena for each subchannel call.
+      arena(), call_combiner_};
   grpc_error_handle error;
   subchannel_call_ = SubchannelCall::Create(std::move(call_args), &error);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-    gpr_log(GPR_INFO,
-            "chand=%p lb_call=%p: create subchannel_call=%p: error=%s", chand(),
-            this, subchannel_call_.get(), StatusToString(error).c_str());
-  }
+  GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+      << "chand=" << chand() << " lb_call=" << this
+      << ": create subchannel_call=" << subchannel_call_.get()
+      << ": error=" << StatusToString(error);
   if (on_call_destruction_complete_ != nullptr) {
     subchannel_call_->SetAfterCallStackDestroy(on_call_destruction_complete_);
     on_call_destruction_complete_ = nullptr;
@@ -3515,150 +3067,4 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::CreateSubchannelCall() {
   }
 }
 
-//
-// ClientChannelFilter::PromiseBasedLoadBalancedCall
-//
-
-ClientChannelFilter::PromiseBasedLoadBalancedCall::PromiseBasedLoadBalancedCall(
-    ClientChannelFilter* chand, absl::AnyInvocable<void()> on_commit,
-    bool is_transparent_retry)
-    : LoadBalancedCall(chand, GetContext<grpc_call_context_element>(),
-                       std::move(on_commit), is_transparent_retry) {}
-
-ArenaPromise<ServerMetadataHandle>
-ClientChannelFilter::PromiseBasedLoadBalancedCall::MakeCallPromise(
-    CallArgs call_args, OrphanablePtr<PromiseBasedLoadBalancedCall> lb_call) {
-  pollent_ = NowOrNever(call_args.polling_entity->WaitAndCopy()).value();
-  // Record ops in tracer.
-  if (call_attempt_tracer() != nullptr) {
-    call_attempt_tracer()->RecordSendInitialMetadata(
-        call_args.client_initial_metadata.get());
-    // TODO(ctiller): Find a way to do this without registering a no-op mapper.
-    call_args.client_to_server_messages->InterceptAndMapWithHalfClose(
-        [](MessageHandle message) { return message; },  // No-op.
-        [this]() {
-          // TODO(roth): Change CallTracer API to not pass metadata
-          // batch to this method, since the batch is always empty.
-          grpc_metadata_batch metadata;
-          call_attempt_tracer()->RecordSendTrailingMetadata(&metadata);
-        });
-  }
-  // Extract peer name from server initial metadata.
-  call_args.server_initial_metadata->InterceptAndMap(
-      [self = lb_call->RefAsSubclass<PromiseBasedLoadBalancedCall>()](
-          ServerMetadataHandle metadata) {
-        if (self->call_attempt_tracer() != nullptr) {
-          self->call_attempt_tracer()->RecordReceivedInitialMetadata(
-              metadata.get());
-        }
-        Slice* peer_string = metadata->get_pointer(PeerString());
-        if (peer_string != nullptr) self->peer_string_ = peer_string->Ref();
-        return metadata;
-      });
-  client_initial_metadata_ = std::move(call_args.client_initial_metadata);
-  return OnCancel(
-      Map(TrySeq(
-              // LB pick.
-              [this]() -> Poll<absl::Status> {
-                auto result = PickSubchannel(was_queued_);
-                if (GRPC_TRACE_FLAG_ENABLED(
-                        grpc_client_channel_lb_call_trace)) {
-                  gpr_log(GPR_INFO,
-                          "chand=%p lb_call=%p: %sPickSubchannel() returns %s",
-                          chand(), this,
-                          GetContext<Activity>()->DebugTag().c_str(),
-                          result.has_value() ? result->ToString().c_str()
-                                             : "Pending");
-                }
-                if (result == absl::nullopt) return Pending{};
-                return std::move(*result);
-              },
-              [this, call_args = std::move(call_args)]() mutable
-              -> ArenaPromise<ServerMetadataHandle> {
-                call_args.client_initial_metadata =
-                    std::move(client_initial_metadata_);
-                return connected_subchannel()->MakeCallPromise(
-                    std::move(call_args));
-              }),
-          // Record call completion.
-          [this](ServerMetadataHandle metadata) {
-            if (call_attempt_tracer() != nullptr ||
-                lb_subchannel_call_tracker() != nullptr) {
-              absl::Status status;
-              grpc_status_code code = metadata->get(GrpcStatusMetadata())
-                                          .value_or(GRPC_STATUS_UNKNOWN);
-              if (code != GRPC_STATUS_OK) {
-                absl::string_view message;
-                if (const auto* grpc_message =
-                        metadata->get_pointer(GrpcMessageMetadata())) {
-                  message = grpc_message->as_string_view();
-                }
-                status =
-                    absl::Status(static_cast<absl::StatusCode>(code), message);
-              }
-              RecordCallCompletion(status, metadata.get(),
-                                   &GetContext<CallContext>()
-                                        ->call_stats()
-                                        ->transport_stream_stats,
-                                   peer_string_.as_string_view());
-            }
-            RecordLatency();
-            return metadata;
-          }),
-      [lb_call = std::move(lb_call)]() {
-        // If the waker is pending, then we need to remove ourself from
-        // the list of queued LB calls.
-        if (!lb_call->waker_.is_unwakeable()) {
-          MutexLock lock(&lb_call->chand()->lb_mu_);
-          lb_call->Commit();
-          // Remove pick from list of queued picks.
-          lb_call->RemoveCallFromLbQueuedCallsLocked();
-          // Remove from queued picks list.
-          lb_call->chand()->lb_queued_calls_.erase(lb_call.get());
-        }
-        // TODO(ctiller): We don't have access to the call's actual status
-        // here, so we just assume CANCELLED.  We could change this to use
-        // CallFinalization instead of OnCancel() so that we can get the
-        // actual status.  But we should also have access to the trailing
-        // metadata, which we don't have in either case.  Ultimately, we
-        // need a better story for code that needs to run at the end of a
-        // call in both cancellation and non-cancellation cases that needs
-        // access to server trailing metadata and the call's real status.
-        if (lb_call->call_attempt_tracer() != nullptr) {
-          lb_call->call_attempt_tracer()->RecordCancel(
-              absl::CancelledError("call cancelled"));
-        }
-        if (lb_call->call_attempt_tracer() != nullptr ||
-            lb_call->lb_subchannel_call_tracker() != nullptr) {
-          // If we were cancelled without recording call completion, then
-          // record call completion here, as best we can.  We assume status
-          // CANCELLED in this case.
-          lb_call->RecordCallCompletion(absl::CancelledError("call cancelled"),
-                                        nullptr, nullptr, "");
-        }
-      });
-}
-
-Arena* ClientChannelFilter::PromiseBasedLoadBalancedCall::arena() const {
-  return GetContext<Arena>();
-}
-
-grpc_metadata_batch*
-ClientChannelFilter::PromiseBasedLoadBalancedCall::send_initial_metadata()
-    const {
-  return client_initial_metadata_.get();
-}
-
-void ClientChannelFilter::PromiseBasedLoadBalancedCall::OnAddToQueueLocked() {
-  waker_ = GetContext<Activity>()->MakeNonOwningWaker();
-  was_queued_ = true;
-}
-
-void ClientChannelFilter::PromiseBasedLoadBalancedCall::RetryPickLocked() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
-    gpr_log(GPR_INFO, "chand=%p lb_call=%p: RetryPickLocked()", chand(), this);
-  }
-  waker_.WakeupAsync();
-}
-
 }  // namespace grpc_core