grpc 1.65.2 → 1.66.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f7fb00b001baa72da1610e37b806197d5be662256faa1fe7b48a6f7f5c27017
-  data.tar.gz: b36119a3b270a2a66827949490d9e708ac3df7abbbb55dc74e55ea6bc3157f58
+  metadata.gz: e52dc0f3d86134aa54814feb69ada6c3fa30f1627f3fecfa8fb2eda3b8e413a6
+  data.tar.gz: '08083c099539b4d8c3712344e644cf14017503900a3a450ec045a996fcb17a85'
 SHA512:
-  metadata.gz: 55ff653a9ed98a3d3122ca80187d6a8897e40b998bd0ad6e68007244939a789fb9f11733784018456e312120c75926530936bc897980aa9dde6485fa1da37ed4
-  data.tar.gz: a20230c8357f4909d26c4f92818d4caa276660b8ee6d668b41c58fe835da6fca97ba75f9a1c98e569c62f699c8acbcddf4c50382a38695b5dbc69188ad07dbcd
+  metadata.gz: 3bfe425204ec77309d3c969b8c7cb3aefbf4739120edb11e9a2c1343b8a74c6579792f3fc67d123f1bd7e743578b58e47334b0410b7fa1f8aa4cfa987b181b8d
+  data.tar.gz: 62bc4b19bc3527c0975a58302f77d37fd3caf06f98333b14307d0ca429be04e3f165c7f61a3eabf591efafe0554f55e035e9058106613003ee42e74c4ada6c5f

data/Makefile

@@ -367,8 +367,8 @@ E = @echo
 Q = @
 endif
 
-CORE_VERSION = 42.0.0
-CPP_VERSION = 1.65.2
+CORE_VERSION = 43.0.0
+CPP_VERSION = 1.66.0-pre3
 
 CPPFLAGS_NO_ARCH += $(addprefix -I, $(INCLUDES)) $(addprefix -D, $(DEFINES))
 CPPFLAGS += $(CPPFLAGS_NO_ARCH) $(ARCH_FLAGS)
@@ -404,7 +404,7 @@ SHARED_EXT_CORE = dll
 SHARED_EXT_CPP = dll
 
 SHARED_PREFIX =
-SHARED_VERSION_CORE = -42
+SHARED_VERSION_CORE = -43
 SHARED_VERSION_CPP = -1
 else ifeq ($(SYSTEM),Darwin)
 EXECUTABLE_SUFFIX =
@@ -675,9 +675,10 @@ LIBGRPC_SRC = \
     src/core/client_channel/client_channel_filter.cc \
     src/core/client_channel/client_channel_plugin.cc \
     src/core/client_channel/client_channel_service_config.cc \
-    src/core/client_channel/config_selector.cc \
+    src/core/client_channel/direct_channel.cc \
     src/core/client_channel/dynamic_filters.cc \
     src/core/client_channel/global_subchannel_pool.cc \
+    src/core/client_channel/lb_metadata.cc \
     src/core/client_channel/load_balanced_call_destination.cc \
     src/core/client_channel/local_subchannel_pool.cc \
     src/core/client_channel/retry_filter.cc \
@@ -1342,6 +1343,7 @@ LIBGRPC_SRC = \
     src/core/lib/transport/call_filters.cc \
     src/core/lib/transport/call_final_info.cc \
     src/core/lib/transport/call_spine.cc \
+    src/core/lib/transport/call_state.cc \
     src/core/lib/transport/connectivity_state.cc \
     src/core/lib/transport/error_utils.cc \
     src/core/lib/transport/interception_chain.cc \
@@ -1459,6 +1461,7 @@ LIBGRPC_SRC = \
     src/core/util/json/json_reader.cc \
     src/core/util/json/json_util.cc \
     src/core/util/json/json_writer.cc \
+    src/core/util/latent_see.cc \
     src/core/util/linux/cpu.cc \
     src/core/util/linux/log.cc \
     src/core/util/log.cc \
@@ -1488,18 +1491,24 @@ LIBGRPC_SRC = \
     src/core/xds/grpc/xds_certificate_provider.cc \
     src/core/xds/grpc/xds_client_grpc.cc \
     src/core/xds/grpc/xds_cluster.cc \
+    src/core/xds/grpc/xds_cluster_parser.cc \
     src/core/xds/grpc/xds_cluster_specifier_plugin.cc \
     src/core/xds/grpc/xds_common_types.cc \
+    src/core/xds/grpc/xds_common_types_parser.cc \
     src/core/xds/grpc/xds_endpoint.cc \
+    src/core/xds/grpc/xds_endpoint_parser.cc \
     src/core/xds/grpc/xds_health_status.cc \
     src/core/xds/grpc/xds_http_fault_filter.cc \
-    src/core/xds/grpc/xds_http_filters.cc \
+    src/core/xds/grpc/xds_http_filter_registry.cc \
     src/core/xds/grpc/xds_http_rbac_filter.cc \
     src/core/xds/grpc/xds_http_stateful_session_filter.cc \
     src/core/xds/grpc/xds_lb_policy_registry.cc \
     src/core/xds/grpc/xds_listener.cc \
+    src/core/xds/grpc/xds_listener_parser.cc \
     src/core/xds/grpc/xds_route_config.cc \
+    src/core/xds/grpc/xds_route_config_parser.cc \
     src/core/xds/grpc/xds_routing.cc \
+    src/core/xds/grpc/xds_server_grpc.cc \
     src/core/xds/grpc/xds_transport_grpc.cc \
     src/core/xds/xds_client/xds_api.cc \
     src/core/xds/xds_client/xds_bootstrap.cc \
@@ -1681,6 +1690,7 @@ LIBGRPC_SRC = \
     third_party/upb/upb/message/array.c \
     third_party/upb/upb/message/compat.c \
     third_party/upb/upb/message/copy.c \
+    third_party/upb/upb/message/internal/compare_unknown.c \
     third_party/upb/upb/message/internal/extension.c \
     third_party/upb/upb/message/internal/message.c \
     third_party/upb/upb/message/map.c \
@@ -1833,8 +1843,8 @@ $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE): $(LIBGRPC_
 ifeq ($(SYSTEM),Darwin)
 	$(Q) $(LDXX) $(LDFLAGS) -L$(LIBDIR)/$(CONFIG) -install_name $(SHARED_PREFIX)grpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) -dynamiclib -o $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBGRPC_OBJS) $(LIBDIR)/$(CONFIG)/libcares.a $(OPENSSL_MERGE_LIBS) $(ZLIB_MERGE_LIBS) $(LDLIBS_SECURE) $(LDLIBS)
 else
-	$(Q) $(LDXX) $(LDFLAGS) -L$(LIBDIR)/$(CONFIG) -shared -Wl,-soname,libgrpc.so.42 -o $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBGRPC_OBJS) $(LIBDIR)/$(CONFIG)/libcares.a $(OPENSSL_MERGE_LIBS) $(ZLIB_MERGE_LIBS) $(LDLIBS_SECURE) $(LDLIBS)
-	$(Q) ln -sf $(SHARED_PREFIX)grpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).so.42
+	$(Q) $(LDXX) $(LDFLAGS) -L$(LIBDIR)/$(CONFIG) -shared -Wl,-soname,libgrpc.so.43 -o $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBGRPC_OBJS) $(LIBDIR)/$(CONFIG)/libcares.a $(OPENSSL_MERGE_LIBS) $(ZLIB_MERGE_LIBS) $(LDLIBS_SECURE) $(LDLIBS)
+	$(Q) ln -sf $(SHARED_PREFIX)grpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).so.43
 	$(Q) ln -sf $(SHARED_PREFIX)grpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).so
 endif
 endif

data/include/grpc/event_engine/event_engine.h

@@ -503,6 +503,20 @@ bool operator!=(const EventEngine::ConnectionHandle& lhs,
 std::ostream& operator<<(std::ostream& out,
                          const EventEngine::ConnectionHandle& handle);
 
+namespace detail {
+std::string FormatHandleString(uint64_t key1, uint64_t key2);
+}
+
+template <typename Sink>
+void AbslStringify(Sink& out, const EventEngine::ConnectionHandle& handle) {
+  out.Append(detail::FormatHandleString(handle.keys[0], handle.keys[1]));
+}
+
+template <typename Sink>
+void AbslStringify(Sink& out, const EventEngine::TaskHandle& handle) {
+  out.Append(detail::FormatHandleString(handle.keys[0], handle.keys[1]));
+}
+
 }  // namespace experimental
 }  // namespace grpc_event_engine
 

data/include/grpc/event_engine/extensible.h

@@ -60,6 +60,9 @@ class Extensible {
   /// if (endpoint != nullptr) endpoint->Process();
   ///
   virtual void* QueryExtension(absl::string_view /*id*/) { return nullptr; }
+
+ protected:
+  ~Extensible() = default;
 };
 
 }  // namespace experimental

data/include/grpc/event_engine/memory_request.h

@@ -46,6 +46,24 @@ class MemoryRequest {
   size_t min() const { return min_; }
   size_t max() const { return max_; }
 
+  bool operator==(const MemoryRequest& other) const {
+    return min_ == other.min_ && max_ == other.max_;
+  }
+  bool operator!=(const MemoryRequest& other) const {
+    return !(*this == other);
+  }
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& s, const MemoryRequest& r) {
+    if (r.min_ == r.max_) {
+      s.Append(r.min_);
+    } else {
+      s.Append(r.min_);
+      s.Append("..");
+      s.Append(r.max_);
+    }
+  }
+
  private:
   size_t min_;
   size_t max_;

data/include/grpc/support/log.h

@@ -41,9 +41,6 @@ typedef enum gpr_log_severity {
   GPR_LOG_SEVERITY_ERROR
 } gpr_log_severity;
 
-/** Returns a string representation of the log severity */
-GPRAPI const char* gpr_log_severity_string(gpr_log_severity severity);
-
 /** Macros to build log contexts at various severity levels */
 #define GPR_DEBUG __FILE__, __LINE__, GPR_LOG_SEVERITY_DEBUG
 #define GPR_INFO __FILE__, __LINE__, GPR_LOG_SEVERITY_INFO
@@ -80,21 +77,6 @@ typedef void (*gpr_log_func)(gpr_log_func_args* args);
 
 GPRAPI void gpr_set_log_function(gpr_log_func deprecated_setting);
 
-GPRAPI void gpr_assertion_failed(const char* filename, int line,
-                                 const char* message) GPR_ATTRIBUTE_NORETURN;
-
-/** abort() the process if x is zero, having written a line to the log.
-
-   Intended for internal invariants.  If the error can be recovered from,
-   without the possibility of corruption, or might best be reflected via
-   an exception in a higher-level language, consider returning error code.  */
-#define GPR_ASSERT(x)                               \
-  do {                                              \
-    if (GPR_UNLIKELY(!(x))) {                       \
-      gpr_assertion_failed(__FILE__, __LINE__, #x); \
-    }                                               \
-  } while (0)
-
 #ifdef __cplusplus
 }
 #endif

data/include/grpc/support/metrics.h

@@ -17,6 +17,7 @@
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/port_platform.h>
 
 namespace grpc_core {
@@ -26,9 +27,10 @@ namespace experimental {
 // plugins.
 class StatsPluginChannelScope {
  public:
-  StatsPluginChannelScope(absl::string_view target,
-                          absl::string_view default_authority)
-      : target_(target), default_authority_(default_authority) {}
+  StatsPluginChannelScope(
+      absl::string_view target, absl::string_view default_authority,
+      const grpc_event_engine::experimental::EndpointConfig& args)
+      : target_(target), default_authority_(default_authority), args_(args) {}
 
   /// Returns the target used for creating the channel in the canonical form.
   /// (Canonicalized target definition -
@@ -36,13 +38,22 @@ class StatsPluginChannelScope {
   absl::string_view target() const { return target_; }
   /// Returns the default authority for the channel.
   absl::string_view default_authority() const { return default_authority_; }
+  /// Returns channel arguments.  THIS METHOD IS EXPERIMENTAL.
+  // TODO(roth, ctiller, yashkt): Find a better representation for
+  // channel args before de-experimentalizing this API.
+  const grpc_event_engine::experimental::EndpointConfig& experimental_args()
+      const {
+    return args_;
+  }
 
  private:
   // Disable copy constructor and copy-assignment operator.
   StatsPluginChannelScope(const StatsPluginChannelScope&) = delete;
   StatsPluginChannelScope& operator=(const StatsPluginChannelScope&) = delete;
+
   absl::string_view target_;
   absl::string_view default_authority_;
+  const grpc_event_engine::experimental::EndpointConfig& args_;
 };
 
 }  // namespace experimental

data/include/grpc/support/port_platform.h

@@ -746,6 +746,22 @@ extern void gpr_unreachable_code(const char* reason, const char* file,
 #endif
 #endif /* GPR_ATTRIBUTE_NOINLINE */
 
+#ifndef GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
+#ifdef __cplusplus
+#if GPR_HAS_CPP_ATTRIBUTE(clang::always_inline)
+#define GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION [[clang::always_inline]]
+#elif GPR_HAS_ATTRIBUTE(always_inline)
+#define GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION __attribute__((always_inline))
+#else
+// TODO(ctiller): add __forceinline for MSVC
+#define GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
+#endif
+#else
+// Disable for C code
+#define GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
+#endif
+#endif /* GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION */
+
 #ifndef GPR_NO_UNIQUE_ADDRESS
 #if GPR_HAS_CPP_ATTRIBUTE(no_unique_address)
 #define GPR_NO_UNIQUE_ADDRESS [[no_unique_address]]
@@ -820,6 +836,12 @@ extern void gpr_unreachable_code(const char* reason, const char* file,
 #endif /* __GPR_WINDOWS */
 #endif /* GRPC_ALLOW_EXCEPTIONS */
 
+#ifdef __has_builtin
+#define GRPC_HAS_BUILTIN(a) __has_builtin(a)
+#else
+#define GRPC_HAS_BUILTIN(a) 0
+#endif
+
 /* Use GPR_LIKELY only in cases where you are sure that a certain outcome is the
  * most likely. Ideally, also collect performance numbers to justify the claim.
  */

data/src/core/client_channel/client_channel.cc

@@ -28,6 +28,7 @@
 #include <vector>
 
 #include "absl/cleanup/cleanup.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/cord.h"
@@ -43,7 +44,6 @@
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/json.h>
-#include <grpc/support/log.h>
 #include <grpc/support/metrics.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
@@ -61,6 +61,7 @@
 #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/event_engine/channel_args_endpoint_config.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -73,6 +74,7 @@
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/sleep.h"
 #include "src/core/lib/promise/try_seq.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -283,10 +285,10 @@ class ClientChannel::SubchannelWrapper::WatcherWrapper
           }
         }
       } else {
-        gpr_log(GPR_ERROR,
-                "client_channel=%p: Illegal keepalive throttling value %s",
-                subchannel_wrapper_->client_channel_.get(),
-                std::string(keepalive_throttling.value()).c_str());
+        LOG(ERROR) << "client_channel="
+                   << subchannel_wrapper_->client_channel_.get()
+                   << ": Illegal keepalive throttling value "
+                   << std::string(keepalive_throttling.value());
       }
     }
     // Propagate status only in state TF.
@@ -453,10 +455,10 @@ class ClientChannel::ClientChannelControlHelper
       const char* extra = client_channel_->disconnect_error_.ok()
                               ? ""
                               : " (ignoring -- channel shutting down)";
-      gpr_log(GPR_INFO,
-              "client_channel=%p: update: state=%s status=(%s) picker=%p%s",
-              client_channel_.get(), ConnectivityStateName(state),
-              status.ToString().c_str(), picker.get(), extra);
+      LOG(INFO) << "client_channel=" << client_channel_.get()
+                << ": update: state=" << ConnectivityStateName(state)
+                << " status=(" << status << ") picker=" << picker.get()
+                << extra;
     }
     // Do update only if not shutting down.
     if (client_channel_->disconnect_error_.ok()) {
@@ -625,6 +627,7 @@ ClientChannel::ClientChannel(
       work_serializer_(std::make_shared<WorkSerializer>(event_engine_)),
       state_tracker_("client_channel", GRPC_CHANNEL_IDLE),
       subchannel_pool_(GetSubchannelPool(channel_args_)) {
+  CHECK(event_engine_.get() != nullptr);
   GRPC_TRACE_LOG(client_channel, INFO)
       << "client_channel=" << this << ": creating client_channel";
   // Set initial keepalive time.
@@ -635,8 +638,10 @@ ClientChannel::ClientChannel(
     keepalive_time_ = -1;  // unset
   }
   // Get stats plugins for channel.
-  experimental::StatsPluginChannelScope scope(this->target(),
-                                              default_authority_);
+  grpc_event_engine::experimental::ChannelArgsEndpointConfig endpoint_config(
+      channel_args_);
+  experimental::StatsPluginChannelScope scope(
+      this->target(), default_authority_, endpoint_config);
   stats_plugin_group_ =
       GlobalStatsPluginRegistry::GetStatsPluginsForChannel(scope);
 }
@@ -683,10 +688,93 @@ grpc_connectivity_state ClientChannel::CheckConnectivityState(
   return state;
 }
 
-void ClientChannel::WatchConnectivityState(grpc_connectivity_state, Timestamp,
-                                           grpc_completion_queue*, void*) {
-  // TODO(ctiller): implement
-  Crash("not implemented");
+namespace {
+
+// A fire-and-forget object to handle external connectivity state watches.
+class ExternalStateWatcher : public RefCounted<ExternalStateWatcher> {
+ public:
+  ExternalStateWatcher(WeakRefCountedPtr<ClientChannel> channel,
+                       grpc_completion_queue* cq, void* tag,
+                       grpc_connectivity_state last_observed_state,
+                       Timestamp deadline)
+      : channel_(std::move(channel)), cq_(cq), tag_(tag) {
+    MutexLock lock(&mu_);
+    // Start watch.  This inherits the ref from creation.
+    auto watcher =
+        MakeOrphanable<Watcher>(RefCountedPtr<ExternalStateWatcher>(this));
+    watcher_ = watcher.get();
+    channel_->AddConnectivityWatcher(last_observed_state, std::move(watcher));
+    // Start timer.  This takes a second ref.
+    const Duration timeout = deadline - Timestamp::Now();
+    timer_handle_ =
+        channel_->event_engine()->RunAfter(timeout, [self = Ref()]() mutable {
+          ApplicationCallbackExecCtx callback_exec_ctx;
+          ExecCtx exec_ctx;
+          self->MaybeStartCompletion(absl::DeadlineExceededError(
+              "Timed out waiting for connection state change"));
+          // ExternalStateWatcher deletion might require an active ExecCtx.
+          self.reset();
+        });
+  }
+
+ private:
+  class Watcher : public AsyncConnectivityStateWatcherInterface {
+   public:
+    explicit Watcher(RefCountedPtr<ExternalStateWatcher> external_state_watcher)
+        : external_state_watcher_(std::move(external_state_watcher)) {}
+
+    void OnConnectivityStateChange(grpc_connectivity_state /*new_state*/,
+                                   const absl::Status& /*status*/) override {
+      external_state_watcher_->MaybeStartCompletion(absl::OkStatus());
+    }
+
+   private:
+    RefCountedPtr<ExternalStateWatcher> external_state_watcher_;
+  };
+
+  // This is called both when the watch reports a new connectivity state
+  // and when the timer fires.  It will trigger a CQ notification only
+  // on the first call.  Subsequent calls will be ignored, because
+  // events can come in asynchronously.
+  void MaybeStartCompletion(absl::Status status) {
+    MutexLock lock(&mu_);
+    if (watcher_ == nullptr) return;  // Ignore subsequent notifications.
+    // Cancel watch.
+    channel_->RemoveConnectivityWatcher(watcher_);
+    watcher_ = nullptr;
+    // Cancel timer.
+    channel_->event_engine()->Cancel(timer_handle_);
+    // Send CQ completion.
+    Ref().release();  // Released in FinishedCompletion().
+    grpc_cq_end_op(cq_, tag_, status, FinishedCompletion, this,
+                   &completion_storage_);
+  }
+
+  // Called when the completion is returned to the CQ.
+  static void FinishedCompletion(void* arg, grpc_cq_completion* /*ignored*/) {
+    auto* self = static_cast<ExternalStateWatcher*>(arg);
+    self->Unref();
+  }
+
+  WeakRefCountedPtr<ClientChannel> channel_;
+
+  Mutex mu_;
+  grpc_completion_queue* cq_ ABSL_GUARDED_BY(&mu_);
+  void* tag_ ABSL_GUARDED_BY(&mu_);
+  grpc_cq_completion completion_storage_ ABSL_GUARDED_BY(&mu_);
+  Watcher* watcher_ ABSL_GUARDED_BY(&mu_) = nullptr;
+  grpc_event_engine::experimental::EventEngine::TaskHandle timer_handle_
+      ABSL_GUARDED_BY(&mu_);
+};
+
+}  // namespace
+
+void ClientChannel::WatchConnectivityState(grpc_connectivity_state state,
+                                           Timestamp deadline,
+                                           grpc_completion_queue* cq,
+                                           void* tag) {
+  new ExternalStateWatcher(WeakRefAsSubclass<ClientChannel>(), cq, tag, state,
+                           deadline);
 }
 
 void ClientChannel::AddConnectivityWatcher(
@@ -768,10 +856,12 @@ grpc_call* ClientChannel::CreateCall(
     grpc_call* parent_call, uint32_t propagation_mask,
     grpc_completion_queue* cq, grpc_pollset_set* /*pollset_set_alternative*/,
     Slice path, absl::optional<Slice> authority, Timestamp deadline, bool) {
+  auto arena = call_arena_allocator()->MakeArena();
+  arena->SetContext<grpc_event_engine::experimental::EventEngine>(
+      event_engine());
   return MakeClientCall(parent_call, propagation_mask, cq, std::move(path),
                         std::move(authority), false, deadline,
-                        compression_options(), event_engine_.get(),
-                        call_arena_allocator()->MakeArena(), Ref());
+                        compression_options(), std::move(arena), Ref());
 }
 
 void ClientChannel::StartCall(UnstartedCallHandler unstarted_handler) {
@@ -907,15 +997,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";
     }
@@ -1195,14 +1283,17 @@ void ClientChannel::UpdateServiceConfigInDataPlaneLocked() {
   }
   CoreConfiguration::Get().channel_init().AddToInterceptionChainBuilder(
       GRPC_CLIENT_CHANNEL, builder);
-  // TODO(roth): add filters returned by config selector
-  // Create call destination.
+  // Add filters returned by the config selector (e.g., xDS HTTP filters).
+  config_selector->AddFilters(builder);
+  // TODO(roth, ctiller): When we implement the retry interceptor, that
+  // needs to be added *after* the filters added by the config selector.
   const bool enable_retries =
       !channel_args_.WantMinimalStack() &&
       channel_args_.GetBool(GRPC_ARG_ENABLE_RETRIES).value_or(true);
   if (enable_retries) {
     Crash("call v3 stack does not yet support retries");
   }
+  // Create call destination.
   auto top_of_stack_call_destination = builder.Build(call_destination_);
   // Send result to data plane.
   if (!top_of_stack_call_destination.ok()) {
@@ -1254,6 +1345,9 @@ void ClientChannel::StartIdleTimer() {
                     }
                   });
   });
+  auto arena = SimpleArenaAllocator(0)->MakeArena();
+  arena->SetContext<grpc_event_engine::experimental::EventEngine>(
+      event_engine());
   idle_activity_.Set(MakeActivity(
       std::move(promise), ExecCtxWakeupScheduler{},
       [self = std::move(self)](absl::Status status) mutable {
@@ -1265,13 +1359,14 @@ void ClientChannel::StartIdleTimer() {
                     GRPC_CHANNEL_IDLE, absl::OkStatus(),
                     "channel entering IDLE", nullptr);
                 // TODO(roth): In case there's a race condition, we
-                // might need to check for any calls that are queued
-                // waiting for a resolver result or an LB pick.
+                // might need to check for any calls that are
+                // queued waiting for a resolver result or an LB
+                // pick.
               },
               DEBUG_LOCATION);
         }
       },
-      GetContext<EventEngine>()));
+      std::move(arena)));
 }
 
 absl::Status ClientChannel::ApplyServiceConfigToCall(