grpc 1.73.0 → 1.75.0

data/src/core/channelz/ztrace_collector.h

@@ -25,6 +25,7 @@
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/util/json/json_writer.h"
+#include "src/core/util/memory_usage.h"
 #include "src/core/util/single_set_ptr.h"
 #include "src/core/util/string.h"
 #include "src/core/util/sync.h"
@@ -168,7 +169,7 @@ class ZTraceCollector {
     };
     template <typename T>
     void Append(std::pair<gpr_cycle_counter, T> value) {
-      memory_used_ += value.second.MemoryUsage();
+      memory_used_ += MemoryUsageOf(value.second);
       while (memory_used_ > memory_cap_) RemoveMostRecent();
       std::get<Collection<T> >(data).push_back(std::move(value));
     }
@@ -187,7 +188,7 @@ class ZTraceCollector {
           collection.front().first < state->most_recent) {
         state->enact = +[](Instance* instance) {
           auto& collection = std::get<Collection<T> >(instance->data);
-          const size_t ent_usage = collection.front().second.MemoryUsage();
+          const size_t ent_usage = MemoryUsageOf(collection.front().second);
           CHECK_GE(instance->memory_used_, ent_usage);
           instance->memory_used_ -= ent_usage;
           collection.pop_front();

data/src/core/client_channel/backup_poller.cc

@@ -62,10 +62,15 @@ static grpc_core::Duration g_poll_interval =
 static bool g_backup_polling_disabled;
 
 void grpc_client_channel_global_init_backup_polling() {
+#ifndef GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER
   // Disable backup polling if EventEngine is used everywhere.
   g_backup_polling_disabled = grpc_core::IsEventEngineClientEnabled() &&
                               grpc_core::IsEventEngineListenerEnabled() &&
                               grpc_core::IsEventEngineDnsEnabled();
+#else
+  // EventEngine polling not supported, keep using the backup poller.
+  g_backup_polling_disabled = false;
+#endif
   if (g_backup_polling_disabled) {
     return;
   }
@@ -155,11 +160,21 @@ static void g_poller_init_locked() {
   }
 }
 
+static bool g_can_poll_in_background() {
+#ifndef GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER
+  return grpc_iomgr_run_in_background();
+#else
+  // No iomgr "event_engines" (not to be confused with the new EventEngine)
+  // are able to run in backgroung.
+  return false;
+#endif
+}
+
 void grpc_client_channel_start_backup_polling(
     grpc_pollset_set* interested_parties) {
   if (g_backup_polling_disabled ||
       g_poll_interval == grpc_core::Duration::Zero() ||
-      grpc_iomgr_run_in_background()) {
+      g_can_poll_in_background()) {
     return;
   }
   gpr_mu_lock(&g_poller_mu);
@@ -179,7 +194,7 @@ void grpc_client_channel_stop_backup_polling(
     grpc_pollset_set* interested_parties) {
   if (g_backup_polling_disabled ||
       g_poll_interval == grpc_core::Duration::Zero() ||
-      grpc_iomgr_run_in_background()) {
+      g_can_poll_in_background()) {
     return;
   }
   grpc_pollset_set_del_pollset(interested_parties, g_poller->pollset);

data/src/core/client_channel/client_channel.cc

@@ -495,24 +495,13 @@ class ClientChannel::ClientChannelControlHelper
     return *client_channel_->stats_plugin_group_;
   }
 
-  void AddTraceEvent(TraceSeverity severity, absl::string_view message) override
+  void AddTraceEvent(absl::string_view message) override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*client_channel_->work_serializer_) {
     if (client_channel_->resolver_ == nullptr) return;  // Shutting down.
-    if (client_channel_->channelz_node_ != nullptr) {
-      client_channel_->channelz_node_->AddTraceEvent(
-          ConvertSeverityEnum(severity),
-          grpc_slice_from_copied_buffer(message.data(), message.size()));
-    }
+    GRPC_CHANNELZ_LOG(client_channel_->channelz_node_) << std::string(message);
   }
 
  private:
-  static channelz::ChannelTrace::Severity ConvertSeverityEnum(
-      TraceSeverity severity) {
-    if (severity == TRACE_INFO) return channelz::ChannelTrace::Info;
-    if (severity == TRACE_WARNING) return channelz::ChannelTrace::Warning;
-    return channelz::ChannelTrace::Error;
-  }
-
   WeakRefCountedPtr<ClientChannel> client_channel_;
 };
 
@@ -1158,12 +1147,8 @@ void ClientChannel::OnResolverResultChangedLocked(Resolver::Result result) {
   }
   // Add channel trace event.
   if (!trace_strings.empty()) {
-    std::string message =
-        absl::StrCat("Resolution event: ", absl::StrJoin(trace_strings, ", "));
-    if (channelz_node_ != nullptr) {
-      channelz_node_->AddTraceEvent(channelz::ChannelTrace::Severity::Info,
-                                    grpc_slice_from_cpp_string(message));
-    }
+    GRPC_CHANNELZ_LOG(channelz_node_)
+        << "Resolution event: " << absl::StrJoin(trace_strings, ", ");
   }
 }
 
@@ -1279,8 +1264,7 @@ void ClientChannel::UpdateServiceConfigInDataPlaneLocked(
   ChannelArgs new_args = args.SetObject(this).SetObject(saved_service_config_);
   // Construct filter stack.
   auto new_blackboard = MakeRefCounted<Blackboard>();
-  InterceptionChainBuilder builder(new_args, blackboard_.get(),
-                                   new_blackboard.get());
+  InterceptionChainBuilder builder(new_args, new_blackboard.get());
   if (idle_timeout_ != Duration::Zero()) {
     builder.AddOnServerTrailingMetadata([this](ServerMetadata&) {
       if (idle_state_.DecreaseCallCount()) StartIdleTimer();
@@ -1289,16 +1273,18 @@ void ClientChannel::UpdateServiceConfigInDataPlaneLocked(
   CoreConfiguration::Get().channel_init().AddToInterceptionChainBuilder(
       GRPC_CLIENT_CHANNEL, builder);
   // Add filters returned by the config selector (e.g., xDS HTTP filters).
-  config_selector->AddFilters(builder);
+  config_selector->AddFilters(builder, blackboard_.get(), new_blackboard.get());
   const bool enable_retries =
       !channel_args_.WantMinimalStack() &&
       channel_args_.GetBool(GRPC_ARG_ENABLE_RETRIES).value_or(true);
   if (enable_retries) {
+    RetryInterceptor::UpdateBlackboard(*saved_service_config_,
+                                       blackboard_.get(), new_blackboard.get());
     builder.Add<RetryInterceptor>();
   }
+  blackboard_ = std::move(new_blackboard);
   // Create call destination.
   auto top_of_stack_call_destination = builder.Build(call_destination_);
-  blackboard_ = std::move(new_blackboard);
   // Send result to data plane.
   if (!top_of_stack_call_destination.ok()) {
     resolver_data_for_calls_.Set(MaybeRewriteIllegalStatusCode(
@@ -1319,13 +1305,16 @@ void ClientChannel::UpdateStateLocked(grpc_connectivity_state state,
   state_tracker_.SetState(state, status, reason);
   if (channelz_node_ != nullptr) {
     channelz_node_->SetConnectivityState(state);
-    std::string trace =
-        channelz::ChannelNode::GetChannelConnectivityStateChangeString(state);
     if (!status.ok() || state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-      absl::StrAppend(&trace, " status:", status.ToString());
+      GRPC_CHANNELZ_LOG(channelz_node_)
+          << channelz::ChannelNode::GetChannelConnectivityStateChangeString(
+                 state)
+          << " status: " << status;
+    } else {
+      GRPC_CHANNELZ_LOG(channelz_node_)
+          << channelz::ChannelNode::GetChannelConnectivityStateChangeString(
+                 state);
     }
-    channelz_node_->AddTraceEvent(channelz::ChannelTrace::Severity::Info,
-                                  grpc_slice_from_cpp_string(std::move(trace)));
   }
 }
 

data/src/core/client_channel/client_channel_filter.cc

@@ -980,24 +980,13 @@ class ClientChannelFilter::ClientChannelControlHelper final
     return **chand_->owning_stack_->stats_plugin_group;
   }
 
-  void AddTraceEvent(TraceSeverity severity, absl::string_view message) override
+  void AddTraceEvent(absl::string_view message) override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     if (chand_->resolver_ == nullptr) return;  // Shutting down.
-    if (chand_->channelz_node_ != nullptr) {
-      chand_->channelz_node_->AddTraceEvent(
-          ConvertSeverityEnum(severity),
-          grpc_slice_from_copied_buffer(message.data(), message.size()));
-    }
+    GRPC_CHANNELZ_LOG(chand_->channelz_node_) << std::string(message);
   }
 
  private:
-  static channelz::ChannelTrace::Severity ConvertSeverityEnum(
-      TraceSeverity severity) {
-    if (severity == TRACE_INFO) return channelz::ChannelTrace::Info;
-    if (severity == TRACE_WARNING) return channelz::ChannelTrace::Warning;
-    return channelz::ChannelTrace::Error;
-  }
-
   ClientChannelFilter* chand_;
 };
 
@@ -1333,12 +1322,8 @@ void ClientChannelFilter::OnResolverResultChangedLocked(
   }
   // Add channel trace event.
   if (!trace_strings.empty()) {
-    std::string message =
-        absl::StrCat("Resolution event: ", absl::StrJoin(trace_strings, ", "));
-    if (channelz_node_ != nullptr) {
-      channelz_node_->AddTraceEvent(channelz::ChannelTrace::Severity::Info,
-                                    grpc_slice_from_cpp_string(message));
-    }
+    GRPC_CHANNELZ_LOG(channelz_node_)
+        << "Resolution event: " << absl::StrJoin(trace_strings, ", ");
   }
 }
 
@@ -1460,18 +1445,20 @@ void ClientChannelFilter::UpdateServiceConfigInDataPlaneLocked(
       !new_args.WantMinimalStack() &&
       new_args.GetBool(GRPC_ARG_ENABLE_RETRIES).value_or(true);
   // Construct dynamic filter stack.
+  auto new_blackboard = MakeRefCounted<Blackboard>();
   std::vector<const grpc_channel_filter*> filters =
-      config_selector->GetFilters();
+      config_selector->GetFilters(blackboard_.get(), new_blackboard.get());
   if (enable_retries) {
+    RetryFilter::UpdateBlackboard(*service_config, blackboard_.get(),
+                                  new_blackboard.get());
     filters.push_back(&RetryFilter::kVtable);
   } else {
     filters.push_back(&DynamicTerminationFilter::kFilterVtable);
   }
-  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);
+  RefCountedPtr<DynamicFilters> dynamic_filters =
+      DynamicFilters::Create(new_args, std::move(filters), blackboard_.get());
+  CHECK(dynamic_filters != nullptr);
   // Grab data plane lock to update service config.
   //
   // We defer unreffing the old values (and deallocating memory) until
@@ -1552,13 +1539,16 @@ void ClientChannelFilter::UpdateStateLocked(grpc_connectivity_state state,
   state_tracker_.SetState(state, status, reason);
   if (channelz_node_ != nullptr) {
     channelz_node_->SetConnectivityState(state);
-    std::string trace =
-        channelz::ChannelNode::GetChannelConnectivityStateChangeString(state);
     if (!status.ok() || state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-      absl::StrAppend(&trace, " status:", status.ToString());
+      GRPC_CHANNELZ_LOG(channelz_node_)
+          << channelz::ChannelNode::GetChannelConnectivityStateChangeString(
+                 state);
+    } else {
+      GRPC_CHANNELZ_LOG(channelz_node_)
+          << channelz::ChannelNode::GetChannelConnectivityStateChangeString(
+                 state)
+          << " status: " << status.ToString();
     }
-    channelz_node_->AddTraceEvent(channelz::ChannelTrace::Severity::Info,
-                                  grpc_slice_from_cpp_string(std::move(trace)));
   }
 }
 
@@ -2300,7 +2290,8 @@ class ClientChannelFilter::LoadBalancedCall::LbCallState final
   ServiceConfigCallData::CallAttributeInterface* GetCallAttribute(
       UniqueTypeName type) const override;
 
-  ClientCallTracer::CallAttemptTracer* GetCallAttemptTracer() const override;
+  ClientCallTracerInterface::CallAttemptTracer* GetCallAttemptTracer()
+      const override;
 
  private:
   LoadBalancedCall* lb_call_;
@@ -2317,7 +2308,7 @@ ClientChannelFilter::LoadBalancedCall::LbCallState::GetCallAttribute(
   return service_config_call_data->GetCallAttribute(type);
 }
 
-ClientCallTracer::CallAttemptTracer*
+ClientCallTracerInterface::CallAttemptTracer*
 ClientChannelFilter::LoadBalancedCall::LbCallState::GetCallAttemptTracer()
     const {
   return lb_call_->call_attempt_tracer();
@@ -2374,9 +2365,9 @@ class ClientChannelFilter::LoadBalancedCall::BackendMetricAccessor final
 
 namespace {
 
-ClientCallTracer::CallAttemptTracer* CreateCallAttemptTracer(
+ClientCallTracerInterface::CallAttemptTracer* CreateCallAttemptTracer(
     Arena* arena, bool is_transparent_retry) {
-  auto* call_tracer = DownCast<ClientCallTracer*>(
+  auto* call_tracer = DownCast<ClientCallTracerInterface*>(
       arena->GetContext<CallTracerAnnotationInterface>());
   if (call_tracer == nullptr) return nullptr;
   auto* tracer = call_tracer->StartNewAttempt(is_transparent_retry);

data/src/core/client_channel/client_channel_filter.h

@@ -373,7 +373,7 @@ class ClientChannelFilter::LoadBalancedCall
 
  protected:
   ClientChannelFilter* chand() const { return chand_; }
-  ClientCallTracer::CallAttemptTracer* call_attempt_tracer() const {
+  ClientCallTracerInterface::CallAttemptTracer* call_attempt_tracer() const {
     return call_attempt_tracer_;
   }
   ConnectedSubchannel* connected_subchannel() const {
@@ -434,7 +434,7 @@ class ClientChannelFilter::LoadBalancedCall
   // previous attempt yet leading to a situation where we have two active call
   // attempt tracers, and so we cannot rely on the arena to give us the right
   // tracer when performing cleanup.
-  ClientCallTracer::CallAttemptTracer* call_attempt_tracer_;
+  ClientCallTracerInterface::CallAttemptTracer* call_attempt_tracer_;
 
   absl::AnyInvocable<void()> on_commit_;
 

data/src/core/client_channel/client_channel_internal.h

@@ -54,7 +54,8 @@ class ClientChannelLbCallState : public LoadBalancingPolicy::CallState {
 
   virtual ServiceConfigCallData::CallAttributeInterface* GetCallAttribute(
       UniqueTypeName type) const = 0;
-  virtual ClientCallTracer::CallAttemptTracer* GetCallAttemptTracer() const = 0;
+  virtual ClientCallTracerInterface::CallAttemptTracer* GetCallAttemptTracer()
+      const = 0;
 };
 
 // Internal type for ServiceConfigCallData.  Handles call commits.

data/src/core/client_channel/config_selector.h

@@ -30,6 +30,7 @@
 #include "src/core/call/interception_chain.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/client_channel/client_channel_internal.h"
+#include "src/core/filter/blackboard.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
@@ -61,9 +62,14 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
 
   // The channel will call this when the resolver returns a new ConfigSelector
   // to determine what set of dynamic filters will be configured.
-  virtual void AddFilters(InterceptionChainBuilder& /*builder*/) {}
+  virtual void AddFilters(InterceptionChainBuilder& /*builder*/,
+                          const Blackboard* /*old_blackboard*/,
+                          Blackboard* /*new_blackboard*/) {}
   // TODO(roth): Remove this once the legacy filter stack goes away.
-  virtual std::vector<const grpc_channel_filter*> GetFilters() { return {}; }
+  virtual std::vector<const grpc_channel_filter*> GetFilters(
+      const Blackboard* /*old_blackboard*/, Blackboard* /*new_blackboard*/) {
+    return {};
+  }
 
   // Gets the configuration for the call and stores it in service config
   // call data.

data/src/core/client_channel/dynamic_filters.cc

@@ -137,9 +137,9 @@ namespace {
 
 absl::StatusOr<RefCountedPtr<grpc_channel_stack>> CreateChannelStack(
     const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters,
-    const Blackboard* old_blackboard, Blackboard* new_blackboard) {
+    const Blackboard* blackboard) {
   ChannelStackBuilderImpl builder("DynamicFilters", GRPC_CLIENT_DYNAMIC, args);
-  builder.SetBlackboards(old_blackboard, new_blackboard);
+  builder.SetBlackboard(blackboard);
   for (auto filter : filters) {
     builder.AppendFilter(filter);
   }
@@ -150,16 +150,15 @@ absl::StatusOr<RefCountedPtr<grpc_channel_stack>> CreateChannelStack(
 
 RefCountedPtr<DynamicFilters> DynamicFilters::Create(
     const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters,
-    const Blackboard* old_blackboard, Blackboard* new_blackboard) {
+    const Blackboard* blackboard) {
   // Attempt to create channel stack from requested filters.
-  auto p = CreateChannelStack(args, std::move(filters), old_blackboard,
-                              new_blackboard);
+  auto p = CreateChannelStack(args, std::move(filters), blackboard);
   if (!p.ok()) {
     // Channel stack creation failed with requested filters.
     // Create with lame filter instead.
     auto error = p.status();
     p = CreateChannelStack(args.Set(MakeLameClientErrorArg(&error)),
-                           {&LameClientFilter::kFilter}, nullptr, nullptr);
+                           {&LameClientFilter::kFilter}, nullptr);
   }
   return MakeRefCounted<DynamicFilters>(std::move(p.value()));
 }

data/src/core/client_channel/dynamic_filters.h

@@ -90,7 +90,7 @@ class DynamicFilters final : public RefCounted<DynamicFilters> {
 
   static RefCountedPtr<DynamicFilters> Create(
       const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters,
-      const Blackboard* old_blackboard, Blackboard* new_blackboard);
+      const Blackboard* blackboard);
 
   explicit DynamicFilters(RefCountedPtr<grpc_channel_stack> channel_stack)
       : channel_stack_(std::move(channel_stack)) {}

data/src/core/client_channel/global_subchannel_pool.cc

@@ -77,7 +77,10 @@ RefCountedPtr<Subchannel> GlobalSubchannelPool::RegisterSubchannel(
   SubchannelMap old_map2;
   MutexLock lock(&write_shard.mu);
   auto* existing = write_shard.map.Lookup(key);
-  if (existing != nullptr) return (*existing)->RefIfNonZero();
+  if (existing != nullptr) {
+    auto existing_ref = (*existing)->RefIfNonZero();
+    if (existing_ref != nullptr) return existing_ref;
+  }
   old_map1 = std::exchange(write_shard.map,
                            write_shard.map.Add(key, constructed->WeakRef()));
   MutexLock lock_read(&read_shard.mu);

data/src/core/client_channel/load_balanced_call_destination.cc

@@ -29,7 +29,7 @@ namespace grpc_core {
 namespace {
 
 void MaybeCreateCallAttemptTracer(bool is_transparent_retry) {
-  auto* call_tracer = MaybeGetContext<ClientCallTracer>();
+  auto* call_tracer = MaybeGetContext<ClientCallTracerInterface>();
   if (call_tracer == nullptr) return;
   auto* tracer = call_tracer->StartNewAttempt(is_transparent_retry);
   SetContext<CallTracerInterface>(tracer);
@@ -47,8 +47,9 @@ class LbCallState : public ClientChannelLbCallState {
     return service_config_call_data->GetCallAttribute(type);
   }
 
-  ClientCallTracer::CallAttemptTracer* GetCallAttemptTracer() const override {
-    return GetContext<ClientCallTracer::CallAttemptTracer>();
+  ClientCallTracerInterface::CallAttemptTracer* GetCallAttemptTracer()
+      const override {
+    return GetContext<ClientCallTracerInterface::CallAttemptTracer>();
   }
 };
 
@@ -239,8 +240,8 @@ void LoadBalancedCallDestination::StartCall(
               }
               // If it was queued, add a trace annotation.
               if (was_queued) {
-                auto* tracer =
-                    MaybeGetContext<ClientCallTracer::CallAttemptTracer>();
+                auto* tracer = MaybeGetContext<
+                    ClientCallTracerInterface::CallAttemptTracer>();
                 if (tracer != nullptr) {
                   tracer->RecordAnnotation("Delayed LB pick complete.");
                 }

data/src/core/client_channel/retry_filter.cc

@@ -31,7 +31,6 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/service_config/service_config.h"
 #include "src/core/service_config/service_config_call_data.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -93,39 +92,34 @@ namespace grpc_core {
 // RetryFilter
 //
 
-RetryFilter::RetryFilter(const ChannelArgs& args, grpc_error_handle* error)
-    : client_channel_(args.GetObject<ClientChannelFilter>()),
-      event_engine_(args.GetObject<EventEngine>()),
-      per_rpc_retry_buffer_size_(GetMaxPerRpcRetryBufferSize(args)),
-      service_config_parser_index_(
-          internal::RetryServiceConfigParser::ParserIndex()) {
+void RetryFilter::UpdateBlackboard(const ServiceConfig& service_config,
+                                   const Blackboard* old_blackboard,
+                                   Blackboard* new_blackboard) {
   // Get retry throttling parameters from service config.
-  auto* service_config = args.GetObject<ServiceConfig>();
-  if (service_config == nullptr) return;
   const auto* config = static_cast<const RetryGlobalConfig*>(
-      service_config->GetGlobalParsedConfig(
+      service_config.GetGlobalParsedConfig(
           RetryServiceConfigParser::ParserIndex()));
   if (config == nullptr) return;
-  // Get server name from target URI.
-  auto server_uri = args.GetString(GRPC_ARG_SERVER_URI);
-  if (!server_uri.has_value()) {
-    *error = GRPC_ERROR_CREATE(
-        "server URI channel arg missing or wrong type in client channel "
-        "filter");
-    return;
-  }
-  absl::StatusOr<URI> uri = URI::Parse(*server_uri);
-  if (!uri.ok() || uri->path().empty()) {
-    *error = GRPC_ERROR_CREATE("could not extract server name from target URI");
-    return;
+  // Get throttler.
+  RefCountedPtr<internal::RetryThrottler> throttler;
+  if (old_blackboard != nullptr) {
+    throttler = old_blackboard->Get<internal::RetryThrottler>("");
   }
-  std::string server_name(absl::StripPrefix(uri->path(), "/"));
-  // Get throttling config for server_name.
-  retry_throttle_data_ =
-      internal::ServerRetryThrottleMap::Get()->GetDataForServer(
-          server_name, config->max_milli_tokens(), config->milli_token_ratio());
+  throttler = internal::RetryThrottler::Create(config->max_milli_tokens(),
+                                               config->milli_token_ratio(),
+                                               std::move(throttler));
+  new_blackboard->Set("", std::move(throttler));
 }
 
+RetryFilter::RetryFilter(const grpc_channel_element_args& args)
+    : client_channel_(args.channel_args.GetObject<ClientChannelFilter>()),
+      event_engine_(args.channel_args.GetObject<EventEngine>()),
+      per_rpc_retry_buffer_size_(
+          GetMaxPerRpcRetryBufferSize(args.channel_args)),
+      retry_throttler_(args.blackboard->Get<internal::RetryThrottler>("")),
+      service_config_parser_index_(
+          internal::RetryServiceConfigParser::ParserIndex()) {}
+
 const RetryMethodConfig* RetryFilter::GetRetryPolicy(Arena* arena) {
   auto* svc_cfg_call_data = arena->GetContext<ServiceConfigCallData>();
   if (svc_cfg_call_data == nullptr) return nullptr;

data/src/core/client_channel/retry_filter.h

@@ -45,6 +45,10 @@ class RetryFilter final {
  public:
   static const grpc_channel_filter kVtable;
 
+  static void UpdateBlackboard(const ServiceConfig& service_config,
+                               const Blackboard* old_blackboard,
+                               Blackboard* blackboard);
+
  private:
   // Old filter-stack style call implementation, in
   // retry_filter_legacy_call_data.{h,cc}
@@ -60,8 +64,8 @@ class RetryFilter final {
 
   const internal::RetryMethodConfig* GetRetryPolicy(Arena* arena);
 
-  RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data() const {
-    return retry_throttle_data_;
+  RefCountedPtr<internal::RetryThrottler> retry_throttler() const {
+    return retry_throttler_;
   }
 
   ClientChannelFilter* client_channel() const { return client_channel_; }
@@ -80,15 +84,14 @@ class RetryFilter final {
                  0, INT_MAX);
   }
 
-  RetryFilter(const ChannelArgs& args, grpc_error_handle* error);
+  explicit RetryFilter(const grpc_channel_element_args& args);
 
   static grpc_error_handle Init(grpc_channel_element* elem,
                                 grpc_channel_element_args* args) {
     CHECK(args->is_last);
     CHECK(elem->filter == &kVtable);
-    grpc_error_handle error;
-    new (elem->channel_data) RetryFilter(args->channel_args, &error);
-    return error;
+    new (elem->channel_data) RetryFilter(*args);
+    return absl::OkStatus();
   }
 
   static void Destroy(grpc_channel_element* elem) {
@@ -105,7 +108,7 @@ class RetryFilter final {
   ClientChannelFilter* client_channel_;
   grpc_event_engine::experimental::EventEngine* const event_engine_;
   size_t per_rpc_retry_buffer_size_;
-  RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data_;
+  RefCountedPtr<internal::RetryThrottler> retry_throttler_;
   const size_t service_config_parser_index_;
 };
 

data/src/core/client_channel/retry_filter_legacy_call_data.cc

@@ -537,8 +537,8 @@ bool RetryFilter::LegacyCallData::CallAttempt::ShouldRetry(
   // Check status.
   if (status.has_value()) {
     if (GPR_LIKELY(*status == GRPC_STATUS_OK)) {
-      if (calld_->retry_throttle_data_ != nullptr) {
-        calld_->retry_throttle_data_->RecordSuccess();
+      if (calld_->retry_throttler_ != nullptr) {
+        calld_->retry_throttler_->RecordSuccess();
       }
       GRPC_TRACE_LOG(retry, INFO)
           << "chand=" << calld_->chand_ << " calld=" << calld_
@@ -562,8 +562,8 @@ bool RetryFilter::LegacyCallData::CallAttempt::ShouldRetry(
   // things like failures due to malformed requests (INVALID_ARGUMENT).
   // Conversely, it's important for this to come before the remaining
   // checks, so that we don't fail to record failures due to other factors.
-  if (calld_->retry_throttle_data_ != nullptr &&
-      !calld_->retry_throttle_data_->RecordFailure()) {
+  if (calld_->retry_throttler_ != nullptr &&
+      !calld_->retry_throttler_->RecordFailure()) {
     GRPC_TRACE_LOG(retry, INFO)
         << "chand=" << calld_->chand_ << " calld=" << calld_
         << " attempt=" << this << ": retries throttled";
@@ -1471,7 +1471,7 @@ void RetryFilter::LegacyCallData::SetPollent(grpc_call_element* elem,
 RetryFilter::LegacyCallData::LegacyCallData(RetryFilter* chand,
                                             const grpc_call_element_args& args)
     : chand_(chand),
-      retry_throttle_data_(chand->retry_throttle_data()),
+      retry_throttler_(chand->retry_throttler()),
       retry_policy_(chand->GetRetryPolicy(args.arena)),
       retry_backoff_(
           BackOff::Options()

data/src/core/client_channel/retry_filter_legacy_call_data.h

@@ -370,7 +370,7 @@ class RetryFilter::LegacyCallData final {
 
   RetryFilter* chand_;
   grpc_polling_entity* pollent_;
-  RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data_;
+  RefCountedPtr<internal::RetryThrottler> retry_throttler_;
   const internal::RetryMethodConfig* retry_policy_ = nullptr;
   BackOff retry_backoff_;